old-parkingkoncept/parkingkonceptvenv/lib/python3.7/site-packages/requests/__pycache__/utils.cpython-37.pyc

B
#U<>]au<00>@s<>dZd
dl
Z
d
dlZd
dlZd
dlZd
dlZd
dlZd
dlZd
dlZd
dl	Z	d
dl
Z
d
dlZddlmZ
ddl
mZ
ddlmZ
ddlmZ
ddlmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"
dd	l#m$Z$
dd
l%m&Z&
ddl'm(Z(m)Z)m*Z*m+Z+
dZ,e<0E>-<2D>Z.d
dd<0F>Z/ej0dk<02>
r2dd<12>Z1dd<14>Zdd<16>Z2dd<18>Z3dhdd<1B>
Z4dd<1D>Z5dd<1F>Z6d d!<21>Z7d"d#<23>Z8d$d%<25>Z9d&d'<27>Z:did(d)<29>
Z;d*d+<2B>Z<d,d-<2D>Z=d.d/<2F>Z>d0d1<64>Z?d2d3<64>Z@d4d5<64>ZAd6d7<64>ZBd8d9<64>ZCeDd:<3A>
ZEd;d<<3C>ZFd=d><3E>ZGd?d@<40>ZHdAdB<64>ZIdCdD<64>ZJdEdF<64>ZKejLdGdH<64><00>
ZMdIdJ<64>ZNdjdKdL<64>
ZOdMdN<64>ZPdkdPdQ<64>
ZQdRdS<64>ZRdTdU<64>ZSdV<64>TdW<64>
ZUeUdXZVeUdYZWdZd[<5B>ZXd\d]<5D>ZYd^d_<64>ZZe<05>[d`<60>
Z\e<05>[da<64>
Z]dbdc<64>Z^ddde<64>Z_dfdg<64>Z`dS)lz<6C>
requests.utils
~~~~~~~~~~~~~~

This module provides utility functions that are used within Requests
that are also useful for external consumption.
<EFBFBD>N<>
)
<01>__version__)
<01>certs)
<01>to_native_string)
<01>parse_http_list)<0F>quote<74>urlparse<73>bytes<65>str<74>OrderedDict<63>unquote<74>
getproxies<EFBFBD>proxy_bypass<73>
urlunparse<EFBFBD>
basestring<EFBFBD>
integer_types<65>is_py3<79>proxy_bypass_environment<6E>getproxies_environment<6E>Mapping)
<01>cookiejar_from_dict)
<01>CaseInsensitiveDict)<04>
InvalidURL<EFBFBD>
InvalidHeader<65>FileModeWarning<6E>UnrewindableBodyError)z.netrc<72>_netrc<72>Pi<>
)<02>http<74>https<70>win32c
Cs<>ytrd
dl
}
nd
dl}
Wntk
r.


dSXy6|
<01>|
jd<03>}t|
<01>|d<04>d
<00>
}|
<01>|d<05>d
}Wntk
rz


dSX|r<>|s<>dS|<04>	d<06>
}xX|D]P}|dkr<>d|kr<>d	S|<05>
dd
<EFBFBD>}|<05>
dd<0C>}|<05>
d
d<08>}t<0B>||tj
<0A>r<>d	Sq<>WdS)Nr
Fz;Software\Microsoft\Windows\CurrentVersion\Internet SettingsZProxyEnableZ
ProxyOverride<64>
;z<local><3E>
.Tz\.<2E>
*z.*<2A>
?)r<00>winreg<65>_winreg<65>ImportError<6F>OpenKey<65>HKEY_CURRENT_USER<45>int<6E>QueryValueEx<45>OSError<6F>split<69>replace<63>re<72>match<63>
I)<06>hostr%ZinternetSettingsZproxyEnableZ
proxyOverride<64>test<73>r4<00>4/tmp/pip-install-zuyyrlx8/requests/requests/utils.py<70>proxy_bypass_registry/s8
























r6c

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

        Checks proxy settings gathered from the environment, if specified,
        or the registry.
        N)rrr6)
r2r4r4r5rVs
rc

Cst|d
<01>r|<00>
<01>}|S)z/Returns an internal sequence dictionary update.<2E>items)<02>hasattrr7)
<01>
dr4r4r5<00>dict_to_sequencebs

r:c
	Cs4
d}
d
}t|d<02>rt
|<00>
}
nbt|d<03>r.|j
}
nPt|d<04>r~y|<00><02>}Wntjk
rZ


Yn$Xt<05>|<03>
j}
d|jkr~t	<09>
dt<0B>
t|d<07><02>
ry|<00><0C>}Wn$t
tfk
r<EFBFBD>


|
dk	r<>|
}Yn^Xt|d<08><02>
r|
dk<08>
ry&|<00>d
d	<09>
|<00><0C>}
|<00>|p<>d
<01>

Wnt
tfk
<EFBFBD>
r


d
}
YnX|
dk<08>
r&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>)r8r<r=<00>io<69>UnsupportedOperation<6F>os<6F>fstat<61>st_size<7A>mode<64>warnings<67>warnrr?r,<00>IOErrorr@<00>max)<04>
o<>total_length<74>current_positionr=r4r4r5<00>	super_lenks@

























rOFc	Cs
y<>d
dlm}m
}
d}xJtD]B}ytj<04>d<04>|<05>
<01>
}Wntk
rJ


dSXtj<04>|<06>
r|}PqW|dkrndSt	|<00>
}d}t
|t<0B>r<>|<08>d<06>
}|j
<0A>|<08>
d
}	y6||<04>
<01>|	<09>
}
|
r<EFBFBD>|
d
r<>d
nd}|
||
dfSWn|tfk
r<EFBFBD>


|
r<><72>YnXWnttfk
<EFBFBD>
r


YnXdS)	z;Returns the Requests tuple auth for a given url from netrc.r
)<02>netrc<72>NetrcParseErrorNz~/{}<7D>
:<3A>asciirrA)rPrQ<00>NETRC_FILESrD<00>path<74>
expanduser<EFBFBD>format<61>KeyError<6F>existsr<00>
isinstancer
<00>decode<64>netlocr-<00>authenticatorsrJr'<00>AttributeError)<0C>url<72>raise_errorsrPrQ<00>
netrc_path<EFBFBD>
f<>loc<6F>ri<72>splitstrr2r<00>login_ir4r4r5<00>get_netrc_auth<74>s8


















rgc
CsBt|d
d<02>}
|
r>t
|
t<02>r>|
ddkr>|
ddkr>tj<04>|
<01>
SdS)z0Tries to guess the filename of the given object.<2E>nameNr
<00>
<<3C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
>)<06>getattrrZrrDrU<00>basename)<02>objrhr4r4r5<00>guess_filename<6D>s


roc
Cs<>tj
<01>|<00>
r|Stj
<01>|<00>
\}
}x2|
rRtj
<01>|
<01>
sRtj
<01>|
<01>
\}
}d
<01>||g<02>
}q"Wt<05>|
<01>
sb|St<05>|
<01>
}||<04><08>kr||St	<09>
<EFBFBD>}tj
j|f
|<02>d
<01>
<01><02>}tj
<01>|<06>
s<>|j||d<02>}|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>
/)
rU)rDrUrYr-<00>join<69>zipfile<6C>
is_zipfile<EFBFBD>ZipFile<6C>namelist<73>tempfile<6C>
gettempdir<EFBFBD>extract)rU<00>archive<76>member<65>prefix<69>zip_file<6C>tmp<6D>extracted_pathr4r4r5<00>extract_zipped_paths<68>s 










rc

Cs.|d
krd
St|t
tttf<04>r&td<02>
<01>
t|<00>
S)a<>
Take 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')
        ValueError: cannot encode objects that are not 2-tuples
        >>> from_key_val_list({'key': 'val'})
        OrderedDict([('key', 'val')])

    :rtype: OrderedDict
    Nz+cannot encode objects that are not 2-tuples)rZr
r	<00>boolr*<00>
ValueErrorr)
<01>valuer4r4r5<00>from_key_val_list
s


r<>c

Cs@|d
krd
St|t
tttf<04>r&td<02>
<01>
t|t<06>r8|<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')
        ValueError: cannot encode objects that are not 2-tuples.

    :rtype: list
    Nz+cannot encode objects that are not 2-tuples)	rZr
r	r<>r*r<>rr7<00>list)
r<>r4r4r5<00>to_key_val_list
s



r<>c
Cs\g}
xRt|<00>
D]F}|d
d<02>|dd
<01>kr6dkrJn
nt
|dd<03><00>
}|
<01>|<02>

qW|
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
    Nrrj<00>
")<03>_parse_list_header<65>unquote_header_value<75>append)r<><00>result<6C>itemr4r4r5<00>parse_list_header8
s

(


r<>c
Cs|i}
xrt|<00>
D]f}d
|kr$d|
|<q|<02>
d
d<03>\}}|dd<03>|dd<02>krXdkrln
nt|dd<04><00>
}||
|<qW|
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>
=Nrrjr<>)r<>r-r<>)r<>r<>r<>rhr4r4r5<00>parse_dict_headerX
s





(


r<>cCs\|rX|d
|dkr dkrXn
n4|dd<02>}|
rD|dd<06>dkrX|<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
rjr<>rNrAz\\<5C>
\z\")
r.)r<><00>is_filenamer4r4r5r<>{
s
$

r<>c
Cs"i}
x|D]}|j|
|j
<q
W|
S)
z<>Returns a key/value dictionary from a CookieJar.

    :param cj: CookieJar object to extract cookies from.
    :rtype: dict
    )r<>rh)<03>cj<63>cookie_dict<63>cookier4r4r5<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<>r4r4r5<00>add_dict_to_cookiejar<61>
sr<>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=["\']*(.+?)["\'>])rHrI<00>DeprecationWarningr/<00>compiler1<00>findall)<04>content<6E>
charset_re<EFBFBD>	pragma_re<72>xml_rer4r4r5<00>get_encodings_from_content<6E>
s




r<>c

Cs<>|<00>d
<01>
}
|
d<00>
<01>|
dd<04>}}i}d}xh|D]`}|<06>
<01>}|r2|d}}|<06>d<07>
}	|	dkr<>|d|	<09><00>
|<05>
}||	dd<04><00>
|<05>
}|||<07><03><q2W||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>rj)r-<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_equalsr4r4r5<00>_parse_content_type_header<65>
s















r<>c
CsD|<00>d
<01>
}
|
sdSt
|
<01>
\}
}d|kr4|d<00>d<04>
Sd|
kr@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-1)<03>getr<74>r<>)<03>headersr<73>r<>r4r4r5<00>get_encoding_from_headers<72>
s



r<>ccsr|
jd
kr"x|D]
}|V
qWd
St
<01>|
j<00>
dd<03>
}x |D]}|<03>|<04>
}|r:|V
q:W|jddd<06>}|rn|V
d
S)zStream decodes a iterator.Nr.)
<01>errors<72>T)
<01>final)<04>encoding<6E>codecs<63>getincrementaldecoderr[)<06>iterator<6F>
rr<72><00>decoder<65>chunk<6E>rvr4r4r5<00>stream_decode_response_unicode<64>
s















r<>ccsLd
}|
dks|
d
k
rt|<00>
}
x*|t|<00>
krF||||
<00>V
||
7}qWdS)z Iterate over slices of a string.r
N)
r<)<03>string<6E>slice_length<74>posr4r4r5<00>iter_slicess




r<>c
Csvt<00>
d
t<02>
g}
t|j<04>
}|rJyt|j|<02>Stk
rH


|
<01>|<02>

YnXyt|j|dd<03>St	k
rp


|jSXdS)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.)r.)
r<>N)
rHrIr<>r<>r<>r
r<><00>UnicodeErrorr<72><00>	TypeError)r<><00>tried_encodingsr<73>r4r4r5<00>get_unicode_from_responses








r<>zBABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~c
	Cs<>|<00>d
<01>
}
x<>t
dt|
<01>
<01>D]<5D>}|
|dd<04>}t|<03>
dkr<>|<03><03>r<>ytt|d<05><02>
}Wn tk
rt


td|<00>
<01>
YnX|tkr<>||
|dd<07>|
|<q<>d
|
||
|<qd
|
||
|<qWd<08>	|
<01>
S)	z<>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
rA<00>z%Invalid percent-escape sequence: '%s'N<>)
r-<00>ranger<<00>isalnum<75>chrr*r<>r<00>UNRESERVED_SETrq)<05>uri<72>parts<74>
i<>
h<>
cr4r4r5<00>unquote_unreserved5s









r<>c
Cs:d
}
d}ytt
|<00>
|
d<03>Stk
r4


t||d<03>SXdS)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>safeN)rr<>r)r<><00>safe_with_percent<6E>safe_without_percentr4r4r5<00>requote_uriMs


r<>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
rp)<07>struct<63>unpack<63>socket<65>	inet_atonr-<00>dotted_netmaskr*)<07>ip<69>net<65>ipaddr<64>netaddr<64>bits<74>netmask<73>networkr4r4r5<00>address_in_networkcs




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>r4r4r5r<>rs
r<>c

Cs*yt<00>
|<00>

Wntjk
r$


d
SXdS)z
    :rtype: bool
    FT)r<>r<><00>error)
<01>	string_ipr4r4r5<00>is_ipv4_address}s




r<>c
Cs<>|<00>d
<01>
dkr<>yt
|<00>d
<01>
d<00>
}
Wntk
r8


dSX|
dksJ|
dkrNdSyt<04>|<00>d
<01>
d<00>

Wq<>tjk
r|


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

    :rtype: bool
    rprFr<46>r
T)<07>countr*r-r<>r<>r<>r<>)<02>string_networkr<6B>r4r4r5<00>
is_valid_cidr<64>s








r<>c	csT|
d
k	}|r"tj
<01>|<00>
}|
tj
|<z
d
V
Wd
|rN|d
krDtj
|=n
|tj
|<Xd
S)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)rD<00>environr<6E>)<04>env_namer<65><00>
value_changed<65>	old_valuer4r4r5<00>set_environ<6F>s









r<>c	
Cs,
d
d<02>}|
}|
dkr|d<04>
}
t|<00>
}|j
dkr2dS|
r<>dd<07>|
<01>dd	<09><02>d
<EFBFBD>
D<00>
}
t|j
<01>
r<>xz|
D],}t|<05>
r<>t|j
|<05>r<>dSqb|j
|krbdSqbWnD|j
}|jr<>|d<0B>|j<07>
7}x&|
D]}|j
<01>	|<07>
s<>|<06>	|<07>
r<>dSq<>Wt
d|<03><02>6
yt|j
<01>
}Wn tt
jfk
<EFBFBD>
r


d}YnXWdQRX|<08>
r(dSdS)
zL
    Returns whether we should bypass proxies or not.

    :rtype: bool
    c

Sstj
<01>|<00>
ptj
<01>|<00><03><00>
S)
N)rDr<>r<><00>upper)
<01>
kr4r4r5<00><lambda><3E>r<>z'should_bypass_proxies.<locals>.<lambda>N<>no_proxyTc
ss|]}
|
r|
V
qdS)
Nr4)<02>.0r2r4r4r5<00>	<genexpr><3E>sz(should_bypass_proxies.<locals>.<genexpr><3E>
 r<><00>
,z:{}F)r<00>hostnamer.r-r<>r<>r<><00>portrW<00>endswithr<68>rr<>r<><00>gaierror)	r_r<><00>	get_proxy<78>no_proxy_arg<72>parsed<65>proxy_ip<69>host_with_portr2<00>bypassr4r4r5<00>should_bypass_proxies<65>s<




















r
cCst||
d
<01>riSt
<01>SdS)zA
    Return a dict of environment proxies.

    :rtype: dict
    )
r<>N)r
r
)r_r<>r4r4r5<00>get_environ_proxies<65>s
r
cCsv|
pi}
t|<00>
}|j
d
kr.|
<01>|j|
<01>d<02>
<01>S|jd|j
|jd|j
dg}d
}x|D]}||
krX|
|}PqXW|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<>r<><00>scheme)r_<00>proxies<65>urlparts<74>
proxy_keys<EFBFBD>proxy<78>	proxy_keyr4r4r5<00>select_proxy<78>s











r

<00>python-requestsc

Csd
|tfS)zO
    Return a string representing the default user agent.

    :rtype: str
    z%s/%s)
r)
rhr4r4r5<00>default_user_agentsr
cCstt
<01>d
<01>d<02>
ddd<05><04>
S)z9
    :rtype: requests.structures.CaseInsensitiveDict
    z, )<02>gzip<69>deflatez*/*z
keep-alive)z
User-AgentzAccept-Encoding<6E>Accept<70>
Connection)rr
rqr4r4r4r5<00>default_headers"s




r
c
	
Cs<>g}
d
}|<00>|<02>
}|s|
Sx<>t
<01>d|<00>D]<5D>}y|<03>dd<04>\}}Wntk
r^


|d}}YnXd|<04>d<07>
i
}xP|<05>d<03>
D]B}y|<07>d<08>
\}}Wntk
r<EFBFBD>


PYnX|<00>|<02>
||<08>|<02>
<qzW|
<01>|<06>

q(W|
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<>r_z<> '"r<>)r<>r/r-r<>r<>)	r<><00>links<6B>
replace_chars<72>valr_r<><00>linkr<6B>r<>r4r4r5<00>parse_header_links.s&










r
<00>
rSrA<00>c
Cs<>|d
d<02>}
|
tj
tjfkr dS|
d
d<04>tjkr6dS|
d
d<06>tjtjfkrRdS|
<01>t<07>
}|dkrhd	S|dkr<>|
d
d
d<06>tkr<>d
S|
dd
d<06>tkr<>dS|dkr<>|
d
d<04>t	kr<>d
S|
dd
<01>t	kr<>dSd
S)z
    :rtype: str
    N<>zutf-32r
z	utf-8-sigrAzutf-16r
zutf-8z	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<45><00>_null<6C>_null2<6C>_null3)<03>data<74>sample<6C>	nullcountr4r4r5<00>guess_json_utfYs*


















r(
cCs8t||
<01>\}}}}}}|s$||}}t
||||||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
    )rr)r_<00>
new_schemer
r\rUr<><00>query<72>fragmentr4r4r5<00>prepend_scheme_if_neededys

r,
c
	CsBt|<00>
}
yt
|
j<02>
t
|
j<03>
f}Wnttfk
r<


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

    :rtype: (str,str)
    )r<>r<>)rr<00>username<6D>passwordr^r<>)r_r
<00>authr4r4r5<00>get_auth_from_url<72>s



r0
s^\S[^\r\n]*$|^$z^\S[^\r\n]*$|^$c
	Csf|\}
}t|t
<01>rt}nt}y|<03>|<02>
s4td
|
<00>
<01>
Wn*tk
r`


td|
|t|<02>
f<00>
<01>
YnXdS)z<>Verifies that header value is a string which doesn't contain
    leading whitespace or return characters. This prevents unintended
    header injection.

    :param header: tuple, in the format (name, value).
    z7Invalid return character or leading space in header: %sz>Value for header {%s: %s} must be of type str or bytes, not %sN)rZr	<00>_CLEAN_HEADER_REGEX_BYTE<54>_CLEAN_HEADER_REGEX_STRr0rr<><00>type)r<>rhr<><00>patr4r4r5<00>check_header_validity<74>s








r5
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
    <20>
@rrjr<>)r<00>rsplitr)r_r
r\rUr<>r*
r+
r4r4r5<00>
urldefragauth<74>s


r8
c
	Cs`t|j
d
d<02>}
|
dk	rTt|jt<04>rTy|
|j<03>

Wq\ttfk
rP


td<03>
<01>
Yq\Xntd<04>
<01>
dS)zfMove file pointer back to its recorded starting position
    so it can be read again on redirect.
    r@Nz;An error occurred when rewinding request body for redirect.z+Unable to rewind request body for redirect.)rl<00>bodyrZ<00>_body_positionrrJr,r)<02>prepared_request<73>	body_seekr4r4r5<00>rewind_body<64>s




r=
)
F)
F)
N)
r
)a<>__doc__r<5F><00>
contextlibrBrDr/r<>r<><00>sysrvrHrrrr<>r<00>_internal_utilsr<00>compatrr<>rrr	r
rrr
rrrrrrrr<00>cookiesr<00>
structuresr<00>
exceptionsrrrrrT<00>where<72>DEFAULT_CA_BUNDLE_PATH<54>
DEFAULT_PORTS<54>platformr6r:rOrgrorr<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<><00>	frozensetr<74>r<>r<>r<>r<>r<>r<><00>contextmanagerr<72>r
r
r

r
r
r
<00>encoder"
r#
r$
r(
r,
r0
r<>r1
r2
r5
r8
r=
r4r4r4r5<00><module>	s<>












D


'	=
3  #

%
=

	&