old-saburly-wagtail-web/env/lib/python3.10/site-packages/requests/__pycache__/utils.cpython-310.pyc

o
<00><><EFBFBD>fS<66><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
ddlmZmZmZmZ
dd	lmZmZmZmZmZmZ
dd
lm Z!
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/
ddl0m1Z1
dZ2e<12>3<EFBFBD>Z4ddd<12>Z5d<13>6e<05>7dedd<16>
d<00><02>
Z8ej9dkr<>dd<1A>Z:dd<1C>Z"dd<1E>Z;dd <20>Z<dtd"d#<23>
Z=d$d%<25>Z>d&d'<27>Z?ej@d(d)<29><00>
ZAd*d+<2B>ZBd,d-<2D>ZCd.d/<2F>ZDd0d1<64>ZEdtd2d3<64>
ZFd4d5<64>ZGd6d7<64>ZHd8d9<64>ZId:d;<3B>ZJd<d=<3D>ZKd>d?<3F>ZLd@dA<64>ZMdBdC<64>ZNeOdD<64>
ZPdEdF<64>ZQdGdH<64>ZRdIdJ<64>ZSdKdL<64>ZTdMdN<64>ZUdOdP<64>ZVej@dQdR<64><00>
ZWdSdT<64>ZXdudUdV<64>
ZYdWdX<64>ZZdvdYdZ<64>
Z[dwd\d]<5D>
Z\d^d_<64>Z]d`da<64>Z^db<64>_dc<64>
Z`e`ddZae`deZbdfdg<64>Zcdhdi<64>Zddjdk<64>Zedldm<64>Zfdndo<64>Zgdpdq<64>Zhdrds<64>ZidS)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__)<04>_HEADER_VALIDATORS_BYTE<54>_HEADER_VALIDATORS_STR<54>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>
}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)<06>hostr.<00>internetSettings<67>proxyEnable<6C>
proxyOverride<64>test<73>rA<00>P/home/amir/Desktop/saburlyweb/env/lib/python3.10/site-packages/requests/utils.py<70>proxy_bypass_registryLs<



<02>


<04>

<02>










<02>rCc

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.
        )rrrC)
r<rArArBrrs
rc

Cst|d
<01>r	|<00>
<01>}|S)z/Returns an internal sequence dictionary update.<2E>items)<02>hasattrrD)
<01>
drArArB<00>dict_to_sequence~s

rGc
	Cs4
d}
d
}t|t
<01>r|<00>d<02>
}t|d<03>rt|<00>
}
n2t|d<04>r!|j}
n)t|d<05>rJz|<00><05>}Wntjtfy8


Ynwt	<09>
|<03>
j}
d|jv
rJt
<0A>dt<0F>
t|d<08>r<>z|<00><10>}Wntyd


|
du
rb|
}Yn)wt|d	<09>r<>|
dur<>z|<00>d
d
<EFBFBD>
|<00><10>}
|<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>)<14>
isinstancer<00>encoderErJrK<00>io<69>UnsupportedOperation<6F>AttributeError<6F>os<6F>fstat<61>st_size<7A>mode<64>warnings<67>warnrrMr4rN<00>max)<04>
o<>total_length<74>current_positionrKrArArB<00>	super_len<65>sN













<02>

<04>




<04><02>


<02>
r_Fc	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~/NrA)<02>.0<EFBFBD>
frArArB<00>	<genexpr><3E>s<02>z!get_netrc_auth.<locals>.<genexpr>r
)<02>NetrcParseError<6F>netrc<72>
:<3A>asciirrO)rU<00>environ<6F>get<65>NETRC_FILESrerd<00>path<74>
expanduser<EFBFBD>KeyError<6F>existsrrPr<00>decode<64>netlocr6<00>authenticatorsr4r/rT)<0E>url<72>raise_errors<72>
netrc_file<EFBFBD>netrc_locationsrdre<00>
netrc_pathrb<00>loc<6F>ri<72>splitstrr<r"<00>login_irArArB<00>get_netrc_auth<74>sL






<02>

<02>








<08>
<08><02>
<02>r{c
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>getattrrPrrUrk<00>basename)<02>objr|rArArB<00>guess_filename
s&

<10>r<EFBFBD>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>
/r~N)rUrkrnr6<00>join<69>zipfile<6C>
is_zipfile<EFBFBD>ZipFile<6C>namelist<73>tempfile<6C>
gettempdir<EFBFBD>atomic_open<65>write<74>read)rk<00>archive<76>member<65>prefix<69>zip_file<6C>tmp<6D>extracted_path<74>file_handlerrArArB<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>mkstemprUrk<00>dirname<6D>fdopenr8<00>
BaseException<6F>remove)<04>filename<6D>tmp_descriptor<6F>tmp_name<6D>tmp_handlerrArArBr<>1
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)rPrr<00>boolr2r5r<00>
<01>valuerArArB<00>from_key_val_list>
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>)	rPrrr<>r2r5r
rD<00>listr<74>rArArB<00>to_key_val_listY
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
    Nrr~<00>
")<03>_parse_list_header<65>unquote_header_value<75>append)r<><00>result<6C>itemrArArB<00>parse_list_headerw
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>
=Nrr~r<>)r<>r6r<>)r<>r<>r<>r|rArArB<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
r~r<>rNrOz\\<5C>
\z\")
r8)r<><00>is_filenamerArArBr<><00>
s"<0C>

r<>c
Csd
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
Ssi|]}
|
j|
j
<01>qSrA)r|r<>)ra<00>cookierArArB<00>
<dictcomp><3E>
sz'dict_from_cookiejar.<locals>.<dictcomp>rA<00><02>cj<63>cookie_dictrArArB<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
    rr<>rArArB<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=["\']*(.+?)["\'>])rYrZ<00>DeprecationWarningr9<00>compiler;<00>findall)<04>content<6E>
charset_re<EFBFBD>	pragma_re<72>xml_rerArArB<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>r~)r6<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_equalsrArArB<00>_parse_content_type_headers













<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/jsonrH)rir<>r<>)<03>headersr<73>r<>rArArB<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.Nr8<00>
<01>errors<72>T)
<01>final)<04>encoding<6E>codecs<63>getincrementaldecoderro)<05>iterator<6F>
r<>decoder<65>chunk<6E>rvrArArB<00>stream_decode_response_unicode4s<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)
rJ)<03>string<6E>slice_length<74>posrArArB<00>iter_slicesEs<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.)r8r<>)
rYrZr<>r<>r<>rr<><00>UnicodeErrorr<72><00>	TypeError)r<><00>tried_encodingsr<73>rArArB<00>get_unicode_from_responseOs"<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
rO<00>z"Invalid percent-escape sequence: '<27>
'N<>)
r6<00>rangerJ<00>isalnum<75>chrr2r5r<00>UNRESERVED_SETr<54>)<05>uri<72>parts<74>
i<>
h<>
crArArB<00>unquote_unreserved|s







<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_percentrArArB<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_atonr6<00>dotted_netmaskr2)<07>ip<69>net<65>ipaddr<64>netaddr<64>bits<74>netmask<73>networkrArArB<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
rArArBr
<00>s
r
c

Cs&zt<00>
|<00>

WdSty


Yd
Sw)z
    :rtype: bool
    FT)r<>r<>r4)
<01>	string_iprArArB<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
    r<>rFr	
r
T)<07>countr2r6r5r<>r<>r4)<02>string_networkr
rArArB<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)rUrhri)<04>env_namer<65><00>
value_changed<65>	old_valuerArArB<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)rUrhri<00>upper)
r<>rArArB<00>	get_proxys
z(should_bypass_proxies.<locals>.get_proxyN<79>no_proxyTc
ss<00>|]}
|
r|
V
qdSr
rA)rar<rArArBrcs<02>z(should_bypass_proxies.<locals>.<genexpr><3E>
 r<><00>
,<2C>
:F)r<00>hostnamer8r6r
r
r
<00>port<72>endswithr
rr<>r<><00>gaierror)	rrr
r
<00>no_proxy_arg<72>parsed<65>proxy_ip<69>host_with_portr<<00>bypassrArArB<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)rrr
rArArB<00>get_environ_proxies:s
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
ri<00>scheme)rr<00>proxies<65>urlparts<74>
proxy_keys<EFBFBD>proxy<78>	proxy_keyrArArB<00>select_proxyFs"






<04>



<02>r0
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 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
    Nr
r'
r)
)rrrr*
ri<00>copyr&
r(
<00>
setdefault)	<09>requestr+
<00>	trust_envrrr*
r
<00>new_proxies<65>environ_proxiesr.
rArArB<00>resolve_proxies`s








r7
<00>python-requestsc

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

    :rtype: str
    r<>r)
r|rArArB<00>default_user_agent{sr9
cCstt
<01>td
dd<03><04>
S)z9
    :rtype: requests.structures.CaseInsensitiveDict
    z*/*z
keep-alive)z
User-AgentzAccept-Encoding<6E>Accept<70>
Connection)r!r9
<00>DEFAULT_ACCEPT_ENCODINGrArArArB<00>default_headers<72>s


<04><04>r=
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<>rrz<> '"r<>)r<>r9r6r5r<>)	r<><00>links<6B>
replace_chars<72>valrrr<><00>linkr<6B>r<>rArArB<00>parse_header_links<6B>s*






<02>



<02>rB
<00>
rgrO<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-32rD
z	utf-8-sigrOzutf-16r
rHz	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>	nullcountrArArB<00>guess_json_utf<74>s*


















rQ
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>)rrpr<>r)rr<00>
new_schemer"
r*
<00>authr<r
rk<00>query<72>fragmentrprArArB<00>prepend_scheme_if_needed<65>s







rW
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>passwordrTr<>)rrr"
rT
rArArB<00>get_auth_from_url<72>s
<10>
<02>rZ
c
Cs$|\}
}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<>rArArB<00>check_header_validity
s

r\
cCsxt|
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: )rPrr
rr	r<00>typer:)r<><00>header_part<72>header_validator_index<65>	validator<6F>header_kindrArArBr[
s&









<04><04>




<04>
<04><04><04>r[
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
    rR
rr~r<>)r<00>rsplitr)rrr*
rprkr<>rU
rV
rArArB<00>
urldefragauth(s


rc
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.
    rNNz;An error occurred when rewinding request body for redirect.z+Unable to rewind request body for redirect.)r<><00>bodyrP<00>_body_positionrr4r )<02>prepared_request<73>	body_seekrArArB<00>rewind_body9s


<04>



<04><02>rh
)
Fr
)
T)
r8
)j<>__doc__r<5F><00>
contextlibrRrUr9r<>r<><00>sysr<73>rYr<><00>collectionsr<00>urllib3.utilrrr<>rr<00>_internal_utilsr	r
rr<00>compatr
rrrrrrr<>rrrrrrr<00>cookiesr<00>
exceptionsrrrr <00>
structuresr!rj<00>where<72>DEFAULT_CA_BUNDLE_PATH<54>
DEFAULT_PORTSr<53>r6r<
<00>platformrCrGr_r{r<>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(
r0
r7
r9
r=
rB
rQrK
rL
rM
rQ
rW
rZ
r\
r[
rc
rh
rArArArB<00><module>
s<>











 $
	


<04>
&	
E9%

 
#
(
<04>


=

	
&