serveur-d-authentification/venv/lib/python3.10/site-packages/requests/__pycache__/utils.cpython-310.pyc

o
<00>Q<EFBFBD>j<EFBFBD><6A><00>@
sBUdZd
dl
mZ
d
dlZd
dlZd
dlZd
dlZd
dlZd
dlZd
dl	Z	d
dl
Z
d
dlZd
dlZd
dl
Z
d
dlmZ
d
dlmZmZ
d
dlmZmZmZmZmZmZ
d
dlmZmZ
dd	lmZ
dd
lmZ
ddl m!Z!m"Z"m#Z#m$Z$
ddl%m&Z'
dd
l(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5
ddl(m6Z7
ddl8m9Z9
ddl:m;Z;m<Z<m=Z=m>Z>
ddl?m@Z@
er<>d
dlAmBZB
d
dlmCZC
ddlm%ZD
ddlEmFZFmGZGmHZH
dZIdeJd<e<1E>K<EFBFBD>ZLdeJd<ddd<1D>ZMdeJd<ed<1F>
ZNed <20>
ZOd!<21>Pe<07>Qd"ed#d$<24>
d%<00><02>
ZRdeJd&<e
jSd'k<02>
rd<>d+d,<2C>ZTd<54>d-d.<2E>Z/d<>d2d3<64>ZUd<55>d7d8<64>ZV	9d<39>d<EFBFBD>d>d?<3F>ZWd<57>dBdC<64>ZXd<58>dEdF<64>ZYejZd<5A>dIdJ<64><04>
Z[d<>dNdO<64>Z\ed<>dQdR<64><04>
Z]ed<>dUdR<64><04>
Z]d<>dXdR<64>Z]d<>dZd[<5B>Z^d<>d]d^<5E>Z_d<5F>d<EFBFBD>d`da<64>Z`d<>ddde<64>Zad<61>dhdi<64>Zbd<62>dkdl<64>Zcd<63>dodp<64>Zdd<64>dsdt<64>Zed<65>dzd{<7B>Zfed<>d<EFBFBD>d<EFBFBD><64><04>
Zged<>d<EFBFBD>d<EFBFBD><64><04>
Zgd<67>d<EFBFBD>d<EFBFBD><64>Zgd<67>d<EFBFBD>d<EFBFBD><64>Zheid<69><64>
ZjdeJd<4A><d<>d<EFBFBD>d<EFBFBD><64>Zkd<6B>d<EFBFBD>d<EFBFBD><64>Zld<6C>d<EFBFBD>d<EFBFBD><64>Zmd<6D>d<EFBFBD>d<EFBFBD><64>Znd<6E>d<EFBFBD>d<EFBFBD><64>Zod<6F>d<EFBFBD>d<EFBFBD><64>ZpejZd<5A>d<EFBFBD>d<EFBFBD><64><04>
Zqd<71>d<EFBFBD>d<EFBFBD><64>Zrd<72>d<EFBFBD>d<EFBFBD>d<EFBFBD><64>Zsd<73>d<EFBFBD>d<EFBFBD><64>Zt	#d<>d<EFBFBD>d<EFBFBD>d<EFBFBD><64>Zud<75>d<EFBFBD>d<EFBFBD>d<EFBFBD><64>Zvd<76>d<EFBFBD>d<EFBFBD><64>Zwd<77>d<EFBFBD>d<EFBFBD><64>Zxd<78><64>yd<79><64>
Zzezd<7A>Z{ezd<7A>Z|d<>d<EFBFBD>d<EFBFBD><64>Z}d<>d<EFBFBD>dÄZ~<7E>
dd<>dƄZ<5A>
d
d<>dɄZ<><5A>
dd<>d΄Z<><5A>
dd<>dЄZ<><5A>
dd<>dԄZ<>dS(
z<>
requests.utils
~~~~~~~~~~~~~~

This module provides utility functions that are used within Requests
that are also useful for external consumption.
<EFBFBD>)
<01>annotationsN)
<01>OrderedDict)<02>	Generator<6F>Iterable)<06>
TYPE_CHECKING<4E>Any<6E>Final<61>TypeVar<61>cast<73>overload)<02>make_headers<72>	parse_url<72>
)
<01>certs<74>
<01>__version__)<04>_HEADER_VALIDATORS_BYTE<54>_HEADER_VALIDATORS_STR<54>HEADER_VALIDATORS<52>to_native_string)
<01>
SupportsItems)
<0A>Mapping<6E>bytes<65>
getproxies<EFBFBD>getproxies_environment<6E>
integer_types<65>is_urllib3_1<5F>proxy_bypass<73>proxy_bypass_environment<6E>quote<74>str<74>unquote<74>urlparse<73>
urlunparse)
<01>parse_http_list<73>
<01>cookiejar_from_dict)<04>FileModeWarning<6E>
InvalidHeader<65>
InvalidURL<EFBFBD>UnrewindableBodyError)
<01>CaseInsensitiveDict)
<01>	CookieJar)
<01>BufferedWriter)
<01>_types)<03>PreparedRequest<73>Request<73>Response)z.netrc<72>_netrcr<00>NETRC_FILESr <00>DEFAULT_CA_BUNDLE_PATH<54>Pi<>
)<02>http<74>https<70>
DEFAULT_PORTS<54>_KT<4B>_VTz, z,\s*T)
<01>accept_encodingzaccept-encoding<6E>DEFAULT_ACCEPT_ENCODING<4E>win32<33>host<73>return<72>boolc
	C
s<>zd
dl}
Wn
t
y


YdSwz|
<01>|
jd<03>}t|
<01>|d<04>d
<00>
}|
<01>|d<05>d
}Wnttfy8


YdSw|r=|s?dS|<04>d<06>
}t	d|<04>}|D]*}|dkrXd|v
rX
d	S|<05>
dd
<EFBFBD>}|<05>
dd<0C>}|<05>
d
d<08>}t<0B>||tj
<0A>ru
d	SqKdS)Nr
Fz;Software\Microsoft\Windows\CurrentVersion\Internet Settings<67>ProxyEnable<6C>
ProxyOverride<64>
;z<local><3E>
.Tz\.<2E>
*z.*<2A>
?)<0E>winreg<65>ImportError<6F>OpenKey<65>HKEY_CURRENT_USER<45>int<6E>QueryValueEx<45>OSError<6F>
ValueError<EFBFBD>split<69>filter<65>replace<63>re<72>match<63>
I)r>rG<00>internetSettings<67>proxyEnable<6C>
proxyOverride<64>test<73>rY<00>q/home/sorel/systeme_gestion_cerfig/serveur-d-authentification/venv/lib/python3.10/site-packages/requests/utils.py<70>proxy_bypass_registrycs<



<02>


<04>

<02>










<02>r[c

C
st<00>rt
|<00>
St|<00>
S)
z<>Return True, if the host should be bypassed.

        Checks proxy settings gathered from the environment, if specified,
        or the registry.
        )rrr[)
r>rYrYrZr<00>s
r<00>
d<>6_t.SupportsItems[Any, Any] | Iterable[tuple[Any, Any]]<5D>Iterable[tuple[Any, Any]]c

C
st|t
<01>r	|<00><02>S|S)
z/Returns an internal sequence dictionary update.)<03>
isinstance<EFBFBD>_SupportsItems<6D>items)
r\rYrYrZ<00>dict_to_sequence<63>s

rb<00>
orrKc
	C
s8
d}
d
}tst
|t<02>r|<00>d<02>
}t|d<03>rt|<00>
}
n2t|d<04>r#|j}
n)t|d<05>rLz|<00><06>}Wntjt	fy:


Ynwt
<EFBFBD>|<03>
j}
d|j
v
rLt<0E>dt<10>
t|d<08>r<>z|<00><11>}Wntyf


|
du
rd|
}Yn)wt|d	<09>r<>|
dur<>z|<00>d
d
<EFBFBD>
|<00><11>}
|<00>|p<>d
<01>

Wnty<>


d
}
Yn
w|
dur<>d
}
td
|
|<00>S)Nr
<00>utf-8<>__len__<5F>len<65>fileno<6E>
ba%
Requests has determined the content-length for this request using the binary size of the file: however, the file has been opened in text mode (i.e. without the 'b' flag in the mode). This may lead to an incorrect content-length. In Requests 3.0, support will be removed for files in text mode.<2E>tell<6C>seek<65>)rr_r <00>encode<64>hasattrrfrg<00>io<69>UnsupportedOperation<6F>AttributeError<6F>os<6F>fstat<61>st_size<7A>mode<64>warnings<67>warnr'rirMrj<00>max)rc<00>total_length<74>current_positionrgrYrYrZ<00>	super_len<65>sN











<02>

<04>




<04><02>


<02>
rzF<>url<72>
_t.UriType<70>raise_errors<72>tuple[str, str] | Nonec
	C
s8
t|t
<01>r
|<00>d
<01>
}tj<04>d<02>
}|du
r|f
}ndd<05>tD<00>
}zpddlm}m}
d}|D]}tj	<09>
|<07>
}tj	<09>|<08>
r>|}
n
q,|durFWdSt|<00>
}	|	j
}
|
durTWdSz+||<06>
<01>|
<EFBFBD>
}|rxt|<0B>
r||drhdn
d}||pod	|d
ptd	fWWSWWdSWWdS|tfy<>


|
r<><72>YWdSwttfy<>


YdSw)z;Returns the Requests tuple auth for a given url from netrc.rd<00>NETRCNc
s
s<00>|]}
d|
<01><00>V
qd
S)z~/NrY)<02>.0<EFBFBD>
frYrYrZ<00>	<genexpr><3E>s<02>z!get_netrc_auth.<locals>.<genexpr>r
)<02>NetrcParseError<6F>netrcr<00>rk)r_r<00>decoderq<00>environ<6F>getr3r<>r<><00>path<74>
expanduser<EFBFBD>existsr"<00>hostname<6D>authenticators<72>anyrMrHrp)
r{r}<00>
netrc_file<EFBFBD>netrc_locationsr<73>r<><00>
netrc_pathr<EFBFBD><00>loc<6F>rir>r2<00>login_irYrYrZ<00>get_netrc_auth<74>sF









<02>





<10>
<08><02>
<02>r<EFBFBD><00>obj<62>
str | Nonec
C
sRt|d
d<02>}
|
r!t
|
ttf<02>r#|
ddkr%|
ddkr'tj<05>|
<01>
SdSdSdSdS)z0Tries to guess the filename of the given object.<2E>nameNr
<00>
<<3C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
>)<07>getattrr_r rrqr<><00>basename)r<>r<>rYrYrZ<00>guess_filename
s*

<10>r<EFBFBD>r<>c
	C
s<>tj
<01>|<00>
r|Stj
<01>|<00>
\}
}|
r2tj
<01>|
<01>
s2tj
<01>|
<01>
\}
}|s#nd
<01>||g<02>
}|
r2tj
<01>|
<01>
rt<05>|
<01>
s9|St<05>|
<01>
}||<04><08>v
rF|Stj
<01>	|<02>d
<01>
d<00>
d}t
j|d<03>
\}}zt<00>||<04>
|<02>
<01>
Wt<00>|<06>

|St<00>|<06>

w)z<>Replace nonexistent paths that look like they refer to a member of a zip
    archive with the location of an extracted copy of the target, or else
    just return the provided path unchanged.
    <20>
/r<>)
<01>suffix)rqr<>r<>rO<00>join<69>zipfile<6C>
is_zipfile<EFBFBD>ZipFile<6C>namelist<73>splitext<78>tempfile<6C>mkstemp<6D>write<74>read<61>close)r<><00>archive<76>member<65>prefix<69>zip_filer<65><00>fd<66>extracted_pathrYrYrZ<00>extract_zipped_paths"
s*



<10>








<0C>r<EFBFBD><00>filename<6D>%Generator[BufferedWriter, None, None]c
c
sz<00>tj
tj<03>|<00>
d
<01>
\}
}z"t<02>|
d<02><02>}|V
Wd<00>
n1s"w



Y
t<02>||<00>
WdSty<


t<02>|<02>

<00>w)z-Write a file to the disk in an atomic fashion)
<01>dir<69>wbN)	r<>r<>rqr<><00>dirname<6D>fdopenrQ<00>
BaseException<6F>remove)r<><00>tmp_descriptor<6F>tmp_name<6D>tmp_handlerrYrYrZ<00>atomic_openH
s<02>


<1C>



<02>r<EFBFBD><00>value<75>4Mapping[Any, Any] | Iterable[tuple[Any, Any]] | None<6E>dict[Any, Any] | Nonec

C
s.|d
urd
St|t
tttf<04>rtd<02>
<01>
t|<00>
S)aTake an object and test to see if it can be represented as a
    dictionary. Unless it can not be represented as such, return an
    OrderedDict, e.g.,

    ::

        >>> from_key_val_list([('key', 'val')])
        OrderedDict([('key', 'val')])
        >>> from_key_val_list('string')
        Traceback (most recent call last):
        ...
        ValueError: cannot encode objects that are not 2-tuples
        >>> from_key_val_list({'key': 'val'})
        OrderedDict([('key', 'val')])

    :rtype: OrderedDict
    N<>+cannot encode objects that are not 2-tuples)r_r rr@rKrNr<00>
r<>rYrYrZ<00>from_key_val_listU
s


r<><00>Nonec


C
<01>dS<00>
NrYr<>rYrYrZ<00>to_key_val_listr
s
r<><00>6_t.SupportsItems[_KT, _VT] | Iterable[tuple[_KT, _VT]]<5D>list[tuple[_KT, _VT]]c


C
r<>r<>rYr<>rYrYrZr<>t
<00><03>=_t.SupportsItems[_KT, _VT] | Iterable[tuple[_KT, _VT]] | None<6E>list[tuple[_KT, _VT]] | Nonec

C
sD|d
urd
St|t
tttf<04>rtd<02>
<01>
t|t<06>rt|<00><08><00>
St|<00>
S)a<>
Take an object and test to see if it can be represented as a
    dictionary. If it can be, return a list of tuples, e.g.,

    ::

        >>> to_key_val_list([('key', 'val')])
        [('key', 'val')]
        >>> to_key_val_list({'key': 'val'})
        [('key', 'val')]
        >>> to_key_val_list('string')
        Traceback (most recent call last):
        ...
        ValueError: cannot encode objects that are not 2-tuples

    :rtype: list
    Nr<4E>)	r_r rr@rKrNr`<00>listrar<>rYrYrZr<>x
s



<02>	list[str]c
C
sXg}
t|<00>
D]#}|d
d<02>|dd
<01>krdkr$n
nt
|dd<03><00>
}|
<01>|<02>

q|
S)aParse lists as described by RFC 2068 Section 2.

    In particular, parse comma-separated lists where the elements of
    the list may include quoted-strings.  A quoted-string could
    contain a comma.  A non-quoted string could have quotes in the
    middle.  Quotes are removed automatically after parsing.

    It basically works like :func:`parse_set_header` just that items
    may appear multiple times and case sensitivity is preserved.

    The return value is a standard :class:`list`:

    >>> parse_list_header('token, "quoted value"')
    ['token', 'quoted value']

    To create a header from the :class:`list` again, use the
    :func:`dump_header` function.

    :param value: a string with a list header.
    :return: :class:`list`
    :rtype: list
    Nrr<><00>
")<03>_parse_list_header<65>unquote_header_value<75>append)r<><00>result<6C>itemrYrYrZ<00>parse_list_header<65>
s
(



r<><00>dict[str, str | None]c
C
sxi}
t|<00>
D]3}d
|v
rd|
|<q|<02>
d
d<03>\}}|dd<03>|dd<02>kr+dkr5n
nt|dd<04><00>
}||
|<q|
S)a^Parse lists of key, value pairs as described by RFC 2068 Section 2 and
    convert them into a python dict:

    >>> d = parse_dict_header('foo="is a fish", bar="as well"')
    >>> type(d) is dict
    True
    >>> sorted(d.items())
    [('bar', 'as well'), ('foo', 'is a fish')]

    If there is no value for a key it will be `None`:

    >>> parse_dict_header('key_without_value')
    {'key_without_value': None}

    To create a header from the :class:`dict` again, use the
    :func:`dump_header` function.

    :param value: a string with a dict header.
    :return: :class:`dict`
    :rtype: dict
    <20>
=Nrr<>r<>)r<>rOr<>)r<>r<>r<>r<>rYrYrZ<00>parse_dict_header<65>
s




(




r<><00>is_filenamecC
s^|r-|d
|dkrdkr-n
|S|dd<02>}|
r#|dd<06>dkr-|<00>dd<08><02>d	d<03>S|S)
z<EFBFBD>Unquotes a header value.  (Reversal of :func:`quote_header_value`).
    This does not use the real unquoting but what browsers are actually
    using for quoting.

    :param value: the header value to unquote.
    :rtype: str
    r
r<>r<>rNrkz\\<5C>
\z\")
rQ)r<>r<>rYrYrZr<><00>
s"<0C>

r<><00>cjr,c
C
sd
d<02>|D<00>
}
|
S)z<>Returns a key/value dictionary from a CookieJar.

    :param cj: CookieJar object to extract cookies from.
    :rtype: dict
    c
S
si|]}
|
j|
j
<01>qSrY)r<>r<>)r<><00>cookierYrYrZ<00>
<dictcomp><3E>
sz'dict_from_cookiejar.<locals>.<dictcomp>rY<00>r<><00>cookie_dictrYrYrZ<00>dict_from_cookiejar<61>
s
r<>r<><00>dict[str, str]cC
s
t|
|<00>S)
z<>Returns a CookieJar from a key/value dictionary.

    :param cj: CookieJar to insert cookies into.
    :param cookie_dict: Dict of key/values to insert into CookieJar.
    :rtype: CookieJar
    r%r<>rYrYrZ<00>add_dict_to_cookiejar<61>
s
r<><00>contentc
C
sTt<00>
d
t<02>
tjdtjd<03>}
tjdtjd<03>}t<03>d<05>
}|
<01>|<00>
|<02>|<00>
|<03>|<00>
S)zlReturns encodings from given content string.

    :param content: bytestring to extract encodings from.
    z<>In requests 3.0, get_encodings_from_content will be removed. For more information, please see the discussion on issue #2266. (This warning should only appear once.)z!<meta.*?charset=["\']*(.+?)["\'>])
<01>flagsz+<meta.*?content=["\']*;?charset=(.+?)["\'>]z$^<\?xml.*?encoding=["\']*(.+?)["\'>])rurv<00>DeprecationWarningrR<00>compilerT<00>findall)r<><00>
charset_re<EFBFBD>	pragma_re<72>xml_rerYrYrZ<00>get_encodings_from_content
s<04>	



<02><02><02>r<EFBFBD><00>header<65>tuple[str, dict[str, Any]]c

C
s<>|<00>d
<01>
}
|
d<00>
<01>|
dd<04>}}i}d}|D]+}|<06>
<01>}|rC|<06>d<06>
}dkrC|d|<07><00>
|<05>
}||dd<04><00>
|<05>
}	|	||<08><03><q||fS)z<>Returns content type and parameters from given header.

    :param header: string
    :return: tuple containing content type and dictionary of
         parameters.
    rCr
rNz"' r<>r<>)rO<00>strip<69>find<6E>lower)
r<EFBFBD><00>tokens<6E>content_type<70>params<6D>params_dict<63>strip_chars<72>param<61>idx<64>keyr<79>rYrYrZ<00>_parse_content_type_header#s








<02>
r<><00>headers<72>CaseInsensitiveDict[str]c
C
sP|<00>d
<01>
}
|
s	dSt
|
<01>
\}
}d|vr|d<00>d<04>
Sd|
vr dSd|
vr&dSdS)	z}Returns encodings from given HTTP Header Dict.

    :param headers: dictionary to extract encoding from.
    :rtype: str
    zcontent-typeN<65>charsetz'"<22>textz
ISO-8859-1zapplication/jsonrd)r<>r<>r<>)r<>r<>r<>rYrYrZ<00>get_encoding_from_headers9s



<04>r<EFBFBD><00>iterator<6F>Iterable[bytes]<5D>
rr1<00>"Generator[str | bytes, None, None]cc
sj<00>|
jd
ur
|Ed
H
d
St
<01>|
j<00>
dd<03>
}|D]}|<02>|<03>
}|r$|V
q|jddd<06>}|r3|V
d
Sd
S)zStream decodes an iterator.NrQ<00>
<01>errors<72>T)
<01>final)<04>encoding<6E>codecs<63>getincrementaldecoderr<72>)r
r
<00>decoder<65>chunk<6E>rvrYrYrZ<00>stream_decode_response_unicodeRs<02>








<02>



<04>r
<00>stringr<00>slice_length<74>
int | None<6E>Generator[bytes, None, None]c
C
r<>r<>rY<00>r
r
rYrYrZ<00>iter_sliceser<>r
<00>Generator[str, None, None]c
C
r<>r<>rYr
rYrYrZr
ir<><00>bytes | str<74>"Generator[bytes | str, None, None]cc
sX<00>d
}|
dus|
d
k
rt|<00>
}
|t|<00>
kr*||||
<00>V
||
7}|t|<00>
ksdSdS)z Iterate over slices of a string.r
N)
rf)r
r
<00>posrYrYrZr
ms<02>




<14><>str | bytes | Nonec
C
s<>t<00>
d
t<02>
|jdur
dSg}
t|j<05>
}|r,zt|j|<02>WSty+


|
<01>|<02>

Yn
wzt|j|p3ddd<05>WSt	yC


|jYSw)z<>Returns the requested content back in unicode.

    :param r: Response object to get unicode content from.

    Tried:

    1. charset from content-type
    2. fall back and replace all unicode characters

    :rtype: str
    z<>In requests 3.0, get_unicode_from_response will be removed. For more information, please see the discussion on issue #2266. (This warning should only appear once.)NrdrQr
)
rurvr<>r<>r<>r<>r <00>UnicodeErrorr<72><00>	TypeError)r
<00>tried_encodingsr
rYrYrZ<00>get_unicode_from_responseys&<04>






<02>



<02>r
zBABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~<7E>UNRESERVED_SET<45>uric
	C
s<>|<00>d
<01>
}
t
dt|
<01>
<01>D]Q}|
|dd<04>}t|<03>
dkrT|<03><03>rTz	tt|d<05><02>
}Wnty8


td|<03>d<07><03>
<01>
w|tvrJ||
|dd<08>|
|<qd
|
|<00><00>|
|<qd
|
|<00><00>|
|<qd	<09>	|
<01>
S)
z<EFBFBD>Un-escape any percent-escape sequences in a URI that are unreserved
    characters. This leaves all reserved, illegal and non-ASCII bytes encoded.

    :rtype: str
    <20>
%rr
rk<00>z"Invalid percent-escape sequence: '<27>
'Nr<4E>)
rO<00>rangerf<00>isalnum<75>chrrKrNr)r
r<>)r
<00>parts<74>
i<>
h<>
crYrYrZ<00>unquote_unreserved<65>s







<02>


r*
c
C
s:d
}
d}z	tt
|<00>
|
d<03>WSty


t||d<03>YSw)z<>Re-quote the given URI.

    This function passes the given URI through an unquote/quote cycle to
    ensure that it is fully and consistently quoted.

    :rtype: str
    z!#$%&'()*+,/:;=?@[]~z!#$&'()*+,/:;=?@[]~)
<01>safe)rr*
r))r
<00>safe_with_percent<6E>safe_without_percentrYrYrZ<00>requote_uri<72>s


<02>r.
<00>ip<69>netcC
slt<00>
d
t<02>|<00>
<01>d}|
<01>d<03>
\}}t<00>
d
t<02>tt|<04>
<01>
<01>
<01>d}t<00>
d
t<02>|<03>
<01>d|@}||@||@kS)z<>This function allows you to check if an IP belongs to a network subnet

    Example: returns True if ip = 192.168.1.1 and net = 192.168.1.0/24
             returns False if ip = 192.168.1.1 and net = 192.168.100.0/24

    :rtype: bool
    z=Lr
r<>)<07>struct<63>unpack<63>socket<65>	inet_atonrO<00>dotted_netmaskrK)r/
r0
<00>ipaddr<64>netaddr<64>bits<74>netmask<73>networkrYrYrZ<00>address_in_network<72>s




r;
<00>maskc
C
s&d
dd|>dA}
t<00>
t<02>d|
<01><02>
S)z<>Converts mask from /xx format to xxx.xxx.xxx.xxx

    Example: if mask is 24 function returns 255.255.255.0

    :rtype: str
    l<00><EFBFBD>r<00> z>I)r3
<00>	inet_ntoar1
<00>pack)r<
r8
rYrYrZr5
<00>s
r5
<00>	string_ipc

C
s&zt<00>
|<00>

WdSty


Yd
Sw)z
    :rtype: bool
    FT)r3
r4
rM)
r@
rYrYrZ<00>is_ipv4_address<73>s
<0C>
<02>rA
<00>string_networkc
C
s<>|<00>d
<01>
dkr?zt
|<00>d
<01>
d<00>
}
Wn
ty


YdSw|
dks%|
dkr'dSz
t<04>|<00>d
<01>
d<00>

WdSty>


YdSwdS)zV
    Very simple check of the cidr format in no_proxy variable.

    :rtype: bool
    r<>rFr=
r
T)<07>countrKrOrNr3
r4
rM)rB
r<
rYrYrZ<00>
is_valid_cidr<64>s



<02>

<0C>
<02>rD
<00>env_name<6D>Generator[None, None, None]c	c
s~<00>|
d
u
}d
}|rtj
<01>|<00>
}|
tj
|<zd
V
W|r,|d
ur%tj
|=d
S|tj
|<d
Sd
S|r>|d
ur9tj
|=w|tj
|<w)z<>Set the environment variable 'env_name' to 'value'

    Save previous value, yield, and then restore the previous value stored in
    the environment variable 'env_name'.

    If 'value' is None, do nothingN)rqr<>r<>)rE
r<><00>
value_changed<65>	old_valuerYrYrZ<00>set_environs <02>








<08>

rI
<00>no_proxyc
C
sZ
ddd<06>}|
}|
dur|d<08>
}
t|<00>
}|j
}|durd	S|
r}d
d<0B>|
<01>dd
<0A><02>d<0E>
D<00>
}t|<05>
rJ|D]}t|<07>
rAt||<07>r@
d	Sq2||krH
d	Sq2n3|}|jrW|d|j<07><00>7}|D]#}	|	<09>d<10>
}	||	ksh||	krk
d	Sd|	}	|<05>	|	<09>
sy|<08>	|	<09>
r|
d	SqYt
d|<03><02>
zt|<05>
}
Wntt
jfy<>


d}
Yn
wWd<00>
n1s<>w



Y
|
r<EFBFBD>d	SdS)zL
    Returns whether we should bypass proxies or not.

    :rtype: bool
    r<>r r?r<>c

S
stj
<01>|<00>
p
tj
<01>|<00><03><00>
Sr<>)rqr<>r<><00>upper)
r<>rYrYrZ<00>	get_proxy3s
z(should_bypass_proxies.<locals>.get_proxyNrJ
Tc
s
s<00>|]}
|
r|
V
qdSr<>rY)r<>r>rYrYrZr<>Es<02>z(should_bypass_proxies.<locals>.<genexpr><3E>
 r<><00>
,<2C>
:rDF)r<>r r?r<>)r"r<>rQrOrA
rD
r;
<00>port<72>lstrip<69>endswithrI
rr
r3
<00>gaierror)r{rJ
rL
<00>no_proxy_arg<72>parsedr<64><00>no_proxy_hosts<74>proxy_ip<69>host_with_portr><00>bypassrYrYrZ<00>should_bypass_proxies*sT
	








<02><02><02>	








<02>



<02><02><1C>
rZ
cC
st||
d
<01>riSt
<01>S)zA
    Return a dict of environment proxies.

    :rtype: dict
    <20>
rJ
)rZ
r)r{rJ
rYrYrZ<00>get_environ_proxiesis
r\
<00>proxies<65>dict[str, str] | NonecC
sv|
pi}
t|<00>
}|j
d
ur|
<01>|j|
<01>d<02>
<01>S|jd|j
|jd|j
dg}d
}|D]
}||
vr8|
|}
|Sq+|S)z<>Select a proxy for the url, if applicable.

    :param url: The url being for the request
    :param proxies: A dictionary of schemes or schemes and hosts to proxy URLs
    N<>allz://zall://)r"r<>r<><00>scheme)r{r]
<00>urlparts<74>
proxy_keys<EFBFBD>proxy<78>	proxy_keyrYrYrZ<00>select_proxyus"






<04>



<02>re
<00>request<73>Request | PreparedRequest<73>	trust_envc	C
sz|
d
u
r|
n
i}
tt
|j<02>}t|<03>
j}|
<01>d<02>
}|
<01><06>}|r;t||d<03>s;t||d<03>}|<07>||<07>d<04>
<01>}|r;|<06>	||<08>
|S)a<>
This method takes proxy information from a request and configuration
    input to resolve a mapping of target proxies. This will consider settings
    such as NO_PROXY to strip proxy configurations.

    :param request: Request or PreparedRequest
    :param proxies: A dictionary of schemes or schemes and hosts to proxy URLs
    :param trust_env: Boolean declaring whether to trust environment configs

    :rtype: dict
    NrJ
r[
r_
)
r
r r{r"r`
r<><00>copyrZ
r\
<00>
setdefault)	rf
r]
rh
r{r`
rJ
<00>new_proxies<65>environ_proxiesrc
rYrYrZ<00>resolve_proxies<65>s








rm
<00>python-requestsr<73>c

C
s|<00>d
t<00><00>S)zO
    Return a string representing the default user agent.

    :rtype: str
    r<>r)
r<>rYrYrZ<00>default_user_agent<6E>sro
cC
stt
<01>td
dd<03><04>
S)z9
    :rtype: requests.structures.CaseInsensitiveDict
    z*/*z
keep-alive)z
User-AgentzAccept-Encoding<6E>Accept<70>
Connection)r+ro
r<rYrYrYrZ<00>default_headers<72>s


<04><04>rr
<00>list[dict[str, str]]c
	
C
s<>g}
d
}|<00>|<02>
}|s
|
St
<01>d|<00>D]M}z
|<03>dd<04>\}}Wnty-


|d}}Yn
wd|<04>d<07>
i
}|<05>d<03>
D] }z	|<07>d<08>
\}}Wn
tyO


Y
nw|<00>|<02>
||<08>|<02>
<q:|
<01>|<06>

q|
S)	z<>Return a list of parsed link headers proxies.

    i.e. Link: <http:/.../front.jpeg>; rel=front; type="image/jpeg",<http://.../back.jpeg>; rel=back;type="image/jpeg"

    :rtype: list
    z '"z, *<rCrr<>r{z<> '"r<>)r<>rRrOrNr<>)	r<><00>links<6B>
replace_chars<72>valr{r<><00>linkr<6B>r<>rYrYrZ<00>parse_header_links<6B>s*






<02>



<02>rx
<00>
<00>asciirk<00><00>datac
C
s<>|d
d<02>}
|
tj
tjfvrdS|
d
d<04>tjkrdS|
d
d<06>tjtjfvr)dS|
<01>t<07>
}|dkr4d	S|dkrN|
d
d
d<06>tkrCd
S|
dd
d<06>tkrNdS|dkrf|
d
d<04>t	kr\d
S|
dd
<01>t	krfdSd
S)z
    :rtype: str
    N<>zutf-32r{
z	utf-8-sigrkzutf-16r
rdz	utf-16-berz	utf-16-lez	utf-32-bez	utf-32-le)
r	
<00>BOM_UTF32_LE<4C>BOM_UTF32_BE<42>BOM_UTF8<46>BOM_UTF16_LE<4C>BOM_UTF16_BErC
<00>_null<6C>_null2<6C>_null3)r|
<00>sample<6C>	nullcountrYrYrZ<00>guess_json_utf<74>s*


















r<>
<00>
new_schemecC
svt|<00>
}|\}}}}}}}	|j
}
|
s||
}
}|r%tt|
<EFBFBD>}
d
<01>||
g<02>
}
|dur+|
}|dur1d}t||
|d||	f<06>
S)z<>Given a URL that may or may not have a scheme, prepend the given scheme.
    Does not replace a present scheme with the one provided as an argument.

    :rtype: str
    <20>
@Nr<4E>)r
<00>netlocr
r r<>r#)r{r<>
rU
r`
<00>auth<74>_host<73>_portr<74><00>query<72>fragmentr<74>
rYrYrZ<00>prepend_scheme_if_neededs









r<>
<00>tuple[str, str]c
	C
s@t|<00>
}
z
t
|
j<02>
t
|
j<03>
f}W|Sttfy


d
}Y|Sw)z{Given a url with authentication components, extract them into a tuple of
    username,password.

    :rtype: (str,str)
    )r<>r<>)r"r!<00>username<6D>passwordrpr
)r{rU
r<>
rYrYrZ<00>get_auth_from_url.s<10>
<02>r<EFBFBD>
<00>tuple[str | bytes, str | bytes]c
C
s$|\}
}t||
d
<01>
t||d<02>
dS)z<>Verifies that header parts don't contain leading whitespace
    reserved characters, or return characters.

    :param header: tuple, in the format (name, value).
    r
rN)
<01>_validate_header_part)r<>r<>r<>rYrYrZ<00>check_header_validity?s

r<>
<00>header_part<72>str | bytes<65>header_validator_indexcC
sxt|
t
<01>r
t|}nt|
t<03>rt|}ntd
|
<01>d|<00>dt|
<01>
<01><00><06>
<01>
|<03>|
<01>
s:|dkr.dn
d}td|<04>d|
<01><02><04>
<01>
dS)	Nz
Header part (z) from z# must be of type str or bytes, not r
r<>r<>zTInvalid leading whitespace, reserved character(s), or return character(s) in header z: )r_r rrrr(<00>typerS)r<>r<>
r<>
<00>	validator<6F>header_kindrYrYrZr<>
Js&







<04><04>




<04>
<04><04><04>r<EFBFBD>
c
C
sFt|<00>
\}
}}}}}|s||}}|<02>
d
d<02>d}t|
||||df<06>
S)zW
    Given a url remove the fragment and the authentication part.

    :rtype: str
    r<>
rr<>r<>)r"<00>rsplitr#)r{r`
r<>
r<>r<>r<>
<00>	_fragmentrYrYrZ<00>
urldefragauthbs


r<>
<00>prepared_requestr/c
C
sRt|j
d
d<02>}
|
du
r%t|jt<04>r%z|
|j<03>

WdSty$


td<03>
<01>
wtd<04>
<01>
)zfMove file pointer back to its recorded starting position
    so it can be read again on redirect.
    rjNz;An error occurred when rewinding request body for redirect.z+Unable to rewind request body for redirect.)r<><00>bodyr_<00>_body_positionrrMr*)r<>
<00>	body_seekrYrYrZ<00>rewind_bodyss



<04>



<04><02>r<>
)r>r r?r@)r\r]r?r^)rcrr?rK)
F)r{r|r}r@r?r~)r<>rr?r<>)r<>r r?r )r<>r r?r<>)r<>r<>r?r<>)r<>r<>r?r<>)r<>r<>r?r<>)r<>r<>r?r<>)r<>r r?r<>)r<>r r?r<>)r<>r r<>r@r?r )r<>r,r?r<>)r<>r,r<>r<>r?r,)r<>r r?r<>)r<>r r?r<>)r<>r<>r?r<>)r
r

r
r1r?r
)r
rr
r
r?r
)r
r r
r
r?r
)r
r
r
r
r?r
)r
r1r?r
)r
r r?r )r/
r r0
r r?r@)r<
rKr?r )r@
r r?r@)rB
r r?r@)rE
r r<>r<>r?rF
)r{r rJ
r<>r?r@r<>)r{r rJ
r<>r?r<>)r{r r]
r^
r?r<>)
T)rf
rg
r]
r^
rh
r@r?r<>)
rn
)r<>r r?r )r?r<>)r<>r r?rs
)r|
rr?r<>)r{r r<>
r r?r )r{r r?r<>
)r<>r<>
r?r<>)r<>r<>
r<>
r<>
r<>
rKr?r<>)r{r r?r )r<>
r/r?r<>)<29><>__doc__<5F>
__future__rr	
<00>
contextlibrnrqrRr3
r1
<00>sysr<73>rur<><00>collectionsr<00>collections.abcrr<00>typingrrrr	r
r<00>urllib3.utilrr
r<>rr<00>_internal_utilsrrrrr.rr`<00>compatrrrrrrrrrr r!r"r#r$r<><00>cookiesr&<00>
exceptionsr'r(r)r*<00>
structuresr+<00>http.cookiejarr,r-<00>_t<5F>modelsr/r0r1r3<00>__annotations__<5F>wherer4r8r9r:r<>rOr<<00>platformr[rbrzr<>r<>r<><00>contextmanagerr<72>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r
r
r
<00>	frozensetr
r*
r.
r;
r5
rA
rD
rI
rZ
r\
re
rm
ro
rr
rx
rlr<>
r<>
r<>
r<>
r<>
r<>
r<>
r<>
r<>
r<>
rYrYrYrZ<00><module>
s<>











 
	
<







<0C>

&

H<0C>
4
&






 
 #









*
<0C>







?
<0C>
	

&