wg-backend-django/acer-env/lib/python3.10/site-packages/requests/__pycache__/utils.cpython-310.pyc

o
<00>Ԅć<00>@s<>dZd
dl
Z
d
dlZd
dlZd
dlZd
dlZd
dlZd
dlZd
dlZd
dl	Z	d
dl
Z
d
dlZd
dlm
Z

d
dlmZmZ
ddlmZ
ddlmZ
ddlmZmZ
dd	lmZmZmZmZmZmZ
dd
lmZ
ddlm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&
ddl'm(Z(
dd
l)m*Z*m+Z+m,Z,m-Z-
ddl.m/Z/
dZ0e<12>1<EFBFBD>Z2ddd<12>Z3d<13>4e<05>5dedd<16>
d<00><02>
Z6ej7dkr<>dd<1A>Z8dd<1C>Z dd<1E>Z9dd <20>Z:dtd"d#<23>
Z;d$d%<25>Z<d&d'<27>Z=ej>d(d)<29><00>
Z?d*d+<2B>Z@d,d-<2D>ZAd.d/<2F>ZBd0d1<64>ZCdtd2d3<64>
ZDd4d5<64>ZEd6d7<64>ZFd8d9<64>ZGd:d;<3B>ZHd<d=<3D>ZId>d?<3F>ZJd@dA<64>ZKdBdC<64>ZLeMdD<64>
ZNdEdF<64>ZOdGdH<64>ZPdIdJ<64>ZQdKdL<64>ZRdMdN<64>ZSdOdP<64>ZTej>dQdR<64><00>
ZUdSdT<64>ZVdudUdV<64>
ZWdWdX<64>ZXdvdYdZ<64>
ZYdwd\d]<5D>
ZZd^d_<64>Z[d`da<64>Z\db<64>]dc<64>
Z^e^ddZ_e^deZ`dfdg<64>Zadhdi<64>Zbdjdk<64>Zcdldm<64>Zddndo<64>Zedpdq<64>Zfdrds<64>ZgdS)xz<78>
requests.utils
~~~~~~~~~~~~~~

This module provides utility functions that are used within Requests
that are also useful for external consumption.
<EFBFBD>N)
<01>OrderedDict)<02>make_headers<72>	parse_url<72>
)
<01>certs<74>
<01>__version__)<02>HEADER_VALIDATORS<52>to_native_string)<06>Mapping<6E>
basestring<EFBFBD>bytes<65>
getproxies<EFBFBD>getproxies_environment<6E>
integer_types)
<01>parse_http_list)<07>proxy_bypass<73>proxy_bypass_environment<6E>quote<74>str<74>unquote<74>urlparse<73>
urlunparse<EFBFBD>
<01>cookiejar_from_dict)<04>FileModeWarning<6E>
InvalidHeader<65>
InvalidURL<EFBFBD>UnrewindableBodyError)
<01>CaseInsensitiveDict)z.netrc<72>_netrc<72>Pi<>
)<02>http<74>httpsz, z,\s*T)
<01>accept_encodingzaccept-encoding<6E>win32c
	Cs<>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>
}|D]*}|dkrSd|v
rS
d	S|<05>	dd
<EFBFBD>}|<05>	dd<0C>}|<05>	d
d<08>}t
<EFBFBD>||t
j<0C>rp
d	SqFdS)Nr
Fz;Software\Microsoft\Windows\CurrentVersion\Internet Settings<67>ProxyEnable<6C>
ProxyOverride<64>
;z<local><3E>
.Tz\.<2E>
*z.*<2A>
?)
<0A>winreg<65>ImportError<6F>OpenKey<65>HKEY_CURRENT_USER<45>int<6E>QueryValueEx<45>OSError<6F>
ValueError<EFBFBD>split<69>replace<63>re<72>match<63>
I)<06>hostr,<00>internetSettings<67>proxyEnable<6C>
proxyOverride<64>test<73>r><00>a/home/infidel/Sync/Project/ocp-wg-backend/acer-env/lib/python3.10/site-packages/requests/utils.py<70>proxy_bypass_registryGs:



<02>


<04>

<02>









<02>r@c

Cst<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@)
r9r>r>r?rks
rc

Cst|d
<01>r	|<00>
<01>}|S)z/Returns an internal sequence dictionary update.<2E>items)<02>hasattrrA)
<01>
dr>r>r?<00>dict_to_sequencews

rDc
	Cs 
d}
d
}t|d<02>rt
|<00>
}
n2t|d<03>r|j
}
n)t|d<04>r@z|<00><02>}Wntjtfy.


Ynwt<06>|<03>
j}
d|j	v
r@t
<EFBFBD>dt<0C>
t|d<07>r<>z|<00>
<0A>}WntyZ


|
du
rX|
}Yn)wt|d<08>r<>|
dur<>z|<00>d
d	<09>
|<00>
<0A>}
|<00>|ptd
<01>

Wnty<>


d
}
Yn
w|
dur<>d
}
td
|
|<00>S)
Nr
<00>__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>)rBrFrG<00>io<69>UnsupportedOperation<6F>AttributeError<6F>os<6F>fstat<61>st_size<7A>mode<64>warnings<67>warnrrIr2rJ<00>max)<04>
o<>total_length<74>current_positionrGr>r>r?<00>	super_len<65>sJ










<02>

<04>




<04><02>


<02>
rYFc	Cs>
tj
<01>d
<01>
}|du
r|f
}ndd<04>tD<00>
}z}ddlm}m}
d}|D]!}ztj<06>|<07>
}Wnty8


Y
WdSwtj<06>	|<08>
rC|}
n
q"|durKWdSt
|<00>
}	d}
t|t<0C>r[|
<EFBFBD>
d<08>
}
|	j<0E>|
<EFBFBD>
d}z||<06>
<01>|<0B>
}|r|drsdn
d	}
||
|d
fWWSWWdS|tfy<>


|
r<><72>YWdSwttfy<>


YdSw)z;Returns the Requests tuple auth for a given url from netrc.<2E>NETRCNc
ss<00>|]}
d|
<01><00>V
qd
S)z~/Nr>)<02>.0<EFBFBD>
fr>r>r?<00>	<genexpr><3E>s<02>z!get_netrc_auth.<locals>.<genexpr>r
)<02>NetrcParseError<6F>netrc<72>
:<3A>asciirrK)rO<00>environ<6F>get<65>NETRC_FILESr_r^<00>path<74>
expanduser<EFBFBD>KeyError<6F>existsr<00>
isinstancer<00>decode<64>netlocr4<00>authenticatorsr2r-rN)<0E>url<72>raise_errors<72>
netrc_file<EFBFBD>netrc_locationsr^r_<00>
netrc_pathr\<00>loc<6F>ri<72>splitstrr9r <00>login_ir>r>r?<00>get_netrc_auth<74>sL






<02>

<02>








<08>
<08><02>
<02>rvc
CsNt|d
d<02>}
|
rt
|
t<02>r!|
ddkr#|
ddkr%tj<04>|
<01>
SdSdSdSdS)z0Tries to guess the filename of the given object.<2E>nameNr
<00>
<<3C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
>)<06>getattrrirrOre<00>basename)<02>objrwr>r>r?<00>guess_filename<6D>s&

<10>r~c
Cs<>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|St	<09>
<EFBFBD>}tj
<01>||<02>d
<01>
d<00>}tj
<01>|<06>
syt|<06>
<01>}|<07>|<04>
|<02>
<01>

Wd<00>
|S1stw



Y
|S)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>
/ryN)rOrerhr4<00>join<69>zipfile<6C>
is_zipfile<EFBFBD>ZipFile<6C>namelist<73>tempfile<6C>
gettempdir<EFBFBD>atomic_open<65>write<74>read)re<00>archive<76>member<65>prefix<69>zip_file<6C>tmp<6D>extracted_path<74>file_handlerr>r>r?<00>extract_zipped_paths
s.



<10>









<EFBFBD><10>r<>c
csz<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<><00>mkstemprOre<00>dirname<6D>fdopenr5<00>
BaseException<6F>remove)<04>filename<6D>tmp_descriptor<6F>tmp_name<6D>tmp_handlerr>r>r?r<>'
s<02>


<1C>



<02>r<EFBFBD>c

Cs.|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)rirr
<00>boolr0r3r<00>
<01>valuer>r>r?<00>from_key_val_list4
s


r<>c

Cs@|d
urd
St|t
tttf<04>rtd<02>
<01>
t|t<06>r|<00><07>}t|<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>)	rirr
r<>r0r3rrA<00>listr<74>r>r>r?<00>to_key_val_listO
s



r<>c
CsXg}
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
    Nrry<00>
")<03>_parse_list_header<65>unquote_header_value<75>append)r<><00>result<6C>itemr>r>r?<00>parse_list_headerm
s
(



r<>c
Csxi}
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>
=Nrryr<>)r<>r4r<>)r<>r<>r<>rwr>r>r?<00>parse_dict_header<65>
s




(




r<>cCs^|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
ryr<>rNrKz\\<5C>
\z\")
r5)r<><00>is_filenamer>r>r?r<><00>
s"<0C>

r<>c
Csi}
|D]}|j|
|j
<q|
S)
z<>Returns a key/value dictionary from a CookieJar.

    :param cj: CookieJar object to extract cookies from.
    :rtype: dict
    )r<>rw)<03>cj<63>cookie_dict<63>cookier>r>r?<00>dict_from_cookiejar<61>
s
r<>cCs
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<>r<>r>r>r?<00>add_dict_to_cookiejar<61>
s
r<>c
CsTt<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=["\']*(.+?)["\'>])rSrT<00>DeprecationWarningr6<00>compiler8<00>findall)<04>content<6E>
charset_re<EFBFBD>	pragma_re<72>xml_rer>r>r?<00>get_encodings_from_content<6E>
s<04>	



<02><02><02>r<EFBFBD>c

Cs<>|<00>d
<01>
}
|
d<00>
<01>|
dd<04>}}i}d}|D]0}|<06>
<01>}|rH|d}}|<06>d<07>
}	|	dkrB|d|	<09><00>
|<05>
}||	dd<04><00>
|<05>
}|||<07><03><q||fS)	z<>Returns content type and parameters from given header

    :param header: string
    :return: tuple containing content type and dictionary of
         parameters
    r(r
rNz"' Tr<54>ry)r4<00>strip<69>find<6E>lower)
<EFBFBD>header<65>tokens<6E>content_type<70>params<6D>params_dict<63>items_to_strip<69>param<61>keyr<79><00>index_of_equalsr>r>r?<00>_parse_content_type_header<65>
s













<02>
r<>c
CsP|<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/json<6F>utf-8)rcr<>r<>)<03>headersr<73>r<>r>r>r?<00>get_encoding_from_headerss



<04>r<EFBFBD>ccsj<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.Nr5<00>
<01>errors<72>T)
<01>final)<04>encoding<6E>codecs<63>getincrementaldecoderrj)<05>iterator<6F>
r<>decoder<65>chunk<6E>rvr>r>r?<00>stream_decode_response_unicode.s<02>








<02>



<04>r<EFBFBD>ccsX<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)<03>string<6E>slice_length<74>posr>r>r?<00>iter_slices?s<02>




<14>r<EFBFBD>c
Csvt<00>
d
t<02>
g}
t|j<04>
}|r%zt|j|<02>WSty$


|
<01>|<02>

Yn
wz	t|j|dd<03>WSt	y:


|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.)r5r<>)
rSrTr<>r<>r<>rr<><00>UnicodeErrorr<72><00>	TypeError)r<><00>tried_encodingsr<73>r>r>r?<00>get_unicode_from_responseIs"<04>	




<02>



<02>r<EFBFBD>zBABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~c
	Cs<>|<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>
'N<>)
r4<00>rangerF<00>isalnum<75>chrr0r3r<00>UNRESERVED_SETr<54>)<05>uri<72>parts<74>
i<>
h<>
cr>r>r?<00>unquote_unreservedvs







<02>


r<>c
Cs: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_percentr>r>r?<00>requote_uri<72>s


<02>r<EFBFBD>cCslt<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_atonr4<00>dotted_netmaskr0)<07>ip<69>net<65>ipaddr<64>netaddr<64>bits<74>netmask<73>networkr>r>r?<00>address_in_network<72>s




r
c
Cs&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)r<><00>	inet_ntoar<61><00>pack)<02>maskr<6B>r>r>r?r<><00>s
r<>c

Cs&zt<00>
|<00>

WdSty


Yd
Sw)z
    :rtype: bool
    FT)r<>r<>r2)
<01>	string_ipr>r>r?<00>is_ipv4_address<73>s
<0C>
<02>r
c
Cs<>|<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
    rrFr
r
T)<07>countr0r4r3r<>r<>r2)<02>string_networkr
r>r>r?<00>
is_valid_cidr<64>s



<02>

<0C>
<02>r
c	csz<00>|
d
u
}|rtj
<01>|<00>
}|
tj
|<zd
V
W|r*|d
ur#tj
|=d
S|tj
|<d
Sd
S|r<|d
ur7tj
|=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)rOrbrc)<04>env_namer<65><00>
value_changed<65>	old_valuer>r>r?<00>set_environ<6F>s<02>







<08>

r
c	
Cs8
d
d<02>}|
}|
dur|d<04>
}
t|<00>
}|j
durdS|
rkdd<07>|
<01>dd	<09><02>d
<EFBFBD>
D<00>
}
t|j
<01>
rJ|
D]}t|<05>
r@t|j
|<05>r?
dSq0|j
|krH
dSq0n!|j
}|jrX|d|j<07><00>7}|
D]}|j
<01>|<07>
sg|<06>|<07>
rj
dSqZt	d|<03><02>
zt
|j
<01>
}Wnttj
fy<>


d}Yn
wWd<00>
n1s<>w



Y
|r<>dSdS)
zL
    Returns whether we should bypass proxies or not.

    :rtype: bool
    c

Sstj
<01>|<00>
p
tj
<01>|<00><03><00>
S<00>
N)rOrbrc<00>upper)
r<>r>r>r?<00>	get_proxy<78>s
z(should_bypass_proxies.<locals>.get_proxyN<79>no_proxyTc
ss<00>|]}
|
r|
V
qdSr
r>)r[r9r>r>r?r]s<02>z(should_bypass_proxies.<locals>.<genexpr><3E>
 r<><00>
,<2C>
:F)r<00>hostnamer5r4r
r
r
<00>port<72>endswithr
rr<>r<><00>gaierror)	rmr
r
<00>no_proxy_arg<72>parsed<65>proxy_ip<69>host_with_portr9<00>bypassr>r>r?<00>should_bypass_proxies<65>sJ








<02>
<02><02>	


<02>


<02><02><1C>
r 
cCst||
d
<01>riSt
<01>S)zA
    Return a dict of environment proxies.

    :rtype: dict
    <20>
r
)r 
r)rmr
r>r>r?<00>get_environ_proxies3s
r"
cCsv|
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://)rr
rc<00>scheme)rm<00>proxies<65>urlparts<74>
proxy_keys<EFBFBD>proxy<78>	proxy_keyr>r>r?<00>select_proxy?s"






<04>



<02>r*
c	Cst|
d
u
r|
n
i}
|j}t
|<03>
j}|
<01>d<02>
}|
<01><04>}|r8t||d<03>s8t||d<03>}|<07>||<07>d<04>
<01>}|r8|<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 a 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
    Nr
r!
r#
)rmrr$
rc<00>copyr 
r"
<00>
setdefault)	<09>requestr%
<00>	trust_envrmr$
r
<00>new_proxies<65>environ_proxiesr(
r>r>r?<00>resolve_proxiesYs








r1
<00>python-requestsc

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

    :rtype: str
    rr)
rwr>r>r?<00>default_user_agenttsr3
cCstt
<01>td
dd<03><04>
S)z9
    :rtype: requests.structures.CaseInsensitiveDict
    z*/*z
keep-alive)z
User-AgentzAccept-Encoding<6E>Accept<70>
Connection)rr3
<00>DEFAULT_ACCEPT_ENCODINGr>r>r>r?<00>default_headers}s


<04><04>r7
c
	
Cs<>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, *<r(rr<>rmz<> '"r<>)r<>r6r4r3r<>)	r<><00>links<6B>
replace_chars<72>valrmr<><00>linkr<6B>r<>r>r>r?<00>parse_header_links<6B>s*






<02>



<02>r<
<00>
rarK<00>c
Cs<>|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
r<>z	utf-16-berz	utf-16-lez	utf-32-bez	utf-32-le)
r<EFBFBD><00>BOM_UTF32_LE<4C>BOM_UTF32_BE<42>BOM_UTF8<46>BOM_UTF16_LE<4C>BOM_UTF16_BEr	
<00>_null<6C>_null2<6C>_null3)<03>data<74>sample<6C>	nullcountr>r>r?<00>guess_json_utf<74>s*


















rK
cCslt|<00>
}|\}}}}}}}	|j
}
|
s||
}
}|r d
<01>||
g<02>
}
|dur&|
}|dur,d}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>)rrkr<>r)rm<00>
new_schemer
r$
<00>authr9r
re<00>query<72>fragmentrkr>r>r?<00>prepend_scheme_if_needed<65>s







rQ
c
	Cs@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<>)rr<00>username<6D>passwordrNr<>)rmr
rN
r>r>r?<00>get_auth_from_url<72>s
<10>
<02>rT
c
Csv|\}
}|D]}t|<03>
t
v
r td
|<03>d|
<01>d|<02>dt|<03>
<01><00><08>
<01>
qt|
dt
t|
<01>
d<00>
t|dt
t|<02>
d<00>
d	S)
z<EFBFBD>Verifies that header parts don't contain leading whitespace
    reserved characters, or return characters.

    :param header: tuple, in the format (name, value).
    z
Header part (z) from {<7B>: z$} must be of type str or bytes, not rwr
r<>rN)<04>typer	r<00>_validate_header_part)r<>rwr<><00>partr>r>r?<00>check_header_validitys



<04><04><02>
rY
cCs"|<02>|<00>
st
d
|
<01>d|<00><02><04>
<01>
dS)NzSInvalid leading whitespace, reserved character(s), or returncharacter(s) in header rU
)r7r)<03>header_part<72>header_kind<6E>	validatorr>r>r?rW
s




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

    :rtype: str
    rL
rryr<>)r<00>rsplitr)rmr$
rkrer<>rO
rP
r>r>r?<00>
urldefragauths


r^
c
CsRt|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>bodyri<00>_body_positionrr2r)<02>prepared_request<73>	body_seekr>r>r?<00>rewind_body/s


<04>



<04><02>rc
)
Fr
)
T)
r2
)h<>__doc__r<5F><00>
contextlibrLrOr6r<>r<><00>sysr<73>rSr<><00>collectionsr<00>urllib3.utilrrr<>rr<00>_internal_utilsr	r
<00>compatrrr
rrrrr<>rrrrrrr<00>cookiesr<00>
exceptionsrrrr<00>
structuresrrd<00>where<72>DEFAULT_CA_BUNDLE_PATH<54>
DEFAULT_PORTSr<53>r4r6
<00>platformr@rDrYrvr~r<><00>contextmanagerr<72>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<><00>	frozensetr<74>r<>r<>r
r<>r
r
r
r 
r"
r*
r1
r3
r7
r<
<00>encoderE
rF
rG
rK
rQ
rT
rY
rW
r^
rc
r>r>r>r?<00><module>
s<>











 
$
	


<04>
$	
B9%

 
#
(
<04>


<

	
&