�
��c@s dZd
dddddgZ
ddd	d
ddd
ddddddddgZddd	d
dddd
ddddddddddddgZd	dddddddddg
ZddddddddddddddgZddddddd	dddddgZdddd	dd
ddddd
ddg
Zd Zd!Z	ha
d"�Zd#ef
d$��YZ
d%e
f
d&��YZd'e
f
d(��YZded)�Zd*�Zd+d,�Zded-�Zd.�Zd/�Zed0�Zd1�Zd2Zd3�Zed4jo
e�
n

d5S(6sParse (absolute and relative) URLs.

See RFC 1808: "Relative Uniform Resource Locators", by R. Fielding,
UC Irvine, June 1995.
turlparset
urlunparseturljoint	urldefragturlsplitt
urlunsplittftpthttptgophertnntptimaptwaistfilethttpstshttptmmstprosperotrtsptrtsputtsftpttelnettsnewstrsynctsvnssvn+sshthdltmailtotnewstsiptsipssAabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+-.ic
Cs
had
S(sClear the parse cache.N(
t_parse_cache(((s/sys/lib/python/urlparse.pytclear_cache&st
BaseResultcBs�eZ
dZd
Zed
��Zed��Zed��Zed��Zed��Z	ed��Z
ed��Zed��Zed	��Z
RS(s
Base class for the parsed result objects.

    This provides the attributes shared by the two derived result
    objects as read-only properties.  The derived classes are
    responsible for checking the right number of arguments were
    supplied to the constructor.

    c

Cs|d
S(Ni((
tself((s/sys/lib/python/urlparse.pytscheme:sc

Cs|d
S(Ni
((
R!((s/sys/lib/python/urlparse.pytnetloc>sc

Cs|d
S(Ni((
R!((s/sys/lib/python/urlparse.pytpathBsc

Cs|d
S(Ni�((
R!((s/sys/lib/python/urlparse.pytqueryFsc

Cs|d
S(Ni�((
R!((s/sys/lib/python/urlparse.pytfragmentJsc
Cs_|i}
d
|
joE
|
i
d
d�d}d|jo
|i
dd�d}n

|Sn

dS(Nt
@i
it
:(R#tsplittNone(R!R#tuserinfo((s/sys/lib/python/urlparse.pytusernameQs	







c
CsY|i}
d
|
jo?
|
i
d
d�d}d|jo
|i
dd�dSqU
n

dS(NR'i
iR((R#R)R*(R!R#R+((s/sys/lib/python/urlparse.pytpassword[s	






c
Csh|i}
d
|
jo
|
i
d
d�d}
n

d|
jo
|
i
dd�d}
n

|
i�p
dS(NR'i
R(i(R#R)tlowerR*(R!R#((s/sys/lib/python/urlparse.pythostnameds	






c
Csh|i}
d
|
jo
|
i
d
d�d}
n

d|
jo'
|
i
dd�d}t|d�Sn

dS(NR'i
R(i
(R#R)tintR*(R!R#tport((s/sys/lib/python/urlparse.pyR1ms	







((t__name__t
__module__t__doc__t	__slots__tpropertyR"R#R$R%R&R,R-R/R1(((s/sys/lib/python/urlparse.pyR ,s
		tSplitResultc
Bs eZ
dZd�Zd
�ZRS(cCsti
||
||||f�S(
N(R t__new__(tclsR"R#R$R%R&((s/sys/lib/python/urlparse.pyR8|s

c

Cs
t|�S(
N(
R(
R!((s/sys/lib/python/urlparse.pytgeturl�s
((R2R3R5R8R:(((s/sys/lib/python/urlparse.pyR7xs	tParseResultcBs/eZ
dZd�Zed
��Zd�ZRS(cCs"ti
||
|||||f�S(
N(R R8(R9R"R#R$tparamsR%R&((s/sys/lib/python/urlparse.pyR8�s

c

Cs|d
S(Ni((
R!((s/sys/lib/python/urlparse.pyR<�sc

Cs
t|�S(
N(
R
(
R!((s/sys/lib/python/urlparse.pyR:�s
((R2R3R5R8R6R<R:(((s/sys/lib/python/urlparse.pyR;�s	cCsvt||
|�}|\}
}}}}|
t
jo#
d
|jo
t|�\}}n
d}t|
|||||�S(s#
Parse a URL into 6 components:
    <scheme>://<netloc>/<path>;<params>?<query>#<fragment>
    Return a 6-tuple: (scheme, netloc, path, params, query, fragment).
    Note that we don't break the components up in smaller bits
    (e.g. netloc is a single string) and we don't expand % escapes.t
;R(Rtuses_paramst_splitparamsR;(turlR"tallow_fragmentsttupleR#R%R&R<((s/sys/lib/python/urlparse.pyR�s



c
Csld
|jo:
|id|i
d
��}
|
djo
|dfSqV
n
|id�}
||
 ||
dfS(Nt
/R=iRi
(tfindtrfind(R@t
i((s/sys/lib/python/urlparse.pyR?�s






icCsVx>d
D]*}|i||
�}|djo
Pq
qWt
|�}||
|!||fS(Ns/?#i(RDtlen(R@tstartt
ctdelim((s/sys/lib/python/urlparse.pyt_splitnetloc�s




	
cCszt|�}||
|f}t
i|d
�}|o
|Sn

tt
�tjo
t�
n

d
}}}|id�}|djo&

|| djo�
|| i�}
||d}|d djo
t	|d�\}}n

|o)
d|jo
|i
dd�\}}n

d	|jo
|i
d	d�\}}n

t|
||||�}	|	t
|<|	Sn

xG|| D]}
|
tjo
Pqk

qk
W|| i�||d}
}n

|
t
jo*
|d djo
t	|d�\}}n

|o6
|
tjo)
d|jo
|i
dd�\}}n

|
tjo)
d	|jo
|i
d	d�\}}n

t|
||||�}	|	t
|<|	S(s
Parse a URL into 5 components:
    <scheme>://<netloc>/<path>?<query>#<fragment>
    Return a 5-tuple: (scheme, netloc, path, query, fragment).
    Note that we don't break the components up in smaller bits
    (e.g. netloc is a single string) and we don't expand % escapes.RR(iRi
is//t
#t
?N(tboolRtgetR*RGtMAX_CACHE_SIZERRDR.RKR)R7tscheme_charstuses_netloct
uses_fragmentt
uses_query(R@R"RAtkeytcachedR#R%R&RFt
vRI((s/sys/lib/python/urlparse.pyR�sH



























	#


!






c
CsL|\}
}}}}}|o
d
||f}n

t|
||||f�S(s�Put a parsed URL back together again.  This may result in a
    slightly different, but equivalent URL, if the URL that was parsed
    originally had redundant delimiters, e.g. a ? with an empty query
    (the draft states that these are equivalent).s%s;%s(
R(t.0R"R#R@R<R%R&((s/sys/lib/python/urlparse.pyR
�s

c
Cs�|\}
}}}}|p%
|
o]
|
tjoP
|d
 djo?
|o
|d djo
d|}n

d|p
d|}n

|
o
|
d|}n

|o
|d|}n

|o
|d|}n

|S(	Nis//i
RCRR(RMRL(
RR(RXR"R#R@R%R&((s/sys/lib/python/urlparse.pyR�s
,
&







c	Cs�|p
|
Sn

|
p
|Sn

t|d
|�\}}}}}}t|
||�\}	}
}}}
}|	|jp

|	t
jo
|
Sn

|	tjo1
|
o 
t|	|
|||
|f�Sn

|}
n

|d djo 
t|	|
|||
|f�Sn

|p
|p
|
p 
t|	|
||||f�Sn

|id�d |id�}|ddjo
d
|d<n

xd|jo
|id�
qn

Wxvd}t|�d}xZ||joK
||djo,
||dd	jo
||d|d5Pn

|d}q�
WPq�|d
dgjo
d
|d<n6
t|�djo"
|ddjo
d
g
|d)n

t|	|
di|�||
|f�S(
saJoin a base URL and a possibly relative URL to form an absolute
    interpretation of the latter.Ri
RCi�t
.s..ii�(Rs..(Rt
uses_relativeRRR
R)tremoveRGtjoin(tbaseR@RAtbschemetbnetloctbpathtbparamstbqueryt	bfragmentR"R#R$R<R%R&tsegmentsRFt
n((s/sys/lib/python/urlparse.pyR�sP


$$















 














$


c
Csed
|joJ
t|�\}
}}}}}t
|
||||df�}||fSn
|dfSdS(s�Removes any existing fragment from URL.

    Returns a tuple of the defragmented URL and the fragment.  If
    the URL contained no fragments, the second element is the
    empty string.
    RLRN(RR
(R@t
sRet
pt
at
qtfragtdefrag((s/sys/lib/python/urlparse.pyR$
s




s�
      http://a/b/c/d

      g:h        = <URL:g:h>
      http:g     = <URL:http://a/b/c/g>
      http:      = <URL:http://a/b/c/d>
      g          = <URL:http://a/b/c/g>
      ./g        = <URL:http://a/b/c/g>
      g/         = <URL:http://a/b/c/g/>
      /g         = <URL:http://a/g>
      //g        = <URL:http://g>
      ?y         = <URL:http://a/b/c/d?y>
      g?y        = <URL:http://a/b/c/g?y>
      g?y/./x    = <URL:http://a/b/c/g?y/./x>
      .          = <URL:http://a/b/c/>
      ./         = <URL:http://a/b/c/>
      ..         = <URL:http://a/b/>
      ../        = <URL:http://a/b/>
      ../g       = <URL:http://a/b/g>
      ../..      = <URL:http://a/>
      ../../g    = <URL:http://a/g>
      ../../../g = <URL:http://a/../g>
      ./../g     = <URL:http://a/b/g>
      ./g/.      = <URL:http://a/b/c/g/>
      /./g       = <URL:http://a/./g>
      g/./h      = <URL:http://a/b/c/g/h>
      g/../h     = <URL:http://a/b/c/h>
      http:g     = <URL:http://a/b/c/g>
      http:      = <URL:http://a/b/c/d>
      http:?y         = <URL:http://a/b/c/d?y>
      http:g?y        = <URL:http://a/b/c/g?y>
      http:g?y/./x    = <URL:http://a/b/c/g?y/./x>
c	Cs�d
dk}d}
|i
do7
|i
d}|djo

|i}q�
t|�}nG
yd
dkl}
Wn#tj
o



d
dkl}
n
X|t�}x�i�}|p
Pn

|i	�}|p
q�n

|d}t
|�}d||fGHt|
|�}	|
p

|	}
n

d|	}
d	||
fGHt|�d
jo;
|ddjo*
|
|djo
d
G|dGdGHq~

q�
q�dS(Ni�Ri
t
-(
tStringIOis
%-10s : %ss<URL:%s>s
%-10s = %sit
=itEXPECTEDs
!!!!!!!!!!(
tsystargvtstdintopent	cStringIORmtImportErrort
test_inputtreadlineR)RRRG(RpR]tfntfpRmtlinetwordsR@tpartstabstwrapped((s/sys/lib/python/urlparse.pyttestU
s:






























$

t__main__N(R4t__all__RZRRtnon_hierarchicalR>RTRSRQRPRRRBR R7R;tTrueRR?RKRR
RRRRvRR2(((s/sys/lib/python/urlparse.pys<module>sL

















	L			+			0	/	!