�
o�Dac	@s�dZd
dl
Z
d
dlZd
dlZd
dlmZ
ddlmZ
ddlmZ
ddlm	Z	
ddlm
Z

dd	lmZ
dd
lmZ
ddlm
Z

ddlmZ
dd
lmZ
ddlmZ
ddlmZ
ejd�
Zeed�
�
ZdZed�eD�
�
Zged�
D]Zdejd�
^q4
Zeeddddddg��
Zdef
d��YZ ede f
d ��Y�
Z!d!e f
d"��YZ"i
ee�6Z#d#d$�
Z$d%�Z%d#d&�
Z&de(d'�Z)d(d)d*d#d+�Z*e*�Z+e*d,d-d.d/�Z,d0�Z-d(d)d*d#d1�Z.d(d)d#d2�Z/d3�Z0d(d4d#d5�Z1d(d4d6�Z2d(d7�
Z3d#j4ged8�
D]Z5e5ekr�e6e5�
^q��
Z7d9�Z8e
j9d:e8�
d(d:d;�Z:d<Z;d(d)e<d=�Z=d(e<e(d4d>dd?�Z>d(e<e(d4d>dde<d@�Z?dA�Z@d(e<e<dd>dB�ZAdd(e<e<dd>dC�ZBe(dD�
ZCdEeDf
dF��YZEdS(Gs�
    werkzeug.urls
    ~~~~~~~~~~~~~

    ``werkzeug.urls`` used to provide several wrapper functions for Python 2
    urlparse, whose main purpose were to work around the behavior of the Py2
    stdlib and its lack of unicode support. While this was already a somewhat
    inconvenient situation, it got even more complicated because Python 3's
    ``urllib.parse`` actually does handle unicode properly. In other words,
    this module would wrap two libraries with completely different behavior. So
    now this module contains a 2-and-3-compatible backport of Python 3's
    ``urllib.parse``, which is mostly API-compatible.

    :copyright: 2007 Pallets
    :license: BSD-3-Clause
i����N(
t
namedtuplei
(
tfix_tuple_repr(
timplements_to_string(
tmake_literal_wrapper(
tnormalize_string_tuple(
tPY2(
t	text_type(
t	to_native(
t
to_unicode(
ttry_coerce_native(
t_decode_idna(
t_encode_idnas^[a-zA-Z0-9+-.]+$sBabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~t0123456789ABCDEFabcdefc
cs?|]5}
tD](}|
|j
�t|
|d�fV
q
qd
S(iN(t
_hexdigitstencodetint(t.0t
at
b((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pys	<genexpr>2si
s%%%02Xtasciit	_URLTupletschemetnetloctpathtquerytfragmenttBaseURLcBs�eZ
dZdZd
�Zed��
Zed��
Zed��
Zed��
Z	ed��
Z
ed��
Zed��
Zed	��
Z
d
�Zd�Zd�Zd
�Zd�Zd�Zdd�
Zd�Zd�Zd�ZRS(s7Superclass of :py:class:`URL` and :py:class:`BytesURL`.c
Ks
|j|
�S(
s�Return an URL with the same values, except for those parameters
        given new values by whichever keyword arguments are specified.(
t_replace(tselftkwargs((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pytreplaceAsc

Cs|j�d
S(s�The host part of the URL if available, otherwise `None`.  The
        host is either the hostname or the IP address mentioned in the
        URL.  It will not contain the port.
        i(
t_split_host(
R((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pythostFsc
Csm|j}
|
dk	r]t|
t�r]yt|
�
}
Wq]tk
rY


|
jd
d�}
q]Xnt|
d
d�S(s 
Works exactly like :attr:`host` but will return a result that
        is restricted to ASCII.  If it finds a netloc that is not ASCII
        it will attempt to idna decode it.  This is useful for socket
        operations when the URL might include internationalized characters.
        RtignoreN(R tNonet
isinstanceRRtUnicodeErrorRR(Rtrv((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyt
ascii_hostNs	






c
Cs^y@tt
|j�d
�
�
}
d|
k
o6dk
n
r?|
SWnttfk
rY


n
XdS(s}The port in the URL as an integer if it was present, `None`
        otherwise.  This does not fill in default ports.
        i
ii��N(RRRt
ValueErrort	TypeError(RR%((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pytport]s




c

Cs|j�d
S(sSThe authentication part in the URL if available, `None`
        otherwise.
        i(
t
_split_netloc(
R((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pytauthisc
Cs*|j�d
}
|
dk	r&t|
�
SdS(s�The username if it was part of the URL, `None` otherwise.
        This undergoes URL decoding and will always be a unicode string.
        iN(t_split_authR"t_url_unquote_legacy(RR%((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pytusernameps

c

Cs|j�d
S(s�The username if it was part of the URL, `None` otherwise.
        Unlike :attr:`username` this one is not being decoded.
        i(
R,(
R((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pytraw_usernameysc
Cs*|j�d
}
|
dk	r&t|
�
SdS(s�The password if it was part of the URL, `None` otherwise.
        This undergoes URL decoding and will always be a unicode string.
        i
N(R,R"R-(RR%((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pytpassword�s

c

Cs|j�d
S(s�The password if it was part of the URL, `None` otherwise.
        Unlike :attr:`password` this one is not being decoded.
        i
(
R,(
R((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pytraw_password�sc
Ost|j
|
|�
S(
s�Decodes the query part of the URL.  Ths is a shortcut for
        calling :func:`url_decode` on the query argument.  The arguments and
        keyword arguments are forwarded to :func:`url_decode` unchanged.
        (t
url_decodeR(RtargsR((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pytdecode_query�sc
Ostt
||
|�
�
S(
s�Joins this URL with another one.  This is just a convenience
        function for calling into :meth:`url_join` and then parsing the
        return value again.
        (t	url_parseturl_join(RR3R((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pytjoin�sc

Cs
t|�
S(
s�Returns a URL string or bytes depending on the type of the
        information stored.  This is just a convenience function
        for calling :meth:`url_unparse` for this URL.
        (
turl_unparse(
R((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pytto_url�sc
Cs�t|j
pd
�
}
d|
kr.d|
}
n|j}|dk	rVd|
|f}
ndjtdt|jpqd
d�t|jp�d
d�g��
}|r�d||
f}
n|
S(s&Decodes the netloc part into a string.tt
:s[%s]s%s:%ds/:%@s%s@%sN(	R
R R)R"R7tfilterR-R/R1(RR%R)R+((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyt
decode_netloc�s


	





!

c

Cstt
|�
jd
�
�
S(s*
Returns a :class:`BytesURL` tuple that holds a URI.  This will
        encode all the information in the URL properly to ASCII using the
        rules a web browser would follow.

        It's usually more interesting to directly call :meth:`iri_to_uri` which
        will return a string.
        R(R5t
iri_to_uriR(
R((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pytto_uri_tuple�sc

Cstt
|�
�
S(
sS
Returns a :class:`URL` tuple that holds a IRI.  This will try
        to decode as much information as possible in the URL without
        losing information similar to how a web browser does it for the
        URL bar.

        It's usually more interesting to directly call :meth:`uri_to_iri` which
        will return a string.
        (R5t
uri_to_iri(
R((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pytto_iri_tuple�s	cCs�
|jd
krdSt|j�
}|jp.d
}|
d
kr^tjdkrUd}
q^d}
n|
dkrQ
|d dkr�|dd!j�r�|dd!d	kr�|dd!d
|d}n|d ddfk}dd
l}|j	|�
}|r�
|d
kr�
|j
d�
jdd�}t|�
dkr;
|\}}qN
|d}d}q�
n@|
dkr{
dd
l
}|j	|�
}ntdt|
�
�
�
|dkr�
d
}n||fS(s@Returns a tuple with the location of the file in the form
        ``(server, location)``.  If the netloc is empty in the URL or
        points to localhost, it's represented as ``None``.

        The `pathformat` by default is autodetection but needs to be set
        when working with URLs of a specific system.  The supported values
        are ``'windows'`` when working with Windows or DOS paths and
        ``'posix'`` when working with posix paths.

        If the URL does not point to a local file, the server and location
        are both represented as ``None``.

        :param pathformat: The expected format of the path component.
                           Currently ``'windows'`` and ``'posix'`` are
                           supported.  Defaults to ``None`` which is
                           autodetect.
        tfiletnttwindowstposixi
t
/iis|:R;s
\i����NiR:sInvalid path format %ss	127.0.0.1s::1t	localhost(NNs\\\s///(s	127.0.0.1s::1RG(RR"turl_unquoteRRtostnametisalphatntpathtnormpathtlstriptsplittlent	posixpathR(trepr(Rt
pathformatRR t
windows_shareRLtpartsRQ((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pytget_file_location�s6



		
6










	c

Cs5|j|j
kr(|j
j|jd
�Sd|j
fS(Ni
(t_atRROR"(
R((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyR*
s


c
CsF|j�d
}
|
sdS|j|
kr3|
dfS|
j|jd�S(Nii
(NN(R*R"t_colonRO(RR+((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyR,
s






c
Cs�|j�d
}
|
sdS|
j|j�
sX|j|
krN|
j|jd
�S|
dfS|
j|j�
}|dkr�|
dfS|
d
|!}|
|d
}|j|j�
r�||d
fS|dfS(Ni
i(NN(R*R"t
startswitht	_lbracketRXROtfindt	_rbracket(RR%tidxR trest((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyR
s














(N(t__name__t
__module__t__doc__t	__slots__RtpropertyR R&R)R+R.R/R0R1R4R7R9R=R?RAR"RVR*R,R(((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyR<s*
								
	<		tURLcBsMeZ
dZd
Zd
ZdZdZdZd�Zd�Z	ddd	�Z
RS(s�Represents a parsed URL.  This behaves like a regular tuple but
    also has some extra attributes that give further insight into the
    URL.
    t
@R;t
[t
]c


Cs
|j�S(
N(
R9(
R((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyt__str__;
s
c
	Cs�|jpd
}
d|
kr(d|
}
n|j
}|d	k	rPd|
|f}
ndjtd	t|jpkd
ddd�t|jp�d
ddd�g��
}|r�d||
f}
nt|
�
S(
s6Encodes the netloc part to an ASCII safe URL as bytes.R:R;s[%s]s%s:%dsutf-8tstricts/:%s%s@%sN(	R&R)R"R7R<t	url_quoteR/R1R(RR%R)R+((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyt
encode_netloc>
s



	





'

sutf-8RcCsUt|j
jd
�
|j�|jj|
|�|jj|
|�|jj|
|��S(s�Encodes the URL to a tuple made out of bytes.  The charset is
        only being used for the path, query and fragment.
        R(tBytesURLRRRkRRR(Rtcharsetterrors((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyRS
s

	


((R_R`RaRbRWRXRZR\RhRkR(((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyRd.
s



		RlcBsMeZ
dZd
Zd
ZdZdZdZd�Zd�Z	ddd	�Z
RS(s!Represents a parsed URL in bytes.ReR;RfRgc

Cs|j�j
d
d�S(Nsutf-8R(R9tdecode(
R((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyRhi
s
c


Cs|jS(
s&Returns the netloc unchanged as bytes.(
R(
R((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyRkl
ssutf-8RcCsUt|j
jd
�
|j�|jj|
|�|jj|
|�|jj|
|��S(s�Decodes the URL to a tuple made out of strings.  The charset is
        only being used for the path, query and fragment.
        R(RdRRoR=RRR(RRmRn((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyRop
s

	


((R_R`RaRbRWRXRZR\RhRkRo(((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyRl`
s




		R:cs4
t|t
�r!|jd
�
}nt�t
�rB�jd
�
�ntt��
�
�t|jd�
�
}tt|d��
}yt�}Wn5t	k
r�


�f
d�t
j�D�
}t�<n
Xxc|D][}|d }||kr
|j||�

|j
|d�

q�|jd�

|j
|�

q�Wt|�
S(Nsutf-8t
%R:c
s+i|]!\}
}|�kr||
�qS(((Rt
hR(
tunsafe(s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pys
<dictcomp>�
s	ii%(R#RRt	frozensett	bytearraytiterROtnextt
_unquote_mapstKeyErrort
_hextobytetitemstappendtextendtbytes(tstringRrtgroupstresultthex_to_bytetgrouptcode((
Rrs//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyt_unquote_to_bytes�
s&







(






ccs�d
dlm
}
||�
}|r7t|d|�

}nx�|D]�\}}|dkr\q>nt|t�s�t|�
j|
�
}nt|t�s�t|�
j|
�
}nt|�
dt|�
V
q>WdS(Ni
(
titer_multi_itemstkeyt
=(	tdatastructuresR�tsortedR"R#R}RRt_fast_url_quote_plus(tobjRmtencode_keystsortR�R�titerabletvalue((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyt_url_encode_impl�
s










cCsKy t|d
dddd|
�
SWn$t
k
rF


t|d
dd|
�
SXdS(NRmsutf-8RnRiRrtlatin1(RHR$(R�Rr((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyR-�
s

 


c
sGt|�
�t
|t�}|
dkr6�d
�
}
n�d
�
}}}|j�d�
�
}|dkr�tjt|| dd�

�
r�||d}|s�t�f
d�|D�
�
r�|| j	�|}
}q�n|d �d	�
kr�
t
|�
}	xD�d
�
D]6}
|j|
d�}|dkr
t|	|�}	q
q
W|d|	!||	}}�d�
|kr}
�d�
|ks�
�d�
|kr�
�d�
|kr�
td
�
�
q�
n|r�
�d�
|kr�
|j
�d�
d�\}}n�d�
|kr|j
�d�
d�\}}n|r+tnt}||
||||�S(sParses a URL from a string into a :class:`URL` tuple.  If the URL
    is lacking a scheme it can be provided as second argument. Otherwise,
    it is ignored.  Optionally fragments can be stripped from the URL
    by setting `allow_fragments` to `False`.

    The inverse of this function is :func:`url_unparse`.

    :param url: the URL to parse.
    :param scheme: the default schema to use if the URL is schemaless.
    :param allow_fragments: if set to `False` a fragment will be removed
                            from the URL.
    R:R;iRnRi
c
3s!|]}
|
�d�
kV
qd
S(t
0123456789N((Rt
c(
t
s(s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pys	<genexpr>�
sis//s/?#RfRgsInvalid IPv6 URLt
#t
?N(RR#RR"R[t
_scheme_retmatchRtanytlowerRPtminR'RORdRl(
turlRtallow_fragmentst
is_text_basedRRRt
iR^tdelimR�twdelimtresult_type((
R�s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyR5�
s4





+
#






$
$
!

!
sutf-8Ris/:cs�t|t
�r$|j||
�}nt|t
�rH|j||
�}ntt|�
�
tBtt|�
�
}gtd
�
D](}||kr�t|�
nd|^q{�ts��f
d�}n�f
d�}|S(s�
Precompile the translation table for a URL encoding function.

    Unlike :func:`url_quote`, the generated function only takes the
    string to quote.

    :param charset: The charset to encode the result with.
    :param errors: How to handle encoding errors.
    :param safe: An optional sequence of safe characters to never encode.
    :param unsafe: An optional sequence of unsafe characters to always encode.
    i
s%%%02Xc
s$d
jg|D]}
�|
^q
�
S(NR:(
R7(R~R�(
ttable(s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pytquote�
s
c
s*d
jgt
|�
D]}
�|
^q�
S(NR:(R7Rt(R~R�(
R�(s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyR�s
(	R#RRRsRtt_always_safetrangetchrR(RmRntsafeRrR�R�((
R�s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyt_make_fast_url_quote�
s

&
;R�t
 Rrt
+c

Cst|�
j
d
d�S(NR�R�(t_fast_quote_plusR(
R~((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyR�s
cCs
t|t
ttf�s't
|�
}nt|t
�rK|j|
|�}nt|t
�ro|j|
|�}nt|t
�r�|j|
|�}ntt|�
�
tBtt|�
�
}t�}xAt|�
D]3}||kr�|j|�

q�|jt	|�

q�Wt
t|�
�
S(
sD
URL encode a single string with a given encoding.

    :param s: the string to quote.
    :param charset: the charset to be used.
    :param safe: an optional sequence of safe characters.
    :param unsafe: an optional sequence of unsafe characters.

    .. versionadded:: 0.9.2
       The `unsafe` parameter was added.
    (R#RR}RtRRsR�R{R|t
_bytetohexR(R~RmRnR�RrR%tchar((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyRjs







&
	



cCs&t||
||d
d�j
d
d�S(s�URL encode a single string with the given encoding and convert
    whitespace to "+".

    :param s: The string to quote.
    :param charset: The charset to be used.
    :param safe: An optional sequence of safe characters.
    R�R�(RjR(R~RmRnR�((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyturl_quote_plus-sc
Cs
t|�
\}
}}}}t
|
�
}|d
�
}|sT|
r�|j|d�
�
r�|r�|d |d�
kr�|d�
|}n|d�
|p�|d
�
|}n|r�||7}n|
r�|
|d�
|}n|r�||d�
|}n|r
||d�
|}n|S(s�The reverse operation to :meth:`url_parse`.  This accepts arbitrary
    as well as :class:`URL` tuples and returns a URL as a string.

    :param components: the parsed URL as tuple which should be converted
                       into a URL string.
    R:RFi
s//R;R�R�(RRRY(t
componentsRRRRRR�R�((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyR88s 

!


#









RcCs4t||�}|
d
k	r0|j|
|�}n|S(s�
URL decode a single string with a given encoding.  If the charset
    is set to `None` no unicode decoding is performed and raw bytes
    are returned.

    :param s: the string to unquote.
    :param charset: the charset of the query string.  If set to `None`
                    no unicode decoding will take place.
    :param errors: the error handling for the charset decoding.
    N(R�R"Ro(R~RmRnRrR%((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyRHVs



cCsFt|t
�r$|jd
d�}n|jdd�}t||
|�S(sURL decode a single string with the given `charset` and decode "+" to
    whitespace.

    Per default encoding errors are ignored.  If you want a different behavior
    you can set `errors` to ``'replace'`` or ``'strict'``.  In strict mode a
    :exc:`HTTPUnicodeError` is raised.

    :param s: The string to unquote.
    :param charset: the charset of the query string.  If set to `None`
                    no unicode decoding will take place.
    :param errors: The error handling for the `charset` decoding.
    u
+u
 R�R�(R#RRRH(R�RmRn((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyturl_unquote_plusfs


cCs�t||
d
�j
dd�}|jd�
rd|dd!j�rd|dd!dkrdd
|d}nt|�
}t|j|
dd�
}t|j|
dd
�
}t|j	|
dd
�
}t
t|j|j
�|||f�
�
S(sSometimes you get an URL by a user that just isn't a real URL because
    it contains unsafe characters like ' ' and so on. This function can fix
    some of the problems in a similar way browsers handle data entered by the
    user:

    >>> url_fix(u'http://de.wikipedia.org/wiki/Elf (Begriffskl\xe4rung)')
    'http://de.wikipedia.org/wiki/Elf%20(Begriffskl%C3%A4rung)'

    :param s: the string with the URL to fix.
    :param charset: The target charset for the URL if the url was given as
                    unicode string.
    Rs
\RFsfile://iii
s:/s|/sfile:///R�s
/%+$!*'(),s:&%=+$!*'(),(s:/s|/(RRRYRKR5RjRR�RRRR8RRk(R�RmR�Rtqstanchor((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyturl_fixzs5




i�c
CsAt|j
|j|j!�
}
tr4|
jd
�
}
n|
|jfS(sRUsed in :func:`uri_to_iri` after unquoting to re-quote any
    invalid bytes.
    sutf-8(t_fast_url_quotetobjecttstarttendRRo(t
etout((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyt_codec_error_url_quote�s
swerkzeug.url_quotecCs�t|t
�rt|�
}ntt||
��
}t|j|
|t�}t|j|
|t�}t|j	|
|t�}t|j
|j�|||f�
S(
s�Convert a URI to an IRI. All valid UTF-8 characters are unquoted,
    leaving all reserved and invalid characters quoted. If the URL has
    a domain, it is decoded from Punycode.

    >>> uri_to_iri("http://xn--n3h.net/p%C3%A5th?q=%C3%A8ry%DF")
    'http://\u2603.net/p\xe5th?q=\xe8ry%DF'

    :param uri: The URI to convert.
    :param charset: The encoding to encode unquoted bytes with.
    :param errors: Error handler to use during ``bytes.encode``. By
        default, invalid bytes are left quoted.

    .. versionchanged:: 0.15
        All reserved and invalid characters remain quoted. Previously,
        only some reserved characters were preserved, and invalid bytes
        were replaced instead of left quoted.

    .. versionadded:: 0.6
    (R#ttupleR8R5RRHRt_to_iri_unsafeRRRR=(turiRmRnRRR((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyR@�s




s:/?#[]@!$&'()*+,;=%c	Cs�t|t
�rt|�
}n|rvy;t|�
}|jd
�
}t|j��
dkr^|SWqvtk
rr


qvXntt	||
|��
}t
|j|
|t�}t
|j
|
|t�}t
|j|
|t�}tt|j|j�|||f�
�
S(sConvert an IRI to a URI. All non-ASCII and unsafe characters are
    quoted. If the URL has a domain, it is encoded to Punycode.

    >>> iri_to_uri('http://\u2603.net/p\xe5th?q=\xe8ry%DF')
    'http://xn--n3h.net/p%C3%A5th?q=%C3%A8ry%DF'

    :param iri: The IRI to convert.
    :param charset: The encoding of the IRI.
    :param errors: Error handler to use during ``bytes.encode``.
    :param safe_conversion: Return the URL unchanged if it only contains
        ASCII characters and no whitespace. See the explanation below.

    There is a general problem with IRI conversion with some protocols
    that are in violation of the URI specification. Consider the
    following two IRIs::

        magnet:?xt=uri:whatever
        itms-services://?action=download-manifest

    After parsing, we don't know if the scheme requires the ``//``,
    which is dropped if empty, but conveys different meanings in the
    final URL if it's present or not. In this case, you can use
    ``safe_conversion``, which will return the URL unchanged if it only
    contains ASCII characters and no whitespace. This can result in a
    URI with unquoted characters if it was not already quoted correctly,
    but preserves the URL's semantics. Werkzeug uses this for the
    ``Location`` header for redirects.

    .. versionchanged:: 0.15
        All reserved characters remain unquoted. Previously, only some
        reserved characters were left unquoted.

    .. versionchanged:: 0.9.6
       The ``safe_conversion`` parameter was added.

    .. versionadded:: 0.6
    Ri
(R#R�R8RRRPROR$R5RRjRt_to_uri_safeRRRRk(	tiriRmRntsafe_conversiont
native_irit	ascii_iriRRR((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyR>�s &











t
&cCs�|dkr%d
dl
m}
|}nt|t�r\t|t�r\|j|
pSd�
}n7t|t�r�t|t�r�|j|
p�d�
}n|t|j	|�
|
|||��
S(s�
    Parse a querystring and return it as :class:`MultiDict`.  There is a
    difference in key decoding on different Python versions.  On Python 3
    keys will always be fully decoded whereas on Python 2, keys will
    remain bytestrings if they fit into ASCII.  On 2.x keys can be forced
    to be unicode by setting `decode_keys` to `True`.

    If the charset is set to `None` no unicode decoding will happen and
    raw bytes will be returned.

    Per default a missing value for a key will default to an empty key.  If
    you don't want that behavior you can set `include_empty` to `False`.

    Per default encoding errors are ignored.  If you want a different behavior
    you can set `errors` to ``'replace'`` or ``'strict'``.  In strict mode a
    `HTTPUnicodeError` is raised.

    .. versionchanged:: 0.5
       In previous versions ";" and "&" could be used for url decoding.
       This changed in 0.5 where only "&" is supported.  If you want to
       use ";" instead a different `separator` can be provided.

       The `cls` parameter was added.

    :param s: a string with the query string to decode.
    :param charset: the charset of the query string.  If set to `None`
                    no unicode decoding will take place.
    :param decode_keys: Used on Python 2.x to control whether keys should
                        be forced to be unicode objects.  If set to `True`
                        then keys will be unicode in all cases. Otherwise,
                        they remain `str` if they fit into ASCII.
    :param include_empty: Set to `False` if you don't want empty values to
                          appear in the dict.
    :param errors: the decoding error behavior.
    :param separator: the pair separator to be used, defaults to ``&``
    :param cls: an optional dict class to use.  If this is not specified
                       or `None` the default :class:`MultiDict` is used.
    i
(
t	MultiDictRN(
R"R�R�R#RRoR}Rt_url_decode_implRO(R�Rmtdecode_keyst
include_emptyRnt	separatortclsR�((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyR2s/
	






c	
Cssd
dlm
}	
|	|||�}
t|
|
|||�}|rD|S|dkrid
dlm}
|}n||�
S(s�Works like :func:`url_decode` but decodes a stream.  The behavior
    of stream and limit follows functions like
    :func:`~werkzeug.wsgi.make_line_iter`.  The generator of pairs is
    directly fed to the `cls` so you can consume the data while it's
    parsed.

    .. versionadded:: 0.8

    :param stream: a stream with the encoded querystring
    :param charset: the charset of the query string.  If set to `None`
                    no unicode decoding will take place.
    :param decode_keys: Used on Python 2.x to control whether keys should
                        be forced to be unicode objects.  If set to `True`,
                        keys will be unicode in all cases. Otherwise, they
                        remain `str` if they fit into ASCII.
    :param include_empty: Set to `False` if you don't want empty values to
                          appear in the dict.
    :param errors: the decoding error behavior.
    :param separator: the pair separator to be used, defaults to ``&``
    :param cls: an optional dict class to use.  If this is not specified
                       or `None` the default :class:`MultiDict` is used.
    :param limit: the content length of the URL data.  Not necessary if
                  a limited stream is provided.
    :param return_iterator: if set to `True` the `cls` argument is ignored
                            and an iterator over all decoded pairs is
                            returned
    i
(
tmake_chunk_iter(
R�N(twsgiR�R�R"R�R�(
tstreamRmR�R�RnR�R�tlimittreturn_iteratorR�t	pair_itertdecoderR�((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyturl_decode_streamJs&


	c
cs�x�|D]�}|sqnt|�
}|d
�
}||krX|j
|d�\}}	n|sdqn|}|d�
}	t||
|�}|
dk	r�tr�|r�t|�
}n|t|	|
|�fV
qWdS(NR�i
R:(RROR�R"RR	(
R�RmR�R�RntpairR�tequalR�R�((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyR��s














cCs.t|d
�}|j
t||
|||��
S(s�URL encode a dict/`MultiDict`.  If a value is `None` it will not appear
    in the result string.  Per default only values are encoded into the target
    charset strings.  If `encode_keys` is set to ``True`` unicode keys are
    supported too.

    If `sort` is set to `True` the items are sorted by `key` or the default
    sorting algorithm.

    .. versionadded:: 0.5
        `sort`, `key`, and `separator` were added.

    :param obj: the object to encode into a query string.
    :param charset: the charset of the query string.
    :param encode_keys: set to `True` if you have unicode keys. (Ignored on
                        Python 3.x)
    :param sort: set to `True` if you want parameters to be sorted by `key`.
    :param separator: the separator to be used for the pairs.
    :param key: an optional function to be used for sorting.  For more details
                check out the :func:`sorted` documentation.
    R(RR7R�(R�RmR�R�R�R�((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyt
url_encode�s
c
Cs{t|d
�}t
|||||�}|
dkr7|Sx=t|�
D]/\}}	|rf|
j|�

n|
j|	�

qDWdS(s�Like :meth:`url_encode` but writes the results to a stream
    object.  If the stream is `None` a generator over all encoded
    pairs is returned.

    .. versionadded:: 0.8

    :param obj: the object to encode into a query string.
    :param stream: a stream to write the encoded object into or `None` if
                   an iterator over the encoded pairs should be returned.  In
                   that case the separator argument is ignored.
    :param charset: the charset of the query string.
    :param encode_keys: set to `True` if you have unicode keys. (Ignored on
                        Python 3.x)
    :param sort: set to `True` if you want parameters to be sorted by `key`.
    :param separator: the separator to be used for the pairs.
    :param key: an optional function to be used for sorting.  For more details
                check out the :func:`sorted` documentation.
    RN(RR�R"t	enumeratetwrite(
R�R�RmR�R�R�R�tgenR]tchunk((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyturl_encode_stream�s






cCs�t|t
�rt|�
}nt|
t
�r<t|
�
}
nt||
f�
\}}
t|�
}|sj|
S|
st|St|d
|�

\}}}}}t|
||�\}	}
}}}
|	|kr�|
S|
r�t|	|
|||
f�
S|}
|d |d�
kr
|j|d�
�
}nY|sF
|j|d�
�
}|sr
|}qr
n,|j|d�
�
d |j|d�
�
}|d|d�
kr�
|d�
|d<ng|D]}||d�
kr�
|^q�
}x�d}t|�
d}xm||krM|||d�
kr@||d|d�
|d�
fkr@||d|d5Pn|d7}q�
WPq�
W|d�
|d�
g}x|d |kr�|d=qnW|d�
j|�
}t|	|
|||
f�
S(	s	
Join a base URL and a possibly relative URL to form an absolute
    interpretation of the latter.

    :param base: the base URL for the join operation.
    :param url: the URL to join.
    :param allow_fragments: indicates whether fragments should be allowed.
    R�i
RFi����t
.R:s..i(	R#R�R8RRR5RORPR7(tbaseR�R�R�tbschemetbnetloctbpathtbqueryt	bfragmentRRRRRtsegmentstsegmentR�t
ntunwanted_marker((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyR6�sT







!









,
+




<





tHrefcBs5eZ
dZd
dedd�Zd�Zd�ZRS(s�Implements a callable that constructs URLs with the given base. The
    function can be called with any number of positional and keyword
    arguments which than are used to assemble the URL.  Works with URLs
    and posix paths.

    Positional arguments are appended as individual segments to
    the path of the URL:

    >>> href = Href('/foo')
    >>> href('bar', 23)
    '/foo/bar/23'
    >>> href('foo', bar=23)
    '/foo/foo?bar=23'

    If any of the arguments (positional or keyword) evaluates to `None` it
    will be skipped.  If no keyword arguments are given the last argument
    can be a :class:`dict` or :class:`MultiDict` (or any other dict subclass),
    otherwise the keyword arguments are used for the query parameters, cutting
    off the first trailing underscore of the parameter name:

    >>> href(is_=42)
    '/foo?is=42'
    >>> href({'foo': 'bar'})
    '/foo?foo=bar'

    Combining of both methods is not allowed:

    >>> href({'foo': 'bar'}, bar=42)
    Traceback (most recent call last):
      ...
    TypeError: keyword arguments and query-dicts can't be combined

    Accessing attributes on the href object creates a new href object with
    the attribute name as prefix:

    >>> bar_href = href.bar
    >>> bar_href("blub")
    '/foo/bar/blub'

    If `sort` is set to `True` the items are sorted by `key` or the default
    sorting algorithm:

    >>> href = Href("/", sort=True)
    >>> href(a=1, b=2, c=3)
    '/?a=1&b=2&c=3'

    .. versionadded:: 0.5
        `sort` and `key` were added.
    s./sutf-8cCs7|
sd
}
n|
|_||_
||_||_dS(Ns./(R�RmR�R�(RR�RmR�R�((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyt__init__Is

	
	
	
	
cCsj|
d
 dkrt|
�
�
n|j
}|ddkrE|d7}ntt||
�|j|j|j�S(Nit__i����RF(tAttributeErrorR�R�R6RmR�R�(RRJR�((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyt__getattr__Qs


	



c

Osn
|
rFt|
d
t
�rF|r.td�
�
n|
d
|
d
 }}
nS|r�t
g|j�D]1\}}|jd�
r�|d
 p�||f^q\�
}ndjg|
D]-}|dk	r�tt||j	�d�^q��
j
d�
}
|j}|
r&
|jd�
s
|d7}nt|d|
�}n|rd
|dtt
||j	d|jd	|j�d�7}nt|�
S(
Ni����s3keyword arguments and query-dicts can't be combinedt
_RFRs./R�R�R�(R#tdictR(RztendswithR7R"RRjRmRNR�R6R�R�R�R(RRRt
kt
vt
xR%((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyt__call__Ys*






J


0	
	






	
/N(R_R`RatFalseR"R�R�R�(((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyR�s1	(FRatcodecsRItretcollectionsRt_compatR
RRRRRRRR	t	_internalR
RtcompileR�RsRtR�R
R�RyR�R�RR�RRRdRlRwR�R�R-R"tTrueR5R�R�R�R�RjR�R8RHR�R�R7R�R�R�R�tregister_errorR@R�R�R>R2R�R�R�R�R6R�R�(((s//tmp/pip-build-W6Gm0N/Werkzeug/werkzeug/urls.pyt<module>s�

















,
!�
1	1!	
		:	A




9






-	




C