Trancribe/venv/lib/python3.12/site-packages/requests/__pycache__/utils.cpython-312.pyc

<EFBFBD>
$n!j<><6A><00>
<01>B<00>UdZd
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@
erd
dlAmBZB
d
dlmCZC
ddlm%ZD
ddlEmFZFmGZGmHZH
dZIdeJd<ej<><00>ZLdeJd<ddd<1D>ZMdeJd<ed<1F>
ZNed <20>
ZOd!j<>ej<>d"ed#<23>$<24>
d%<00><00>
ZRdeJd&<e
j<EFBFBD>d'k(rd\d(<28>ZTd\d)<29>Z/				d]d*<2A>ZUd^d+<2B>ZV	d_					d`d,<2C>ZWdad-<2D>ZXdbd.<2E>ZYej<>dcd/<2F><04>Z[				ddd0<64>Z\eded1<64><04>Z]e				dfd2<64><04>Z]				dgd3<64>Z]dhd4<64>Z^did5<64>Z_d_djd6<64>Z`dkd7<64>Zadld8<64>Zbdmd9<64>Zcdnd:<3A>Zddod;<3B>Ze						dpd<<3C>Zfe						dqd=<3D><04>Zge						drd><3E><04>Zg						dsd?<3F>Zgdtd@<40>ZheidA<64>
ZjdeJdB<dudC<64>ZkdudD<64>ZldvdE<64>ZmdwdF<64>ZndxdG<64>ZodydH<64>Zpej<>dzdI<64><04>Zqd{dJ<64>Zrd|d}dK<64>Zsd~dL<64>Zt	d							d<>dM<64>Zud<75>d<EFBFBD>dN<64>Zvd<76>dO<64>Zwd<77>dP<64>ZxdQj<51>dR<64>
ZzezdSzZ{ezdTzZ|d<>dU<64>Z}d<>dV<64>Z~d<>dW<64>Zd<7F>dX<64>Z<>								d<>dY<64>Z<>d<EFBFBD>dZ<64>Z<>d<EFBFBD>d[<5B>Z<>y)<29>z<EFBFBD>
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>win32c

<01><00>	d
dl}
	|
j|
jd<03>}t	|
j|d<04>d
<00>
}|
j|d<05>d
}|r|s
y|jd<06>
}td|<04>}|D]j}|dk(rd|v
r
y	|jdd
<EFBFBD>}|jdd<0C>}|jd
d<08>}tj||tj<00>s
<01>j
y	y#t$r
YywxYw
#ttf$r
YywxYw
)NrFz;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>hostrF<00>internetSettings<67>proxyEnable<6C>
proxyOverride<64>tests      <20>P/home/jean/linux-transcriber/venv/lib/python3.12/site-packages/requests/utils.py<70>proxy_bypass_registryrZcs%
<00><00>	<19><19>
	<19>%<25>~<7E>~<7E><16>(<28>(<28>N<> <0E><1C>
<1E>f<EFBFBD>1<>1<>2B<32>M<EFBFBD>R<>ST<53>U<>V<>K<EFBFBD>"<22>/<2F>/<2F>0@<40>/<2F>R<>ST<53>U<>M<EFBFBD><1B>-<2D><18>
&<26>+<2B>+<2B>C<EFBFBD>0<>
<0A><1E>t<EFBFBD>]<5D>3<>
<0A>!<21>	<1C>D<EFBFBD><13>y<EFBFBD> <20><16>d<EFBFBD>?<3F><1F><17><<3C><<3C><03>U<EFBFBD>+<2B>D<EFBFBD><17><<3C><<3C><03>U<EFBFBD>+<2B>D<EFBFBD><17><<3C><<3C><03>T<EFBFBD>*<2A>D<EFBFBD><11>x<EFBFBD>x<EFBFBD><04>d<EFBFBD>B<EFBFBD>D<EFBFBD>D<EFBFBD>)<29><1B>	<1C><15><>C
<1B>
	<19><18>
	<19><><18><1A>$<24>
	<19><18>
	<19>s#<00>C(<00>AC7<00>(	C4<03>3
C4<03>7D	<03>
D	c

<01>B<00>t
<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.
        )rrrZ)
rTs
 rYrr<00>s <00><00>"<22>#<23>+<2B>D<EFBFBD>1<>1<>(<28><14>.<2E>.<2E>c

<01>F<00>t
|t<00>r|j<00>S|S)
z/Returns an internal sequence dictionary update.)<03>
isinstance<EFBFBD>_SupportsItems<6D>items)
<01>
ds
 rY<00>dict_to_sequencerb<00>s<00><00>
<12>!<21>^<5E>$<24><10>w<EFBFBD>w<EFBFBD>y<EFBFBD><18><0C>Hr\c

<01><><00>d}
d
}ts!t|t<00>r|jd<02>
}t	|d<03>rt|<00>
}
n~t	|d<04>r
|j
}
net	|d<05>rY	|j
<00>}tj|<03>
j}
d|jv
rtjdt<00>
	t	|d<08>rW	|j#<00>}t	|d	<09>r:|
<01>8	|j%d
d
<EFBFBD>
|j#<00>}
|j%|x
s
d
<01>

|
<01>d
}
t)d
|
|z
<00>S#tjt f$r
Y<00><>wxYw
#t&$r
d
}
Y<00>?wxYw
#t&$r
|
<01>|
}Y<00>RwxYw
)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>os<6F>fstat<61>st_size<7A>mode<64>warnings<67>warnr(<00>io<69>UnsupportedOperation<6F>AttributeErrorrirjrL<00>max)<04>
o<>total_length<74>current_positionrgs    rY<00>	super_lenr{<00>sy
<00><00><17>L<EFBFBD><18><14><17>J<EFBFBD>q<EFBFBD>#<23>.<2E>
<0E>H<EFBFBD>H<EFBFBD>W<EFBFBD><1D>
<01><0E>q<EFBFBD>)<29><1C><1A>1<EFBFBD>v<EFBFBD><0C>	<10><11>E<EFBFBD>	<1A><18>u<EFBFBD>u<EFBFBD><0C>	<10><11>H<EFBFBD>	<1D>	<12><16>X<EFBFBD>X<EFBFBD>Z<EFBFBD>F<EFBFBD><1E>8<EFBFBD>8<EFBFBD>F<EFBFBD>+<2B>3<>3<>L<EFBFBD><13>!<21>&<26>&<26> <20><18>
<0A>
<0A>2<>$<24>
<12><0F>q<EFBFBD>&<26><19>	%<25> <20>v<EFBFBD>v<EFBFBD>x<EFBFBD><1C><17>q<EFBFBD>&<26>!<21>l<EFBFBD>&:<3A>	%<25><15>F<EFBFBD>F<EFBFBD>1<EFBFBD>a<EFBFBD>L<EFBFBD>#$<24>6<EFBFBD>6<EFBFBD>8<EFBFBD>L<EFBFBD><16>F<EFBFBD>F<EFBFBD>+<2B>0<>q<EFBFBD>1<><14><1B><18><0C><0E>q<EFBFBD>,<2C>!1<>1<>2<>2<><32>e
<13>'<27>'<27><1E>8<>	<11>
<11>		<11><>X
<1F>
%<25>#$<24>L<EFBFBD>
%<25><>%<17>	0<>
<1C>'<27>#/<2F> <20><>
	0<>s6<00>*D8<00>E(<00>.7E<00>8E<03>
E<03>E%<03>$
E%<03>(
E8<03>7
E8c
<01>`<00>t
|t<00>r|jd
<01>
}tjjd<02>
}|<02>|f
}n
d<04>tD<00>}	ddlm}m}
d}|D]D}tjj|<07>
}tjj|<08>
s
<01>B|}
n
|<06>
yt|<00>
}	|	j}
|
<EFBFBD>
y	||<06>
j|
<EFBFBD>
}|r't|<0B>
r|drdn
d}||x
s
d|d	x
s
dfSyy#|t f$r
|
r
<01>YywxYw
#t"t$f$r
YywxYw
)
z;Returns the Requests tuple auth for a given url from netrc.rd<00>NETRCNc
3
<01>&K
<00>|]	}
d|
<01><00><02>
<01>

<00>y
<01>w
)z~/N<>)<02>.0<EFBFBD>
fs  rY<00>	<genexpr>z!get_netrc_auth.<locals>.<genexpr><3E>s<00><00><><00>9<>
<01>R<EFBFBD>
<01>s<EFBFBD>8<EFBFBD>9<>s<00>
r)<02>NetrcParseError<6F>netrcr<00>rk)r^r<00>decodern<00>environ<6F>getr4r<>r<><00>path<74>
expanduser<EFBFBD>existsr#<00>hostname<6D>authenticators<72>anyrLrGrv)
<0A>url<72>raise_errors<72>
netrc_file<EFBFBD>netrc_locationsr<73>r<><00>
netrc_pathr<EFBFBD><00>loc<6F>rirTr3<00>login_is
             rY<00>get_netrc_authr<68><00>s@
<00><00>
<12>#<23>u<EFBFBD><1D><11>j<EFBFBD>j<EFBFBD><17>!<21><03><13><1A><1A><1E><1E><07>(<28>J<EFBFBD><11><1D>%<25>-<2D><0F>9<>[<5B>9<><0F>#
<0A>0<><19>
<EFBFBD> <20>	<16>A<EFBFBD><14>'<27>'<27>$<24>$<24>Q<EFBFBD>'<27>C<EFBFBD><11>w<EFBFBD>w<EFBFBD>~<7E>~<7E>c<EFBFBD>"<22> <20>
<EFBFBD><15>		<16><16><1D><12>
<15>c<EFBFBD>]<5D><02><11>{<7B>{<7B><04><0F><<3C><12>
	<16><1A>:<3A>&<26>5<>5<>d<EFBFBD>;<3B>F<EFBFBD><15>#<23>f<EFBFBD>+<2B>%<25>a<EFBFBD>y<EFBFBD>!<21>a<EFBFBD><07><1E>w<EFBFBD><0F>-<2D>2<EFBFBD>v<EFBFBD>a<EFBFBD>y<EFBFBD><EFBFBD>B<EFBFBD>?<3F>?<3F>&<26>v<EFBFBD><76> <20><17>)<29>	<16><1C><15><1C>	<16><>
<18><1E>(<28>

<0A><0C>

<0A>s=<00>A
D<00>#D<00>+D<00>>D<00>D<03>
D<00>
D<03>D<00>D-<03>,
D-c

<01><><00>t
|d
d<02>}
|
rHt|
ttf<02>r1|
ddk7r(|
ddk7rtj
j
|
<01>
Syyyy)z0Tries to guess the filename of the given object.<2E>nameNr<00>
<<3C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
>)<07>getattrr^r!rrnr<><00>basename)<02>objr<6A>s  rY<00>guess_filenamer<65>
sX<00><00><12>3<EFBFBD><06><04>%<25>D<EFBFBD><0B>
<EFBFBD>4<EFBFBD>#<23>u<EFBFBD><1C>.<2E>4<EFBFBD>
<01>7<EFBFBD>c<EFBFBD>><3E>d<EFBFBD>2<EFBFBD>h<EFBFBD>RU<52>o<EFBFBD><11>w<EFBFBD>w<EFBFBD><1F><1F><04>%<25>%<25>G
V
<01>><3E>.<2E>tr\c

<01>F<00>tjj|<00>
r|Stjj|<00>
\}
}|
rytjj|
<01>
sZtjj|
<01>
\}
}|s
n5d
j	||g<02>
}|
r tjj|
<01>
s
<01>Ztj|
<01>
s|Stj|
<01>
}||j<00>v
r|Stjj|jd
<01>
d<00>
d}tj|<05><03>
\}}	t
j||j|<02>
<00>
t
j|<06>

|S#t
j|<06>

wxYw
)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)rnr<>r<>rN<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_paths        rY<00>extract_zipped_pathsr<73>"
s;
<00><00>

<EFBFBD>w<EFBFBD>w<EFBFBD>~<7E>~<7E>d<EFBFBD><1B><13><0B><19>g<EFBFBD>g<EFBFBD>m<EFBFBD>m<EFBFBD>D<EFBFBD>)<29>O<EFBFBD>G<EFBFBD>V<EFBFBD>
<11>"<22>'<27>'<27>.<2E>.<2E><17>1<><1C>'<27>'<27>-<2D>-<2D><07>0<><0F><07><16><15>
<12><14><18><18>6<EFBFBD>6<EFBFBD>*<2A>+<2B><06>
<12>"<22>'<27>'<27>.<2E>.<2E><17>1<><13><1D><1D>g<EFBFBD>&<26><13><0B><16><EFBFBD><EFBFBD>w<EFBFBD>'<27>H<EFBFBD>
<0A>X<EFBFBD>&<26>&<26>(<28>(<28><13><0B><10>W<EFBFBD>W<EFBFBD>
<1D>
<1D>f<EFBFBD>l<EFBFBD>l<EFBFBD>3<EFBFBD>/<2F><02>3<>
4<>R<EFBFBD>
8<>F<EFBFBD>!<21>)<29>)<29><16>8<><16>B<EFBFBD><0E><15>
<EFBFBD><08><08><12>X<EFBFBD>]<5D>]<5D>6<EFBFBD>*<2A>+<2B>
<EFBFBD><08><08><12><0C><19><19><>	<0B><08><08><12><0C>s<00>
%F	<00>	F c
#
<01>J
K
<00>t
jtjj	|<00>
<00>
<01>
\}
}	tj
|
d<02>5}|<03><03>

ddd<03>
tj||<00>
y#1s
w
Y

<00> xYw
#t$r
tj|<02>

<00>wxYw
<01>w
)z-Write a file to the disk in an atomic fashion)
<01>dir<69>wbN)	r<>r<>rnr<><00>dirname<6D>fdopenrP<00>
BaseException<6F>remove)<04>filename<6D>tmp_descriptor<6F>tmp_name<6D>tmp_handlers    rY<00>atomic_openr<6E>H
s<><00><00><><00> (<28>/<2F>/<2F>B<EFBFBD>G<EFBFBD>G<EFBFBD>O<EFBFBD>O<EFBFBD>H<EFBFBD>4M<34>N<><1C>N<EFBFBD>H<EFBFBD><0E>
<0F>Y<EFBFBD>Y<EFBFBD>~<7E>t<EFBFBD>
,<2C>
	<1E><0B><1D><1D>
	<1E>
<EFBFBD>
<EFBFBD>
<EFBFBD>8<EFBFBD>X<EFBFBD>&<26>
	<1E>
	<1E><><19><0E>
<EFBFBD>	<09>	<09>(<28><1B>
<0A><0E>s4<00>7B#
<01>B<00>A4<03>B<00>3
B#
<01>4A=<07>9B<00> B <03> B#
c

<01>t<00>|<00>
y
t
|ttttf<04>rtd<02>
<00>
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!r<00>boolrJrMr<00>
<01>values
 rY<00>from_key_val_listr<74>U
s6<00><00>(
<0A>}<7D><13><11>%<25>#<23>u<EFBFBD>d<EFBFBD>C<EFBFBD>0<>1<><18>F<>G<>G<><16>u<EFBFBD><1D>r\c

<01><00>y<00>
Nrr<>s
 rY<00>to_key_val_listr<74>r
s<00><00>*-r\c

<01><00>yr<>rr<>s
 rYr<>r<>t
s<00><00> r\c

<01><><00>|<00>
y
t
|ttttf<04>rtd<02>
<00>
t
|t<00>rt|j<00><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<>rJrMr_<00>listr`r<>s
 rYr<>r<>x
sP<00><00>&
<0A>}<7D><13><11>%<25>#<23>u<EFBFBD>d<EFBFBD>C<EFBFBD>0<>1<><18>F<>G<>G<><11>%<25><1E>(<28><13>E<EFBFBD>K<EFBFBD>K<EFBFBD>M<EFBFBD>"<22>"<22><0F><05>;<3B>r\c

<01><><00>g}
t
|<00>
D]5}|d
d|dd
cxk(rdk(rn
nt|dd<00>
}|
j|<02>

<00>7|
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>items   rY<00>parse_list_headerr<72><00>
sY<00><00>.<1B>F<EFBFBD>"<22>5<EFBFBD>)<29><1C><04><0F><02><11>8<EFBFBD>t<EFBFBD>B<EFBFBD>C<EFBFBD>y<EFBFBD>'<27>C<EFBFBD>'<27>'<27><04>Q<EFBFBD>r<EFBFBD>
<EFBFBD>3<>D<EFBFBD><0E>
<0A>
<0A>d<EFBFBD><1B><1C><12>Mr\c

<01><><00>i}
t
|<00>
D]H}d
|v
rd|
|<<00>
|jd
d<03>\}}|dd|ddcxk(rdk(rn
nt|dd<00>
}||
|<<00>J|
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<>rNr<>)r<>r<>r<>r<>s    rY<00>parse_dict_headerr<72><00>
s}<00><00>,%'<27>F<EFBFBD>"<22>5<EFBFBD>)<29><1D><04><0E>d<EFBFBD>?<3F><1F>F<EFBFBD>4<EFBFBD>L<EFBFBD><14><1A>j<EFBFBD>j<EFBFBD><13>a<EFBFBD>(<28><0B><04>e<EFBFBD><10><12>!<21>9<EFBFBD><05>b<EFBFBD>c<EFBFBD>
<EFBFBD>)<29>c<EFBFBD>)<29>(<28><15>q<EFBFBD><12><1B>5<>E<EFBFBD><1C><06>t<EFBFBD><0C><1D><12>Mr\c
<01><><00>|rF|d
|dcxk(rdk(r5n
|S|dd}|
r|dddk7r"|j
dd<08>j
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
    rr<>r<>rNrkz\\<5C>
\z\")
rP)r<><00>is_filenames  rYr<>r<><00>
sd<00><00>
<0A><15>q<EFBFBD><18>U<EFBFBD>2<EFBFBD>Y<EFBFBD>-<2D>#<23>-<2D><11>L<EFBFBD><16>a<EFBFBD><02><0B><05><1B>e<EFBFBD>B<EFBFBD>Q<EFBFBD>i<EFBFBD>6<EFBFBD>1<><18>=<3D>=<3D><16><14>.<2E>6<>6<>u<EFBFBD>c<EFBFBD>B<>B<><10>Lr\c

<01>X<00>|D<00>
cic]}
|
j|
j<00><02>}}
|Sc
c}
w)
z<>Returns a key/value dictionary from a CookieJar.

    :param cj: CookieJar object to extract cookies from.
    :rtype: dict
    )r<>r<>)<03>cj<63>cookie<69>cookie_dicts   rY<00>dict_from_cookiejarr<72><00>
s/<00><00><><3E>><3E><16>6<EFBFBD>;<3B>;<3B><06><0C><0C>,<2C>><3E>K<EFBFBD>><3E><16><16><>?s<00>'c
<01><00>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<>s  rY<00>add_dict_to_cookiejarr<72><00>
s<00><00><1F>{<7B>B<EFBFBD>/<2F>/r\c

<01>^
<00>t
jd
t<00>
tjdtj
<00><03>}
tjdtj
<00><03>}tjd<05>
}|
j
|<00>
|j
|<00>
z|j
|<00>
zS)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=["\']*(.+?)["\'>])rrrs<00>DeprecationWarningrQ<00>compilerS<00>findall)<04>content<6E>
charset_re<EFBFBD>	pragma_re<72>xml_res    rY<00>get_encodings_from_contentr<74>
s<><00><00>

<0A>M<EFBFBD>M<EFBFBD>
1<>	<1B>
<06><14><1A><1A>@<40><02><04><04>M<>J<EFBFBD><12>
<EFBFBD>
<EFBFBD>I<>QS<51>QU<51>QU<51>V<>I<EFBFBD>
<0F>Z<EFBFBD>Z<EFBFBD>?<3F>
@<40>F<EFBFBD>	<13><1A><1A>7<EFBFBD>#<23>
<13>
<1B>
<1B>G<EFBFBD>
$<24>
	%<25>
<10>.<2E>.<2E><17>
!<21>	"<22>r\c

<01>B
<00>|j
d
<01>
}
|
dj<00>|
dd}}i}d}|D]j}|j<00>}|s
<01>|jd<06>
x
}dk7s
<01>-|d|j|<05>
}||dzdj|<05>
}	|	||j<00><<00>l||fS)z<>Returns content type and parameters from given header.

    :param header: string
    :return: tuple containing content type and dictionary of
         parameters.
    rBrrNz"' r<>r<>)rN<00>strip<69>find<6E>lower)
<EFBFBD>header<65>tokens<6E>content_type<70>params<6D>params_dict<63>strip_chars<72>param<61>idx<64>keyr<79>s
          rY<00>_parse_content_type_headerr<72>#s<><00><00><14>\<5C>\<5C>#<23>
<1E>F<EFBFBD>!<21>!<21>9<EFBFBD>?<3F>?<3F>,<2C>f<EFBFBD>Q<EFBFBD>R<EFBFBD>j<EFBFBD>&<26>L<EFBFBD>)+<2B>K<EFBFBD><18>K<EFBFBD><17>-<2D><05><15><0B><0B>
<0A><05><10>U<EFBFBD>Z<EFBFBD>Z<EFBFBD><03>_<EFBFBD>,<2C>c<EFBFBD><12>3<><17><04><13>+<2B>#<23>#<23>K<EFBFBD>0<>C<EFBFBD><19>#<23>
<01>'<27>)<29>$<24>*<2A>*<2A>;<3B>7<>E<EFBFBD>',<2C>K<EFBFBD><03>	<09>	<09><0B>$<24>-<2D><18><1B>$<24>$r\c

<01><><00>|j
d
<01>
}
|
s
yt|
<01>
\}
}d|vr|djd<04>
Sd|
vr
yd|
vr
yy)	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<>)<03>headersr<73>r<>s   rY<00>get_encoding_from_headersr<73>9s`<00><00><1B>;<3B>;<3B>~<7E>.<2E>L<EFBFBD><17><13>5<>l<EFBFBD>C<><18>L<EFBFBD>&<26><10>F<EFBFBD><1A><15>i<EFBFBD> <20>&<26>&<26>u<EFBFBD>-<2D>-<2D>
<0A><1C><1D><1B><19>\<5C>)<29><16>*r\c#
<01><>K
<00>|
j<00>|Ed
{<00><02><02>
y
tj|
j<00>
d<02><03>
}|D]}|j|<03>
}|s
<01>|<04>
<01>

<00>|jdd<05><06>}|r|<04>
<01>

y
y
7<00>e<EFBFBD>w
)zStream decodes an iterator.NrP<00>
<01>errorsr\T)
<01>final)<04>encoding<6E>codecs<63>getincrementaldecoderr<72>)<05>iterator<6F>
r<>decoder<65>chunk<6E>rvs     rY<00>stream_decode_response_unicoder
Rs<><00><00><><00>
	<09>z<EFBFBD>z<EFBFBD><19><1B><1B><1B><0E>6<>f<EFBFBD>*<2A>*<2A>1<EFBFBD>:<3A>:<3A>6<>i<EFBFBD>H<>G<EFBFBD><19><15><05>
<14>^<5E>^<5E>E<EFBFBD>
"<22><02>
<0A><14>H<EFBFBD><15>
<11><1E><1E><03>4<EFBFBD><1E>	(<28>B<EFBFBD>	<09><10><08>
<EFBFBD>	<1C>s<00>A<
<01>
A:<04>AA<
<01>"A<
c
<01><00>yr<>r<00><02>string<6E>slice_lengths  rY<00>iter_slicesr
es<00><00>$'r\c
<01><00>yr<>rr
s  rYr
r
is<00><00>"%r\c#
<01><>K
<00>d
}|
<01>|
d
krt
|<00>
}
|t
|<00>
kr||||
z<00>
<01>

||
z
}|t
|<00>
kr
<01>yy<02>w
)z Iterate over slices of a string.rN)
rf)r
r
<00>poss   rYr
r
msY<00><00><><00><0C>C<EFBFBD><13><1B>|<7C>q<EFBFBD>0<><1A>6<EFBFBD>{<7B><0C>

<0A><03>F<EFBFBD><0B>
<1B><14>S<EFBFBD>3<EFBFBD><1C>-<2D>.<2E>.<2E><0B>|<7C><1B><03><0E><03>F<EFBFBD><0B>
<1B>s<00>AA
<01>A
c

<01>`
<00>t
jd
t<00>
|j<00>
yg}
t	|j
<00>
}|r	t
|j|<02>S	t
|j|x
s
dd<04><05>S#t$r
|
j|<02>

Y<00>9wxYw
#t$r
|jcYSwxYw
)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.)NrdrPr

)
rrrsr<>r<>r<>r<>r!<00>UnicodeErrorr<72><00>	TypeError)r
<00>tried_encodingsr
s   rY<00>get_unicode_from_responser
ys<><00><00>
<0A>M<EFBFBD>M<EFBFBD>
1<>	<1B>
<06>	<09>y<EFBFBD>y<EFBFBD><18><13>!#<23>O<EFBFBD>)<29><11><19><19>3<>H<EFBFBD><0F>	-<2D><16>q<EFBFBD>y<EFBFBD>y<EFBFBD>(<28>+<2B>+<2B>
<19><12>1<EFBFBD>9<EFBFBD>9<EFBFBD>h<EFBFBD>1<>'<27>)<29>D<>D<><44><1C>
	-<2D><1B>"<22>"<22>8<EFBFBD>,<2C>
	-<2D><><15>
<19><10>y<EFBFBD>y<EFBFBD><18>
<19>s$<00>A5<00>B<00>5B<03>
B<03>B-<03>,
B-zBABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~<7E>UNRESERVED_SETc

<01><>
<00>|j
d
<01>
}
tdt|
<01>
<00>D]l}|
|dd}t|<03>
dk(rI|j<00>r9	t	t|d<05><00>
}|tvr||
|ddz|
|<<00>Vd
|
|<00><00>|
|<<00>bd
|
|<00><00>|
|<<00>nd	j|
<01>
S#t$r
td|<03>d<07><03>
<00>
wxYw
)
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>
%rrrk<00>z"Invalid percent-escape sequence: '<27>
'Nr<4E>)
rN<00>rangerf<00>isalnum<75>chrrJrMr*r
r<>)<05>uri<72>parts<74>
i<>
h<>
cs     rY<00>unquote_unreservedr'
<00>s<><00><00>
<10>I<EFBFBD>I<EFBFBD>c<EFBFBD>N<EFBFBD>E<EFBFBD>
<12>1<EFBFBD>c<EFBFBD>%<25>j<EFBFBD>
!<21>
&<26>
<01><11>!<21>H<EFBFBD>Q<EFBFBD>q<EFBFBD>M<EFBFBD>
<01><0E>q<EFBFBD>6<EFBFBD>Q<EFBFBD>;<3B>1<EFBFBD>9<EFBFBD>9<EFBFBD>;<3B>
L
<01><17><03>A<EFBFBD>r<EFBFBD>
<EFBFBD>O<EFBFBD>
<01><11>N<EFBFBD>"<22><1C>u<EFBFBD>Q<EFBFBD>x<EFBFBD>
<01><02>|<7C>+<2B><05>a<EFBFBD><08><1E>u<EFBFBD>Q<EFBFBD>x<EFBFBD>j<EFBFBD>><3E><05>a<EFBFBD><08><1A>5<EFBFBD><11>8<EFBFBD>*<2A>~<7E>E<EFBFBD>!<21>H<EFBFBD>
&<26><0E>7<EFBFBD>7<EFBFBD>5<EFBFBD>><3E><19><><1E>

L
<01> <20>#E<>a<EFBFBD>S<EFBFBD>
<01>!J<>K<>K<>

L
<01>s<00>B'<02>'Cc

<01>p<00>d
}
d}	t
t|<00>
|
<01><03>S#t$r
t
||<02><03>cYSwxYw
)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)r r'
r*)r"
<00>safe_with_percent<6E>safe_without_percents   rY<00>requote_urir,
<00>sJ<00><00>/<2F><15>0<><18>	5<><15>'<27><03>,<2C>3D<33>E<>E<><45><15>5<><15>S<EFBFBD>3<>4<>4<>	5<>s<00><00>5<03>
5c

<01>r
<00>t
jd
tj|<00>
<00>d}|
j	d<03>
\}}t
jd
tjtt
|<04>
<00>
<00>
<00>d}t
jd
tj|<03>
<00>d|z
}||z
||z
k(S)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=Lrr<>)<07>struct<63>unpack<63>socket<65>	inet_atonrN<00>dotted_netmaskrJ)<07>ip<69>net<65>ipaddr<64>netaddr<64>bits<74>netmask<73>networks       rY<00>address_in_networkr:
<00>s<><00><00><14>]<5D>]<5D>4<EFBFBD><16>!1<>!1<>"<22>!5<>
6<>q<EFBFBD>
9<>F<EFBFBD><17>I<EFBFBD>I<EFBFBD>c<EFBFBD>N<EFBFBD>M<EFBFBD>G<EFBFBD>T<EFBFBD><14>m<EFBFBD>m<EFBFBD>D<EFBFBD>&<26>"2<>"2<>><3E>#<23>d<EFBFBD>)<29>3L<33>"M<>N<>q<EFBFBD>Q<>G<EFBFBD><14>m<EFBFBD>m<EFBFBD>D<EFBFBD>&<26>"2<>"2<>7<EFBFBD>";<3B><<3C>Q<EFBFBD>?<3F>'<27>I<>G<EFBFBD><12>W<EFBFBD><1C>'<27>G<EFBFBD>"3<>4<>4r\c

<01>p<00>d
dd|z
zdz
z}
t
jtjd|
<01><00>
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)r0
<00>	inet_ntoar.
<00>pack)<02>maskr7
s  rYr2
r2
<00>s7<00><00><16><11>b<EFBFBD>4<EFBFBD>i<EFBFBD><1E>1<EFBFBD>,<2C>,<2C>D<EFBFBD><11><1B><1B>F<EFBFBD>K<EFBFBD>K<EFBFBD><04>d<EFBFBD>3<>4<>4r\c

<01>N<00>	t
j|<00>

y#t$r
Yy
wxYw
)z
    :rtype: bool
    FT)r0
r1
rL)
<01>	string_ips
 rY<00>is_ipv4_addressrB
<00>s.<00><00><15><0E><18><18><19>#<23><10><><13>
<15><14>
<15>s<00><00>	$<03>
$c

<01>
<00>|j
d
<01>
dk(rR	t|jd
<01>
d<00>
}
|
dks|
dkDr
y	t	j
|jd
<01>
d<00>

yy#t$r
YywxYw
#t$r
YywxYw
)zV
    Very simple check of the cidr format in no_proxy variable.

    :rtype: bool
    r<>rFr<
rT)<07>countrJrNrMr0
r1
rL)<02>string_networkr?
s  rY<00>
is_valid_cidrrF
<00>s<><00><00><16><1B><1B>C<EFBFBD> <20>A<EFBFBD>%<25>	<19><16>~<7E>+<2B>+<2B>C<EFBFBD>0<><11>3<>4<>D<EFBFBD><10>!<21>8<EFBFBD>t<EFBFBD>b<EFBFBD>y<EFBFBD><18>	<19><12><1C><1C>^<5E>1<>1<>#<23>6<>q<EFBFBD>9<>:<3A>
<10><15><><1A>
	<19><18>
	<19><><17>
	<19><18>
	<19>s"<00>A(<00>'A7<00>(	A4<03>3
A4<03>7	B<03>
Bc#
<01><
K
<00>|
d
u
}d
}|r2tjj|<00>
}|
tj|<	d
<01><02>

|r(|<03>tj|=y
|tj|<y
y
#|r(|<03>tj|=w|tj|<wwxYw
<01>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)rnr<>r<>)<04>env_namer<65><00>
value_changed<65>	old_values    rY<00>set_environrK
s<><00><00><><00><1A><14>%<25>M<EFBFBD> <20>I<EFBFBD><14><16>J<EFBFBD>J<EFBFBD>N<EFBFBD>N<EFBFBD>8<EFBFBD>,<2C>	<09>$<24><02>
<EFBFBD>
<EFBFBD>8<EFBFBD><1C>1<>
<0A><18><18> <20><16>J<EFBFBD>J<EFBFBD>x<EFBFBD>(<28>'0<><02>
<EFBFBD>
<EFBFBD>8<EFBFBD>$<24>	<19><>=<3D><18> <20><16>J<EFBFBD>J<EFBFBD>x<EFBFBD>(<28>'0<><02>
<EFBFBD>
<EFBFBD>8<EFBFBD>$<24>	<19>s<00>;B
<01>A-<00>+B
<01>-,B<03>B
c
<01><><00>dd
<01>}|
}|
<01>|d<03>
}
t
|<00>
}|j}|<05>
y|
r<>d<05>|
jdd<07>jd<08>
D<00>}t	|<05>
r)|D]#}t|<07>
rt
||<07>s
<01>
y||k(s
<01>#
ynm|}|jr|d	|j<00><00>z
}|D]H}	|	jd
<EFBFBD>
}	||	k(s||	k(r
yd
|	z}	|j|	<09>
s|j|	<09>
s
<01>H
ytd|<03>5
	t|<05>
}
ddd<02>

r
yy#ttjf$r
d}
Y<00>)wxYw
#1s
w
Y

<00>.xYw
)
zL
    Returns whether we should bypass proxies or not.

    :rtype: bool
    c

<01><><00>tjj|<00>
x
s-
tjj|j<00><00>
Sr<>)rnr<>r<><00>upper)
r<>s
 rY<00>	get_proxyz(should_bypass_proxies.<locals>.get_proxy3s-<00><00><11>z<EFBFBD>z<EFBFBD>~<7E>~<7E>c<EFBFBD>"<22>A<>b<EFBFBD>j<EFBFBD>j<EFBFBD>n<EFBFBD>n<EFBFBD>S<EFBFBD>Y<EFBFBD>Y<EFBFBD>[<5B>&A<>Ar\N<>no_proxyTc
3
<01>&K
<00>|]	}
|
s
<01>|
<01>
<01>

<00>y<00>w
r<>r)r<>rTs  rYr<>z(should_bypass_proxies.<locals>.<genexpr>Es<00><00><><00>X<>4<EFBFBD>SW<53>$<24>X<>s<00>
<01>
<01>
 r<><00>
,<2C>
:rCF)r<>r!<00>return<72>
str | None)r#r<>rPrNrB
rF
r:
<00>port<72>lstrip<69>endswithrK
rr
r0
<00>gaierror)r<>rP
rO
<00>no_proxy_arg<72>parsedr<64><00>no_proxy_hosts<74>proxy_ip<69>host_with_portrT<00>bypasss           rY<00>should_bypass_proxiesra
*sn
<00><00>
B
<01>
<1C>L<EFBFBD><0F><17><1C>Z<EFBFBD>(<28><08>
<15>c<EFBFBD>]<5D>F<EFBFBD><15><EFBFBD><EFBFBD>H<EFBFBD><0F><17><13><0F>Y
<01>8<EFBFBD>+;<3B>+;<3B>C<EFBFBD><12>+D<>+J<>+J<>3<EFBFBD>+O<>X<><0E><1A>8<EFBFBD>$<24>*<2A>
 <20><08> <20><18>*<2A>)<29>(<28>H<EFBFBD>=<3D>#<23><1D><18>)<29> <20>
 <20>&<26>N<EFBFBD><15>{<7B>{<7B><1E>A<EFBFBD>f<EFBFBD>k<EFBFBD>k<EFBFBD>]<5D>"3<>3<><0E>&<26>
 <20><04><1B>{<7B>{<7B>3<EFBFBD>'<27><04><1B>t<EFBFBD>#<23>~<7E><14>'=<3D><1F><1A>T<EFBFBD>z<EFBFBD><04><1B>$<24>$<24>T<EFBFBD>*<2A>n<EFBFBD>.E<>.E<>d<EFBFBD>.K<><1F>

 <20>
<15>Z<EFBFBD><1C>	.<2E><1B>	<1B>!<21>(<28>+<2B>F<EFBFBD><1B><0E><13><10><>
<1A>6<EFBFBD>?<3F>?<3F>+<2B>
	<1B><1A>F<EFBFBD>
	<1B><><1B><1B>s*<00>
D<<03>D<02>D9<05>6D<<03>8
D9<05>9D<<03><Ec
<01>4<00>t
||
<01>
<01>riSt<00>S)zA
    Return a dict of environment proxies.

    :rtype: dict
    <20>
rP
)ra
r)r<>rP
s  rY<00>get_environ_proxiesrd
is<00><00><1D>S<EFBFBD>8<EFBFBD>4<><11>	<09><19>|<7C>r\c
<01>.
<00>|
x
s
i}
t
|<00>
}|j<00>+|
j|j|
jd<02>
<00>S|jdz|jz|jd|jzdg}d
}|D]}||
vs
<01>|
|}
|S|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<><00>proxies<65>urlparts<74>
proxy_keys<EFBFBD>proxy<78>	proxy_keys      rY<00>select_proxyrm
us<><00><00><16>m<EFBFBD><12>G<EFBFBD><17><03>}<7D>H<EFBFBD><0F><18><18> <20><16>{<7B>{<7B>8<EFBFBD>?<3F>?<3F>G<EFBFBD>K<EFBFBD>K<EFBFBD><05>,><3E>?<3F>?<3F>	<11><0F><0F>%<25><1F>(<28>"3<>"3<>3<><10><0F><0F><10>8<EFBFBD>$<24>$<24>$<24>
<0A>	<06>J<EFBFBD>
<11>E<EFBFBD><1F><12>	<09><14><07><1F><1B>I<EFBFBD>&<26>E<EFBFBD><11><10>L<EFBFBD><12>
<11>Lr\c
<01>T
<00>|
<01>|
n
i}
t
t|j<00>}t|<03>
j}|
jd
<01>
}|
j
<00>}|rOt||<05><02>sBt||<05><02>}|j||jd<03>
<00>}|r|j||<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
    rP
rc
rf
)
rr!r<>r#rg
r<><00>copyra
rd
<00>
setdefault)	<09>requestrh
<00>	trust_envr<76>rg
rP
<00>new_proxies<65>environ_proxiesrk
s	         rY<00>resolve_proxiesru
<00>s<><00><00>!<21>,<2C>g<EFBFBD>"<22>G<EFBFBD>
<0E>s<EFBFBD>G<EFBFBD>K<EFBFBD>K<EFBFBD>
 <20>C<EFBFBD>
<15>c<EFBFBD>]<5D>
!<21>
!<21>F<EFBFBD><16>{<7B>{<7B>:<3A>&<26>H<EFBFBD><19>,<2C>,<2C>.<2E>K<EFBFBD><10>.<2E>s<EFBFBD>X<EFBFBD>F<>-<2D>c<EFBFBD>H<EFBFBD>E<><0F><1F>#<23>#<23>F<EFBFBD>O<EFBFBD>,?<3F>,?<3F><05>,F<>G<><05><10><17>"<22>"<22>6<EFBFBD>5<EFBFBD>1<><16>r\c

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

    :rtype: str
    r<>r)
r<>s
 rY<00>default_user_agentrw
<00>s<00><00><13>V<EFBFBD>1<EFBFBD>[<5B>M<EFBFBD>"<22>"r\c
<01>:<00>t
t<00>td
dd<03><04>
S)z9
    :rtype: requests.structures.CaseInsensitiveDict
    z*/*z
keep-alive)z
User-AgentzAccept-Encoding<6E>Accept<70>
Connection)r,rw
r=rr\rY<00>default_headersr{
<00>s%<00><00><1F>,<2C>.<2E>6<><1B>&<26>		
<EFBFBD><06>r\c

<01><>
<00>g}
d
}|j
|<02>
}|s|
Stjd|<00>D]<5D>}	|jdd<04>\}}d|j
d<07>
i
}|jd<03>
D]:}	|jd<08>
\}}|j
|<02>
||j
|<02>
<<00><|
j	|<06>

<00><>|
S#t$r
|d}}Y<00><>wxYw
#t$r
Y
<00>4wxYw
)	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, *<rBrr<>r<>z<> '"r<>)r<>rQrNrMr<>)	r<><00>links<6B>
replace_chars<72>valr<6C>r<><00>linkr<6B>r<>s	         rY<00>parse_header_linksr<73>
<00>s<><00><00>#%<25>E<EFBFBD><1A>M<EFBFBD><11>K<EFBFBD>K<EFBFBD>
<0A>&<26>E<EFBFBD><10><14><0C><11>x<EFBFBD>x<EFBFBD><06><05>&<26><1B><03>	"<22><1D>)<29>)<29>C<EFBFBD><11>+<2B>K<EFBFBD>C<EFBFBD><16>!&<26>s<EFBFBD>y<EFBFBD>y<EFBFBD><18>':<3A>;<3B><04><1B>\<5C>\<5C>#<23>&<26>	H
<01>E<EFBFBD>
<16>"<22>[<5B>[<5B><13>-<2D>
<EFBFBD><03>U<EFBFBD>.3<EFBFBD>[<5B>[<5B><1D>-G<>D<EFBFBD><13><19><19>=<3D>)<29>*<2A>
	H
<01>	<0E><0C><0C>T<EFBFBD><1A>!<1B>$<11>L<EFBFBD><4C><1A>
	"<22><1D>r<EFBFBD><16>C<EFBFBD>
	"<22><><1E>

<16><15>

<16>s#<00>B?<02>1C<04>?
C<05>
C<05>	C<07>
C<07>
<00>asciirk<00>c

<01><>
<00>|d
d}
|
tjtjfvr
y|
d
dtjk(r
y|
d
dtjtj
fvr
y|
j
t<00>
}|dk(r
y	|dk(r |
d
d
d<06>tk(r
y
|
dd
d<06>tk(r
y|dk(r|
d
dtk(r
y
|
dd
tk(r
yy
)z
    :rtype: str
    N<>zutf-32r<32>
z	utf-8-sigrkzutf-16rrdz	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_BErD
<00>_null<6C>_null2<6C>_null3)<03>data<74>sample<6C>	nullcounts   rY<00>guess_json_utfr<66>
<00>s<><00><00><12>"<22>1<EFBFBD>X<EFBFBD>F<EFBFBD>
<0A>&<26>%<25>%<25>v<EFBFBD>':<3A>':<3A>;<3B>;<3B><17>
<0A>b<EFBFBD>q<EFBFBD>z<EFBFBD>V<EFBFBD>_<EFBFBD>_<EFBFBD>$<24><1A>
<0A>b<EFBFBD>q<EFBFBD>z<EFBFBD>f<EFBFBD>)<29>)<29>6<EFBFBD>+><3E>+><3E>?<3F>?<3F><17><16><0C><0C>U<EFBFBD>#<23>I<EFBFBD><10>A<EFBFBD>~<7E><16><10>A<EFBFBD>~<7E><11>#<23>A<EFBFBD>#<23>;<3B>&<26> <20><1E><11>!<21>$<24>Q<EFBFBD>$<24><<3C>6<EFBFBD>!<21><1E><10>A<EFBFBD>~<7E><11>"<22>1<EFBFBD>:<3A><16><1F><1E><11>!<21>"<22>:<3A><16><1F><1E>r\c
<01><><00>t
|<00>
}|\}}}}}}}	|j}
|
s||
}}
|r#tt|
<EFBFBD>}
d
j	||
g<02>
}
|<03>|
}|<07>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>
@r<>)r<00>netlocrr!r<>r$)r<><00>
new_schemer\
rg
<00>auth<74>_host<73>_portr<74><00>query<72>fragmentr<74>
s           rY<00>prepend_scheme_if_neededr<64>
s<><00><00><17>s<EFBFBD>^<5E>F<EFBFBD>8><3E>5<>F<EFBFBD>D<EFBFBD>%<25><15><04>e<EFBFBD>X<EFBFBD><14>]<5D>]<5D>F<EFBFBD><11><1B>V<EFBFBD><04><06><0B><16>c<EFBFBD>6<EFBFBD>"<22><06><14><18><18>4<EFBFBD><16>.<2E>)<29><06>
<0A>~<7E><1B><06><0B>|<7C><11><04><15>v<EFBFBD>v<EFBFBD>t<EFBFBD>R<EFBFBD><15><08>A<>B<>Br\c

<01><><00>t
|<00>
}
	t|
j<00>
t|
j<00>
f}|S#tt
f$r
d
}Y|SwxYw
)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>passwordrvr
)r<>r\
r<>
s   rY<00>get_auth_from_urlr<6C>
.sU<00><00><16>c<EFBFBD>]<5D>F<EFBFBD><18><17><06><0F><0F>(<28>'<27>&<26>/<2F>/<2F>*B<>C<><04><10>K<EFBFBD><4B>
<1B>I<EFBFBD>&<26>
<18><17><04><0F>K<EFBFBD>
<18>s<00>*9<00>A<03>

Ac

<01>B<00>|\}
}t
||
d
<01>
t
||d<02>
y)z<>Verifies that header parts don't contain leading whitespace
    reserved characters, or return characters.

    :param header: tuple, in the format (name, value).
    rrN)
<01>_validate_header_part)r<>r<>r<>s   rY<00>check_header_validityr<79>
?s%<00><00><19>K<EFBFBD>D<EFBFBD>%<25><19>&<26>$<24>
<01>*<2A><19>&<26>%<25><11>+r\c

<01><><00>t
|
t<00>r
t|}n7t
|
t<00>r
t|}ntd
|
<01>d|<00>dt
|
<01>
<00><00><06>
<00>
|j|
<01>
s|dk(rdn
d}td|<04>d|
<01><02><04>
<00>
y)	Nz
Header part (z) from z# must be of type str or bytes, not rr<>r<>zTInvalid leading whitespace, reserved character(s), or return character(s) in header z: )r^r!rrrr)<00>typerR)r<><00>header_part<72>header_validator_index<65>	validator<6F>header_kinds     rYr<>
r<>
Js<><00><00>
<12>+<2B>s<EFBFBD>#<23>*<2A>+A<>B<>	<09>	<13>K<EFBFBD><15>	'<27>+<2B>,B<>C<>	<09><1B><1B>K<EFBFBD>?<3F>'<27>&<26><18>
:1<>15<31>k<EFBFBD>1B<31>0C<30>

E
<01>
<EFBFBD>	
<EFBFBD>
<15>?<3F>?<3F>;<3B>'<27> 6<>!<21> ;<3B>f<EFBFBD><17><0B><1B>
&<26>&1<>]<5D>"<22>[<5B>O<EFBFBD>

E
<01>
<EFBFBD>	
<EFBFBD>(r\c

<01>~<00>t
|<00>
\}
}}}}}|s||}}|jd
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<>rg
r<>
r<>r<>r<>
<00>	_fragments       rY<00>
urldefragauthr<68>
bsU<00><00>6><3E>c<EFBFBD>]<5D>2<>F<EFBFBD>F<EFBFBD>D<EFBFBD>&<26>%<25><19><12><1B>V<EFBFBD><04><06>
<13>]<5D>]<5D>3<EFBFBD>
<01>
"<22>2<EFBFBD>
&<26>F<EFBFBD><15>v<EFBFBD>v<EFBFBD>t<EFBFBD>V<EFBFBD>U<EFBFBD>B<EFBFBD>?<3F>@<40>@r\c

<01><><00>t
|jd
d<02>}
|
<01>.t|jt<00>r	|
|j<00>

yt
d<04>
<00>
#t
$r
t
d<03>
<00>
wxYw
)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_positionrrLr+)<02>prepared_request<73>	body_seeks  rY<00>rewind_bodyr<79>
ssu<00><00><18>(<28>-<2D>-<2D>v<EFBFBD>t<EFBFBD><<3C>I<EFBFBD><10><1C><1A><18>'<27>'<27><15>"<06>	<0E><15>&<26>5<>5<>6<>$<24>$Q<>R<>R<><52><17>	<0E>'<27>M<><0E>
<0E>	<0E>s<00>A<00>A()rTr!rU
r<>)raz6_t.SupportsItems[Any, Any] | Iterable[tuple[Any, Any]]rU
zIterable[tuple[Any, Any]])rxrrU
rJ)
F)r<>z
_t.UriTyper<65>r<>rU
ztuple[str, str] | None)r<>rrU
rV
)r<>r!rU
r!)r<>r!rU
z%Generator[BufferedWriter, None, None])r<>z4Mapping[Any, Any] | Iterable[tuple[Any, Any]] | NonerU
zdict[Any, Any] | None)r<><00>NonerU
r<>
)r<>z6_t.SupportsItems[_KT, _VT] | Iterable[tuple[_KT, _VT]]rU
zlist[tuple[_KT, _VT]])r<>z=_t.SupportsItems[_KT, _VT] | Iterable[tuple[_KT, _VT]] | NonerU
zlist[tuple[_KT, _VT]] | None)r<>r!rU
<00>	list[str])r<>r!rU
<00>dict[str, str | None])r<>r!r<>r<>rU
r!)r<>r-rU
r<>
)r<>r-r<><00>dict[str, str]rU
r-)r<>r!rU
r<>
)r<>r!rU
ztuple[str, dict[str, Any]])r<><00>CaseInsensitiveDict[str]rU
rV
)r
zIterable[bytes]r
r2rU
z"Generator[str | bytes, None, None])r
rr
<00>
int | NonerU
zGenerator[bytes, None, None])r
r!r
r<>
rU
zGenerator[str, None, None])r
zbytes | strr
r<>
rU
z"Generator[bytes | str, None, None])r
r2rU
zstr | bytes | None)r"
r!rU
r!)r3
r!r4
r!rU
r<>)r?
rJrU
r!)rA
r!rU
r<>)rE
r!rU
r<>)rH
r!r<>rV
rU
zGenerator[None, None, None])r<>r!rP
rV
rU
r<>r<>)r<>r!rP
rV
rU
r<>
)r<>r!rh
<00>dict[str, str] | NonerU
rV
)
T)rq
zRequest | PreparedRequestrh
r<>
rr
r<>rU
r<>
)
zpython-requests)r<>r!rU
r!)rU
r<>
)r<>r!rU
zlist[dict[str, str]])r<>
rrU
rV
)r<>r!r<>
r!rU
r!)r<>r!rU
ztuple[str, str])r<><00>tuple[str | bytes, str | bytes]rU
r<>
)r<>r<>
r<>
zstr | bytesr<73>
rJrU
r<>
)r<>r!rU
r!)r<>
r0rU
r<>
)<29><>__doc__<5F>
__future__rr
<00>
contextlibrtrnrQr0
r.
<00>sysr<73>rrr<><00>collectionsr<00>collections.abcrr<00>typingrrr	r
rr<00>urllib3.utilr
rr<>rr<00>_internal_utilsrrrrr/rr_<00>compatrrrrrrrrr r!r"r#r$r%r<><00>cookiesr'<00>
exceptionsr(r)r*r+<00>
structuresr,<00>http.cookiejarr-r.<00>_t<5F>modelsr0r1r2r4<00>__annotations__<5F>wherer5r9r:r;r<>rNr=<00>platformrZrbr{r<>r<>r<><00>contextmanagerr<72>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r
r
r
<00>	frozensetr
r'
r,
r:
r2
rB
rF
rK
ra
rd
rm
ru
rw
r{
r<>
rlr<>
r<>
r<>
r<>
r<>
r<>
r<>
r<>
r<>
r<>
rr\rY<00><module>r<>

s<><00>


<01>
<04>
#<23>
<0A><11>	<09>	<09>	<09>
<0A>
<0A>
<EFBFBD><0F><0F><0E>#<23>/<2F>
<02>
<02>
1<><13>$<24>
<02>
<02>
4<>
<02>
<02>
<02>
<02>
:<3A>(<28>
<02>
<02>
,<2C><10>(<28>!<21><1E>:<3A>:<3A>)<29><0B>U<EFBFBD>)<29>*<2A>e<EFBFBD>k<EFBFBD>k<EFBFBD>m<EFBFBD><16><03>+<2B>!#<23>S<EFBFBD>1<>
<0A>u<EFBFBD>1<>
<0A>e<EFBFBD>n<EFBFBD><03>
<0A>e<EFBFBD>n<EFBFBD><03>"&<26><19><19><0C>B<EFBFBD>H<EFBFBD>H<EFBFBD>W<EFBFBD>l<EFBFBD>4<EFBFBD>8<>9J<39>K<>L<>"<02><17><15>
<02>
<07><<3C><<3C>7<EFBFBD><1A>$<15>L
	/<2F>

<0A>=<3D>

<0A><1E>

<0A>D

3<>P+0<>1

<0A>	<13>1

<0A>#'<27>1

<0A><1B>1

<0A>h

&<26>#
<1A>L
<0C>
<1A>
<1A>	
<0E><1B>	
<0E>
<1E>?<3F>
<1E><1A>
<1E>:
<EFBFBD>-<2D>
<EFBFBD>-<2D>
	<09>
 <20>A<>
 <20><1A>
 <20>
<EFBFBD>
 <20>
<17>H<>
<17>!<21>
<17>@

<12>@

<12>F

<11>2
<17>
0<>
<06>2
%<25>,
<17>2
<11><1D>
<11>"*<2A>
<11>'<27>
<11>&
<EFBFBD>
'<27><11>
'<27>!+<2B>
'<27>!<21>
'<27>
<EFBFBD>
'<27>
<EFBFBD>
%<25><0F>
%<25>)<29>
%<25><1F>
%<25>
<EFBFBD>
%<25>	
<1C><17>	
<1C>'1<>	
<1C>'<27>	
<1C>&
<19>T
"<22>M<><02><0E><05>
<02>

<1A>0
5<>,
5<>
5<>
<10>
<10>0<0C>
<1A>
<1A>
1<><1B>
1<>,<
<11>~
	
<1C>
<11>:<1B>
<17>
&<26>
<17>
"<22>
<17><14>
<17><14>	
<17>>
#<23>
<06>"
<11>L
	<0F>
<0A>
<0A>g<EFBFBD><1E><05>	<0E><11><19><06>	<0E><11><19><06>
<10>@

C
<01><
<10>"
,<2C>

<EFBFBD>+<2B>

<EFBFBD><1C>

<EFBFBD> <20>

<EFBFBD>
<EFBFBD>	

<EFBFBD>0
A
<01>"
S
r\