�
}�^c@sz
dZd
dl
mZ
d
dlZd
dlZd
dlZd
dlZd
dlZd
dlZd
dl	Z	d
dl
Z
d
dlZd
dlZd
dl
Z
d
dlZd
dlZd
dlZd
dlZd
dlZd
dlZd
dlZd
dlZe
jdkr
d
dlZnd
dlZejZejZejZejZejZejZej Z ej!Z!ej"Z"ej#Z#ej$Z$ej%Z%ej&Z&ej'Z'ej(Z(ej)Z)ej*Z*ej+Z+ej,Z,ej-Z-ej.Z.ej/Z/ej0Z0ej1Z1ej2Z2ej3Z3ej4Z4ej5Z5ej6Z6ej7Z7ej8Z8ej9Z9ej:Z:ej;Z;ej<Z<ej=Z=ej>Z>ej?Z?ej@Z@ejAZAeBedejC�ZCejDZDejEZEejFZFejGZGejHZHejIZIejJZJejKZKeL�ZMd�ZNdd�
aOdd	�
aPy
eQZQWn?eRk
r^


e
jSd
dkrOd
d�
ZQnd
d
�
ZQn
Xd
dlTZTe
jdkZUeVeWd�ZXeVeWd�ZYeVeWd�ZZd�Z[dddddddddddddd d!d"d#d$d%d&d'd(d)d*fZ\e\d+d,d-d.fZ]d/�Z^yej_j`
ej_Z_Wn*eak
r`


d0ej_f
d1��YZ_n
Xd2eLf
d3��YZbd4�Zcd5eLf
d6��YZdd7�Zed8�Zfiefd96eed:6Zgd;�Zhd<�Zid=d>d?�ZjejkZkd@�ZldA�ZmdB�ZneVaodC�ZpdD�ZqdE�ZrieVeVeVeVdF�ZsdG�ZtdH�ZueVdI�
ZvdJj@�ZwdKZxdL�Zye
jdkr�eyZzn	ejzZzdM�Z{dN�Z|dO�Z}dP�Z~yd
dlZeVa�Wne�k
r�


eWa�n
Xd
dQ�
Z�iZ�dR�Z�dS�Z�dT�Z�dU�Z�dV�Z�eWeVdW�Z�dXeLf
dY��YZ�eVeWdZ�Z�eVd[�
Z�d\�Z�d]�Z�d^�Z�d_eLf
d`��YZ�d>eVda�Z�db�Z�eVdcdd�Z�eVde�
Z�gdf�
Z�eVidg�Z�dh�Z�di�Z�dj�Z�dk�Z�dl�Z�dmdn�
Z�do�Z�e�dpdqdr>eds�
fdtdqdr>edu�
fdqdqdr>edv�
fdpdqdw>edx�
fdtdqdw>edy�
fdqdqdw>edz�
fdpdqdt>ed{�
fdtdqdt>ed|�
fdqdqdt>ed}�
fdqdqed~�
f�
Z�d�Z�d��a�ddd��Z�d��Z�d��Z�d��Z�d��Z�ye�e�f\Z�Z�Wn#eRk
r�


d��Z�d��Z�n
XeVeWd��Z�d��Z�i
e�d�6e�d�6e�d�6e�d�6e�d�6eWd�6eWd�6eWd�6eWd�6eWd�6Z�d��Z�d�Z�e�d��e�D�
�
Z�d��Z�d�eLf
d���YZ�d��Z�d��Z�d��Z�d��Z�d��Z�d��Z�d��Z�e�dqd�ed��
fdpdqed��
fdtdqed��
fdqdqed��
fdpd�ed��
fdtd�ed��
fdqd�ed��
fdpd�ed��
fdtd�ed��
fdqd�ed��
fdpd�ed��
fdtd�ed��
fdqd�ed��
f�
Z�d
g
Z�d��Z�dS(�s�Mercurial utility functions and platform specific implementations.

This contains helper routines that are independent of the SCM core and
hide platform-specific details from the core.
i����(
t
_Ntntt	statfilescCst||
t
�t
k	S(
N(tgetattrt_notset(tthingtattr((s4/usr/lib64/python2.7/site-packages/mercurial/util.pytsafehasattrQs
tc

Cs
t|�
S(
s�
    Low-overhead wrapper around Python's SHA support

    >>> f = _fastsha1
    >>> a = sha1()
    >>> a = f()
    >>> a.hexdigest()
    'da39a3ee5e6b4b0d3255bfef95601890afd80709'
    (
t	_fastsha1(
t
s((s4/usr/lib64/python2.7/site-packages/mercurial/util.pytsha1Tsc
CsFtj
dkr"ddlm}

nddlm}

|
aa|
|�
S(Niii����(
R(
tsha(ii(tsystversion_infothashlibRRR	(R
t_sha1((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyR	as



iicCs||
S(
N((t	sliceabletoffset((s4/usr/lib64/python2.7/site-packages/mercurial/util.pytbufferqs
cCst|�
|
S(
N(
t
memoryview(RR((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyRts
tposixcCsOtj
|d
tdddtdtjdtjd|d|
�
}|j|jfS(	Ntshelltbufsizei����t	close_fdststdintstdouttuniversal_newlinestenv(t
subprocesstPopentTruetclosefdstPIPERR(tcmdRtnewlinest
p((s4/usr/lib64/python2.7/site-packages/mercurial/util.pytpopen2zs



	
cCs+t||
|�\}}}}|||fS(
N(
tpopen4(R"RR#RRtstderrR$((s4/usr/lib64/python2.7/site-packages/mercurial/util.pytpopen3�s

cCsatj
|d
tdddtdtjdtjdtjd|d	|
�
}|j|j|j|fS(
NRRi����RRRR'RR(RRRR R!RRR'(R"RR#R$((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyR&�s



	

	
c
Cs0yd
dl}|j
SWntk
r+


dSXdS(s(Return version information if available.i����Ntunknown(t__version__tversiontImportError(
R*((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyR+�s





s%Y-%m-%d %H:%M:%Ss%Y-%m-%d %I:%M:%S%ps%Y-%m-%d %H:%Ms%Y-%m-%d %I:%M%ps%Y-%m-%ds%m-%ds%m/%ds%m/%d/%ys%m/%d/%Ys%a %b %d %H:%M:%S %Ys%a %b %d %I:%M:%S%p %Ys%a, %d %b %Y %H:%M:%Ss%b %d %H:%M:%S %Ys%b %d %I:%M:%S%p %Ys%b %d %H:%M:%Ss%b %d %I:%M:%S%ps%b %d %H:%Ms
%b %d %I:%M%ps%b %d %Ys%b %ds%H:%M:%Ss
%I:%M:%S%ps%H:%Ms%I:%M%ps%Ys%Y-%ms%bs%b %Yc
sCi��
jj
d
kr-��
fd�}
n��
fd�}
|
S(s"cache the result of function callsi
c

s'|�kr�
|�
�|<n�|S(
N((
targ(tcachetfunc(s4/usr/lib64/python2.7/site-packages/mercurial/util.pyt
f�s


c
s'|�kr�
|��|<n�|S(
N((
targs(R.R/(s4/usr/lib64/python2.7/site-packages/mercurial/util.pyR0�s


(t	func_codetco_argcount(R/R0((R.R/s4/usr/lib64/python2.7/site-packages/mercurial/util.pyt	cachefunc�s

tdequec
BseZ
d�ZRS(
cCs8x1t|�
D]#\}}||
kr
||=Pq
q
WdS(
N(
t	enumerate(tselftvalt
it
v((s4/usr/lib64/python2.7/site-packages/mercurial/util.pytremove�s



(t__name__t
__module__R;(((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyR5�s
tlrucachedictc
Bs2eZ
dZd
�Zd�Zd�Zd�ZRS(s6cache most recent gets from or sets to this dictionarycCs"i|_|
|_
t�|_dS(
N(t_cachet_maxsizeR5t_order(R7tmaxsize((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyt__init__�s
	
	
cCs1|j|
}|j
j|
�

|j
j|
�

|S(
N(R?RAR;tappend(R7tkeytvalue((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyt__getitem__�s




cCsq|
|jkr@t
|j�
|jkrP|j|jj�=qPn|jj|
�

||j|
<|jj|
�

dS(
N(R?tlenR@RAtpopleftR;RD(R7RERF((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyt__setitem__�s





cCs
|
|jkS(
N(
R?(R7RE((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyt__contains__�s
(R<R=t__doc__RCRGRJRK(((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyR>�s


				c
sRi�t���
j
jd
kr9��
�fd�}
n��
�fd�}
|
S(s+cache most recent results of function callsi
c

sc|�krAt��
d
kr.��j
�=n�
|�
�|<n
�j|�

�j|�

�|S(Ni(RHRIR;RD(
R-(R.R/torder(s4/usr/lib64/python2.7/site-packages/mercurial/util.pyR0�s







c
sc|�krAt��
d
kr.��j
�=n�
|��|<n
�j|�

�j|�

�|S(Ni(RHRIR;RD(
R1(R.R/RM(s4/usr/lib64/python2.7/site-packages/mercurial/util.pyR0
s







(R5R2R3(R/R0((R.R/RMs4/usr/lib64/python2.7/site-packages/mercurial/util.pytlrucachefunc�s
	



t
propertycachecBs&eZ
d�Zdd
�
Zd�ZRS(cCs|
|_|
j
|_dS(
N(R/R<tname(R7R/((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyRC
s
	
cCs#|j|
�
}|j
|
|�
|S(
N(R/t
cachevalue(R7tobjttypetresult((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyt__get__
s


cCst|
|j
|�
dS(
N(tsetattrRP(R7RRRF((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyRQ
s
N(R<R=RCtNoneRURQ(((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyRO
s
	c
CsFtj
|
d
tdtdtjdtj�
}|j|�
\}}|S(s9filter string S through command CMD, returning its outputRRRR(RRRR R!tcommunicate(R
R"R$tpouttperr((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyt
pipefilter
s


c	Cs�
d
\}}z
t
jd
d�
\}}tj|d�}|j|�

|j�
t
jd
d�
\}}tj|�

|
jd|�}
|
jd|�}
tj|
�
}t	j
dkr�|d@r�d	}n|r�ttd
�
|
t
|�
f�
�
nt|d�}|j�}|j�
|SWdy|r;
tj|�

nWntk
rO



n
Xy|ri
tj|�

nWntk
r}



n
XXdS(s�filter string S through a pair of temporary files with CMD.
    CMD is used as a template to create the real command to be run,
    with the strings INFILE and OUTFILE replaced by the real names of
    the temporary files generated.tprefixs
hg-filter-in-twbshg-filter-out-tINFILEtOUTFILEtOpenVMSi
iscommand '%s' failed: %strbN(NN(RWttempfiletmkstemptostfdopentwritetclosetreplacetsystemR
tplatformtAbortRtexplainexittopentreadtunlinktOSError(	R
R"tinnametoutnametinfdtfptoutfdtcodet
r((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyt
tempfilter#
s<














	


















s	tempfile:spipe:cCsVxFtj
�D]8\}}|
j|�
r
|||
t|�
j��Sq
Wt||
�S(
sIfilter a string through a command that transforms its input to its output(tfiltertablet	iteritemst
startswithRHtlstripR[(R
R"RPtfn((s4/usr/lib64/python2.7/site-packages/mercurial/util.pytfilterM
s

!
c

Cst|od
|k�
S(s&return true if a string is binary datat
(
tbool(
R
((s4/usr/lib64/python2.7/site-packages/mercurial/util.pytbinaryT
sii
ccs�d
�}g}d}x�|D]�}|j|�

|t
|�
7}||
kr|
|kr�|
d>}
d||�
>}||
kr�|}
n|
|kr�|}
q�ndj|�
V
d}g}qqW|r�dj|�
V
ndS(srreturn no less than min bytes per chunk while data remains,
    doubling min after each chunk until it reaches maxc
Ss9|s
d
Sd
}
x|r0|dL}|
d7}
qW|
dS(Nii
((t
xR9((s4/usr/lib64/python2.7/site-packages/mercurial/util.pytlog2[
s



	



ii
RN(RDRHtjoin(tsourcetmintmaxR�tbuftblentchunktnmin((s4/usr/lib64/python2.7/site-packages/mercurial/util.pytincreasingchunksX
s&		












	







c


CstS(
N(
R(
R}((s4/usr/lib64/python2.7/site-packages/mercurial/util.pytalwaysy
s
c


CstS(
N(
tFalse(
R}((s4/usr/lib64/python2.7/site-packages/mercurial/util.pytnever|
s
cCs!
|
st|�
St
jj|
�
r�t
jj|�
d
t
jj|
�
d
krgt
jj|t|�
�Sdjt|�
|f�
}nt|
�
|jd�
}}|j	�
|j	�
x8|r�|r�|d|dkr�|j
�
|j
�
q�W|j	�
t
jjdg
t|�
|�
p 
dS(sa
return the relative path from one place to another.
    root should use os.sep to separate directories
    n1 should use os.sep to separate directories
    n2 should use "/" to separate directories
    returns an os.sep-separated path.

    If n1 is a relative path, it's assumed it's
    relative to root.
    n2 should always be relative to root.
    it
/i����s..t
.(
t	localpathRdtpathtisabst
splitdriveR�tpconvertt	splitpathtsplittreversetpoptsepRH(troottn1tn2t
at
b((s4/usr/lib64/python2.7/site-packages/mercurial/util.pytpathto
s



,







#





cCs+tt
d
�p*tt
d�p*tjd�
S(s�return True if we are a frozen executable.

    The code supports py2exe (most common, Windows only) and tools/freeze
    (portable, not much used).
    tfrozent	importerst__main__(RR
timpt	is_frozen(((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyt
mainfrozen�
s

cCs�tdkr�tjjd
�
}tjd}
|r>t|�

q�t�rWttj	�

q�tj
jt|
dd��
dkr�t|
j
�

q�td�
p�tj
jtjd�
}t|�

ntS(s]return location of the 'hg' executable.

    Defaults to $HG or 'hg' in the search path.
    tHGR�t__file__RthgiN(t
_hgexecutableRWRdtenvirontgetR
tmodulest_sethgexecutableR�t
executableR�tbasenameRR�tfindexetargv(R�tmainmodtexe((s4/usr/lib64/python2.7/site-packages/mercurial/util.pythgexecutable�
s






	

$
%


c


Cs
|ad
S(s#set location of the 'hg' executableN(
R�(
R�((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyR��
scs'ytj
j�
Wntk
r$


n
Xd
��|}t|�
}tjdkr}|dk	rktj|�

ntj	|�
}n
t
tj�
}|j�f
d�|
j
�D�
�

t�|d<|dks�|tjkr

tj|dtdtd|d|�
}nmtj|dtdtd|d|d	tjd
tj�
}	x|	j
D]}
|j|
�

qD
W|	j�
|	j}tjdkr�
|d@r�
d
}n|r#|r#dtjj|jdd�d
�
t|�
d
f}|r�
d||f}ny|j|d�

Wq#tk
r


||�
�
q#Xn|S(s�
enhanced shell command execution.
    run with environment maybe modified, maybe in different dir.

    if command fails and onerr is None, return status.  if ui object,
    print error message and return status, else raise onerr object as
    exception.

    if out is specified, it is assumed to be a file-like object that has a
    write() method. stdout and stderr will be redirected to out.c

Ss6|dks|t
krd
S|tkr,dSt|�
S(s9convert python object into string that is useful to shellt
0t
1N(RWR�Rtstr(
R8((s4/usr/lib64/python2.7/site-packages/mercurial/util.pytpy2shell�
s




tplan9c
3s'|]\}
}|
�|�
fV
qdS(
N((t.0t
kR:(
R�(s4/usr/lib64/python2.7/site-packages/mercurial/util.pys	<genexpr>�
sR�RRRtcwdRR'R`i
is%s %ss%s: %ss

N( R
Rtflusht	ExceptiontquotecommandRjRWRdtchdirRitdictR�tupdateRzR�t
__stdout__RtcallRR RR!tSTDOUTRftwaitt
returncodeR�R�R�RltwarntAttributeError(R"R�R�tonerrt	errprefixtouttorigcmdtrcRtproctlineterrmsg((
R�s4/usr/lib64/python2.7/site-packages/mercurial/util.pyRi�
sH





	




#











	

	

"








c
s�f
d
�}
|
S(s5wrap a function with code to check for calling errorscs]y�||
�SWnEtk
rX


t
tjtj�d
�
�
dkrRtj�
n�n
XdS(Nii
(t	TypeErrorRHt	tracebackt
extract_tbR
texc_infoterrortSignatureError(R1tkwargs(
R/(s4/usr/lib64/python2.7/site-packages/mercurial/util.pytcheck�
s




%

((R/R�((
R/s4/usr/lib64/python2.7/site-packages/mercurial/util.pytchecksignature�
scCs�tj
j|
�
rt|
�

ntj
j|�
rMtjtj|�
|
�
nOy$tj||
�
tj	||
�
Wn(tj
k
r�
}
tt|�
�
�
n
Xd
S(s,copy a file, preserving mode and atime/mtimeN(
RdR�tlexistsRotislinktsymlinktreadlinktshutiltcopyfiletcopymodetErrorRkR�(tsrctdesttinst((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyR�s







c	CsA
|dkr?t
j|�
jt
jt
jj|
�
�
jk}nd
}t
jj|�
r�t
j|
�

x�tj	|�
D]X\}}t
jj
||�}t
jj
|
|�}t|||�\}}||7}qtWnd|r
yt||
�
Wq-
t
tfk
r



t}tj||
�
q-
Xntj||
�
|d7}||fS(s1Copy a directory tree using hardlinks if possibleii
N(RWRdtstattst_devR�tdirnametisdirtmkdirtosutiltlistdirR�t	copyfilestoslinktIOErrorRpR�R�tcopy(	R�tdstthardlinktnumRPtkindtsrcnametdstnamet
n((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyR�s(

$














sqcon prn aux nul
    com1 com2 com3 com4 com5 com6 com7 com8 com9
    lpt1 lpt2 lpt3 lpt4 lpt5 lpt6 lpt7 lpt8 lpt9s:*?"<>|c
Cs�x�|jd
d�j
d�
D]�}
|
s.qnxH|
D]@}|tkrUtd�
|St|�
dk
r5td�
|Sq5W|
j
d�
d}|r�|j�tkr�td�
|S|
d}|d	kr|
d
krtd�
|SqWdS(
s�Check that the base-relative path is a valid filename on Windows.
    Returns None if the path is ok, or a UI string describing the problem.

    >>> checkwinfilename("just/a/normal/path")
    >>> checkwinfilename("foo/bar/con.xml")
    "filename contains 'con', which is reserved on Windows"
    >>> checkwinfilename("foo/con.xml/bar")
    "filename contains 'con', which is reserved on Windows"
    >>> checkwinfilename("foo/bar/xml.con")
    >>> checkwinfilename("foo/bar/AUX/bla.txt")
    "filename contains 'AUX', which is reserved on Windows"
    >>> checkwinfilename("foo/bar/bla:.txt")
    "filename contains ':', which is reserved on Windows"
    >>> checkwinfilename("foo/bar/bla.txt")
    "filename contains '\\x07', which is invalid on Windows"
    >>> checkwinfilename("foo/bar/bla ")
    "filename ends with ' ', which is not allowed on Windows"
    >>> checkwinfilename("../bar")
    s
\R�s4filename contains '%s', which is reserved on Windowsis1filename contains %r, which is invalid on WindowsR�ii����s. s..s8filename ends with '%s', which is not allowed on WindowsN(RhR�t_winreservedcharsRtordtlowert_winreservednames(R�R�t
ctbaset
t((s4/usr/lib64/python2.7/site-packages/mercurial/util.pytcheckwinfilename/s$"





	


	
	


	




	
cCs�ytj
||
�SWn;tk
rA
}
|jtjkrR�qRntk
rQ


n
Xtj|
tjtjBtj	B�}tj
||�
tj|�

dS(
N(RdR�RpterrnotEEXISTR�RmtO_CREATtO_WRONLYtO_EXCLRfRg(tinfotpathnametwhytld((s4/usr/lib64/python2.7/site-packages/mercurial/util.pytmakelock[s




	


#

c
Cs~ytj
|�
SWnDtk
rG
}

|
jtjtjfkrX�qXntk
rW


n
Xt|�
}|j�}|j	�
|S(
N(
RdR�RpR
tEINVALtENOSYSR�t	posixfileRnRg(R
R	
RtRw((s4/usr/lib64/python2.7/site-packages/mercurial/util.pytreadlockhs




	







c

Cs<ytj
|j��
SWntk
r7


tj|j�
SXd
S(s1stat file object that may not have fileno method.N(RdtfstattfilenoR�R�RP(
Rt((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyR
us



c
Cs�tj
|�
}
tjj|�
\}}|j�}||kr^|j�}||kr^tSntjj||�}y'tj
|�
}||
kr�tStSWnt	k
r�


tSXd
S(s�
    Return true if the given path is on a case-sensitive filesystem

    Requires a path (like /foo/.hg) ending with a foldable final
    directory component.
    N(
RdR�R�R�tupperR�RR�R�Rp(R�ts1t
dR�tb2tp2ts2((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyt	checkcase~s














cCs�tdkr:ytj
taWq:tk
r6


taq:Xntr�|
tjtj	B@d
kr�|
tj@rud|}n|
tj	@r�d|}nytj|�
SWq�tj
k
r�


q�Xntj||
�S(s�Compile a regular expression, using re2 if possible

    For best performance, use only re2-compatible regexp features. The
    only flags from the re module that are re2-compatible are
    IGNORECASE and MULTILINE.is(?i)s(?m)N(t_re2RWtre2tcompileRR,R�tret
IGNORECASEt	MULTILINER�(tpattflags((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyt	compilere�s 








!












cCsF
d
�}tj
}tjr+|tj}n|jdd�
tjd||f�
}tjj|
�
}g}x�|j|�
D]�\}}|r�|j	|�

q|n|t
kr�tj|�
t
|<nt
|}	|||	�}
|
s

tj|�
}	|	t
|<|||	�}
n|j	|
p
|�

tjj||�}q|Wdj|�
S(s4
Get name in the case stored in the filesystem

    The name should be relative to root, and be normcase-ed for efficiency.

    Note that this function is unnecessary, and should not be
    called, for case-sensitive filesystems (simply because it's expensive).

    The root should be normcase-ed, too.
    cSs+x$|
D]}t|�
|kr|SqWdS(
N(tnormcaseRW(R$tcontentsR�((s4/usr/lib64/python2.7/site-packages/mercurial/util.pytfind�s




s
\s\\s([^%s]+)|([%s]+)R(
RdR�taltsepRhR
R
R�tnormpathtfindallRDt_fspathcacheR�R�(RPR�R$
tsepstpatterntdirRTtpartR�R#
tfound((s4/usr/lib64/python2.7/site-packages/mercurial/util.pytfspath�s.
		
	
















c
	Cs�|d
}
tj
j|
�
r tSyt|
d�j�
Wntk
rK


tSX|d}d}zFyt|
|�
Wnt	k
r�


tSXt|�
}t
|�
dkSWd|dk	r�|j�
nx9|
|fD]+}ytj|�

Wq�t	k
r�


q�Xq�WXdS(s5check whether hardlink count reporting works properlys.hgtmp1t
ws.hgtmp2i
N(RdR�R�R�R
RgR�RWR�RptnlinksRo(ttestfiletf1tf2tfdR0((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyt
checknlink�s.
























c

Cs+|jt
j�
p*t
jo*|jt
j�
S(
s)Check path ends with os.sep or os.altsep.(tendswithRdR�R%
(
R�((s4/usr/lib64/python2.7/site-packages/mercurial/util.pytendswithsepsc

Cs|jt
j�
S(
s�Split path by os.sep.
    Note that this function does not use os.altsep because this is
    an alternative of simple "xxx.split(os.sep)".
    It is recommended to use os.path.normpath() before using this
    function if need.(R�RdR�(
R�((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyR�scCshtj
d
krEdtjkr"tSttdd�r>tj�St	Sntj
dkpctjjd�
SdS(sAre we running in a GUI?tdarwintSSH_CONNECTIONtisguiR
tDISPLAYN(R
RjRdR�R�RR�RWR:
RRPR�(((s4/usr/lib64/python2.7/site-packages/mercurial/util.pytguis


cCsB
tj
j|�
\}}tjd
d|d|�\}}tj|�

t|||�
|
ra|Sy�yt|d�}WnJtk
r�
}
|j	t	j
kr�|St|dd�s�||_
n�n
Xt|d�}	x!t|�
D]}
|	j|
�

q�W|j�
|	j�
Wn/


ytj|�

Wntk
r6



n
X�n
X|S(s
Create a temporary file with the same contents from name

    The permission bits are copied from the original file.

    If the temporary file is going to be truncated immediately, you
    can use emptyok=True as an optimization.

    Returns the name of the temporary file.
    R\s.%s-R+
RatfilenameR]N(RdR�R�RbRcRgR�R
R�R
tENOENTRRWR=
t
filechunkiterRfRoRp(RPtemptyokt
createmodeR
R}R4
ttemptifpR�tofpR�((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyt
mktempcopys6

"
























tatomictempfilecBs8eZ
dZd
dd�Zd�Zd�Zd�ZRS(sf
writable file object that atomically updates a file

    All writes will go to a temporary copy of the original file. Call
    close() when you are done writing, and atomictempfile will rename
    the temporary copy to the original name, making the changes
    visible. If the object is destroyed without being closed, all your
    writes are discarded.
    sw+bcCs|
|_t
|
d
d|kd|�
|_t|j|�|_|jj|_|jj|_|jj|_|jj|_dS(NR@
R/
RA
(	t_atomictempfile__nameRE
t	_tempnameR
t_fpRftseekttellR
(R7RPtmodeRA
((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyRCOs
	





c

Cs9|jj
s5|jj�
t|jt|j�
�
ndS(
N(RI
tclosedRgtrenameRH
R�RG
(
R7((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyRg[s



c

CsH|jj
sDytj|j�

Wntk
r3


n
X|jj�
ndS(
N(RI
RM
RdRoRH
RpRg(
R7((s4/usr/lib64/python2.7/site-packages/mercurial/util.pytdiscard`s






c

Cs t|d
�r|j
�
ndS(NRI
(RRO
(
R7((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyt__del__hs

N(R<R=RLRWRCRgRO
RP
(((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyRF
Fs

		cCs�yt||�
Wn�t
k
r�
}
|jtjkr9d
S|jtjksR|rX�ntjjtjj|�
�
}||kr��nt	||
|�
t||�
n
X|
d
k	r�tj||
�
nd
S(s9recursive directory creation with parent mode inheritanceN(tmakedirRpR
R
R>
RdR�R�tabspathtmakedirsRWtchmod(RPRL
t
notindexedterrtparent((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyRS
ls












cCs�tj
j|�
rd
Stj
jtj
j|�
�
}||krPt||
�
nytj|�

Wn>tk
r�
}
|jtj	kr�tj
j|�
r�d
S�n
X|
d
k	r�tj||
�
nd
S(s&race-safe recursive directory creationN(RdR�R�R�RR
t
ensuredirsR�RpR
R
RWRT
(RPRL
RW
RV
((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyRX
}s







$


c
Cs/t|d
�}
z|
j
�SWd|
j�
XdS(NRa(RmRnRg(R�Rt((s4/usr/lib64/python2.7/site-packages/mercurial/util.pytreadfile�s


cCs2t|d
�}z|j
|
�

Wd|j�
XdS(NR](RmRfRg(R�ttextRt((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyt	writefile�s


cCs2t|d
�}z|j
|
�

Wd|j�
XdS(Ntab(RmRfRg(R�RZ
Rt((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyt
appendfile�s


tchunkbufferc
Bs eZ
dZd
�Zd�ZRS(soAllow arbitrary sized chunks of data to be efficiently read from an
    iterator over chunks of arbitrary size.cCs(d
�}||
�
|_t
�|_dS(szin_iter is the iterator that's iterating over the input chunks.
        targetsize is how big a buffer to try to maintain.c
ssjxc|D][}
t|
�
dkr]d}x:|t|
�
krY|d}|
||!V
|}q(Wq|
V
qWdS(Niiiiii(
RH(tchunksR�tpostend((s4/usr/lib64/python2.7/site-packages/mercurial/util.pytsplitbig�s









N(titerR5t_queue(R7tin_iterRb
((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyRC�s	

cCs�|
}g}|j}x�|d
kr�|s~d}x>|j
D]3}|j|�

|t|�
8}|d
k
r:Pq:q:W|s~Pq~n|j�}|t|�
8}|d
kr�|j||�

|j|| �

q|j|�

qWdj|�
S(suRead L bytes of data from the iterator of chunks of data.
        Returns less than L bytes if the iterator runs dry.iiiRi(Rd
Rc
RDRHRIt
appendleftR�(R7t
ltleftR�tqueuettargetR�((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyRn�s(

	













(R<R=RLRCRn(((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyR^
�s	ccs�|
d
kst�
|dks0|d
ks0t�
xktr�|dkrN|
}nt||
�}|oo|j|�
}|s|Pn|r�|t|�
8}n|V
q3WdS(sX
Create a generator that produces the data in the file size
    (default 65536) bytes at a time, up to optional limit (default is
    to read all data).  Chunks may be less than size bytes if the
    chunk is the last chunk in the file, or the file is a socket or
    some other type of file that sometimes reads less data than is
    requested.iN(tAssertionErrorRWRR�RnRH(R0tsizetlimittnbytesR
((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyR?
�s

	

	





cCs�tj�}|d
krCt
d�
}
tt
d�
|d|
�

�
ntjj|�
tjj|�
}|jd|j}||fS(Nischeck your clocksnegative timestamp: %dthinti�Q
(ttimeRRktdatetimetutcfromtimestampt
fromtimestamptdaystseconds(tctRo
tdeltattz((s4/usr/lib64/python2.7/site-packages/mercurial/util.pytmakedate�s







s%a %b %d %H:%M:%S %Y %1%2c
Cs
|pt�\}}|d
kr0d
}d
}nd|
ksHd|
kr�|d
krZdp]d}t
|�
d}|
jdd||df�}
|
jdd|d�}
nytjt|�
|�
}Wn#tk
r�


tjtj�
}n
Xtj	|
|�}|S(	s�represent a (unixtime, offset) tuple as a localized time.
    unixtime is seconds since the epoch, and offset is the time zone's
    number of seconds away from UTC. if timezone is false, do not
    append time zone to string.is%1s%2t
-t
+i<s%c%02ds%02d(
Ry
tabsRhRp
tgmtimetfloatt
ValueErrorR
tmaxinttstrftime(tdatetformatR
Rx
tsigntminutesR
((s4/usr/lib64/python2.7/site-packages/mercurial/util.pytdatestr�s


	



 






c

Cst|d
d�

S(s1turn (timestamp, tzoff) tuple into iso 8631 date.R�
s%Y-%m-%d(
R�
(
R�
((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyt	shortdatesc
Cs$
d
�}||�
|}}|dk	rDdj
|j�d �
}nt}xndD]f}g|D]}d
||
kr^t^q^}	|	s�|d|||7}|
d|d
7}
qQt}qQWtj||
�}
ttj	|
�
�
}|dkr
ttj
|
�
�
}||}n
||}||fS(s~parse a localized time string and return a (unixtime, offset) tuple.
    if the string cannot be parsed, ValueError is raised.c
Ss�|j�d
}
|
ddkr�t
|
�
dkr�|
dj�r�|
ddkrXdp[d
}t|
dd!�
}t|
dd!�
}||d|dS|
d	ks�|
d
kr�dSdS(Ni����is+-ii
R{
ii<tGMTtUTC(R�RHtisdigittintRW(tstringRx
R�
thoursR�
((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyttimezones

2






t
 i����t
St
MtHIR
tmbtyYt
%t
@s@%iN(R�
R�
sHIR
smbR�
(RWR�R�R�RRp
tstrptimeR�
tcalendarttimegmtmktime(
R�
R�
tdefaultsR�
RR�
tusenowR,
R$R-
t	timetuplet
localunixtimetunixtime((s4/usr/lib64/python2.7/site-packages/mercurial/util.pytstrdates$	




)









cCsp|s
dSt|t
�r/t|�
dkr/|S|
s>t}
n|j�}|td�
krct�S|td�
kr�tjj	�j
d�
}n=|td�
kr�tjj	�tjdd�
j
d�
}ny"tt
|jd	�
�\}}Wn�tk
r�



t�}i}xrdD]j}|j|�
}|dkrX
|d
dkrO
d}qX
d}nt|d|d
�}	||	f||<q
Wx_|
D]=}
yt||
|�\}}Wnttfk
r�



q�
XPq�
Wttd�
|�
�
n
Xt|�
dkrttd�
|�
�
n|d
kr5ttd�
|�
�
n|dksM|dkrfttd�
|�
�
n||fS(s�parse a localized date/time and return a (unixtime, offset) tuple.

    The date may be a "unixtime offset" string or in one of the specified
    formats. If the date already is a (unixtime, offset) tuple, it is returned.

    >>> parsedate(' today ') == parsedate(                                  datetime.date.today().strftime('%b %d'))
    True
    >>> parsedate( 'yesterday ') == parsedate((datetime.date.today() -                                               datetime.timedelta(days=1)                                              ).strftime('%b %d'))
    True
    >>> now, tz = makedate()
    >>> strnow, strtz = parsedate('now')
    >>> (strnow - now) < 1
    True
    >>> tz == strtz
    True
    iitnowttodays%b %dt	yesterdayRt
i
R�
R
R�
R�
R�
R�
R�
tHMSt00R�R�
sinvalid date: %ri���sdate exceeds 32 bits: %dsnegative date value: %di ;��i��simpossible time zone offset: %d(ii(R
smbsyYsHIR�
R�
N(t
isinstancettupleRHtdefaultdateformatststripRRy
Rq
R�
R�
R�
t	timedeltatmapR�
R�R
R�RWR�
R�
t
OverflowErrorRkR|
(R�
tformatstbiastwhenRR�
R�
R,
R�R�R�
((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyt	parsedate5sR

!


	







"

	





		










c
s�
d
�}
d�}|j�}|s9t
td�
�
�
n�
|ddkr�|dsht
td�
�
�
n||d�
��f
d�S|dd	kr�|ds�t
td
�
�
�
n|
|d�
��f
d�S|ddkrr
yt|d�
}Wn+tk
r"



t
td
�
|d�
�
n
X|dkrL
t
td�
|d�
�
nt�d|dd��f
d�Sd|kr�
|jd�
\}}|
|�
||�
��
��
fd�S|
|�
||�
��
��
fd�SdS(sAReturn a function that matches a given date match specifier

    Formats include:

    '{date}' match a given date to the accuracy provided

    '<{date}' on or before a given date

    '>{date}' on or after a given date

    >>> p1 = parsedate("10:29:59")
    >>> p2 = parsedate("10:30:00")
    >>> p3 = parsedate("10:30:59")
    >>> p4 = parsedate("10:31:00")
    >>> p5 = parsedate("Sep 15 10:30:00 1999")
    >>> f = matchdate("10:30")
    >>> f(p1[0])
    False
    >>> f(p2[0])
    True
    >>> f(p3[0])
    True
    >>> f(p4[0])
    False
    >>> f(p5[0])
    False
    c
Ss)td
ddd�}
t
|t|
�dS(NR�
R�R
i(R�R�
textendeddateformats(R�
R
((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyR��s

c
	Ss�td
ddddddd�}
xDdD]<}y"||
d<t
|t|
�dSWq(tk
rc


q(Xq(Wd
|
d<t
|t|
�dS(NR�
t12R�
t23R�
t59R�
t31t30t29R
it28(R�
R�
R�
(R�R�
R�
Rk(R�
R
Rt
((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyR
�s
!











s+dates cannot consist entirely of whitespaceit
<i
sinvalid day spec, use '<DATE'c

s
|�k
S(
N((
R�(
R�
(s4/usr/lib64/python2.7/site-packages/mercurial/util.pyt<lambda>�st
>sinvalid day spec, use '>DATE'c

s
|�kS(
N((
R�(
R�
(s4/usr/lib64/python2.7/site-packages/mercurial/util.pyR�
�sRz
sinvalid day spec: %ss,%s must be nonnegative (see 'hg help dates')iic

s
|�kS(
N((
R�(
R�
(s4/usr/lib64/python2.7/site-packages/mercurial/util.pyR�
�ss to c

s|�ko|�
k
S(
N((
R�(tstarttstop(s4/usr/lib64/python2.7/site-packages/mercurial/util.pyR�
�sc

s|�ko|�
k
S(
N((
R�(R�
R�
(s4/usr/lib64/python2.7/site-packages/mercurial/util.pyR�
�sN(R�
RkRR�
R
Ry
R�(R�
R�R
Rt
R�R�((R�
R�
R�
s4/usr/lib64/python2.7/site-packages/mercurial/util.pyt	matchdate�s>		































c
Cs�|jd
�
}
|
dkr(||
 }n|jd�
}
|
dkrT||
d}n|jd�
}
|
dkr|||
 }n|jd�
}
|
dkr�||
 }n|S(s>Return a short representation of a user name or email address.R�
iR�
i
R�
R�(
R$
(tuserR0((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyt	shortuser�s














c
CsX|jd
�
}
|
dkr(||
 }n|jd�
}
|
dkrT||
d}n|S(s,Return the user portion of an email address.R�
iR�
i
(
R$
(R�
R0((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyt	emailuser�s






c
Cs<|jd
�
}
|
dkr$d}
n||jd�
d|
!S(sget email of author.R�
i����R�
i
N(R$
RW(tauthorRw((s4/usr/lib64/python2.7/site-packages/mercurial/util.pytemail�s

	
cCs6t|�
|
k
r|t
fSd
||
d tfSdS(Ns%s...i(RHR�R(RZ
t	maxlength((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyt	_ellipsis�s


i�
cCsky?t|j
tj�
|
�\}}|s.|S|jtj�
SWn%ttfk
rf


t||
�d
SXdS(s;Trim string to at most maxlength (default: 400) characters.iN(R�
tdecodetencodingtencodetUnicodeDecodeErrortUnicodeEncodeError(RZ
R�
tutextt	truncated((s4/usr/lib64/python2.7/site-packages/mercurial/util.pytellipsis�s





cs�f
d
�}
|
S(s@return a function that renders a readable count of some quantityc
sLx9�D]1\}
}}|||
kr||t|�
SqW�d
d|S(Ni����i(
R~
(tcountt
multipliertdivisorR�
(
t	unittable(s4/usr/lib64/python2.7/site-packages/mercurial/util.pytgos



((R�
R�
((
R�
s4/usr/lib64/python2.7/site-packages/mercurial/util.pytunitcountfn
sidi
is%.0f GBi
s%.1f GBs%.2f GBis%.0f MBs%.1f MBs%.2f MBs%.0f KBs%.1f KBs%.2f KBs
%.0f bytesc

Cst|�
j
d
d�S(Ns\\s
\(treprRh(
R
((s4/usr/lib64/python2.7/site-packages/mercurial/util.pytuireprscKs)d
tj
f
d��Y}
|
a|
|�S(Nttwc
Bs2eZ
dZd
�Zd�Zd�Zd�ZRS(s8
        Extend TextWrapper for width-awareness.

        Neither number of 'bytes' in any encoding nor 'characters' is
        appropriate to calculate terminal columns for specified string.

        Original TextWrapper implementation uses built-in 'len()' directly,
        so overriding is needed to use width information of each characters.

        In addition, characters classified into 'ambiguous' width are
        treated as wide in East Asian area, but as narrow in other.

        This requires use decision to determine width of such characters.
        c
[sGtj
j||
�

t|d
d�dkrC|
jd
t�|_ndS(Ntdrop_whitespace(ttextwraptTextWrapperRCRRWR�RR�
(R7R�((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyRC.s

cSshd
}tj
}xLtt|
�
�
D]8}|||
|�
7}||kr"|
| |
|fSq"W|
dfS(NiR(R�
t	ucolwidthtxrangeRH(R7tucstrt
space_leftRg
tcolwidthR9((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyt_cutdown5s

	




cSsrt||d
�}|j
rR|j|
d|�\}}|j|�

||
d<n|sn|j|
j��

ndS(Ni
i����(R�tbreak_long_wordsR�
RDR�(R7treversed_chunkstcur_linetcur_lentwidthR�
tcuttres((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyt_handle_long_word?s
	






c		Ss�
tj
}g}|jd
k
r4td|j�
�
n|
j�
xH
|
r�
g}d
}|re|j}n	|j}|jt|�
}|jr�|
dj	�dkr�|r�|
d=nxK|
r�||
d�
}|||k
r�|j
|
j��

||7}q�Pq�W|
r3
||
d�
|kr3
|j|
|||�
n|jrb
|rb
|dj	�dkrb
|d=n|rA|j
|dj
|�
�

qAqAW|S(Nisinvalid width %r (must be > 0)i����R(R�
R�
R�
R
R�tsubsequent_indenttinitial_indentRHR�
R�
RDR�R�
R�(	R7R_
R�
tlinesR�
R�
tindentR�
Rg
((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyt_wrap_chunksKs8
	


	

	%

	




	



!(R<R=RLRCR�
R�
R�
(((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyR�
s

		
	(R�
R�
t
MBTextWrapper(R�R�
((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyR�
s
j
cCs�tt
|�
t
|�
�}|
|k
r=td
|d�}
n|jtjtj�}|jtjtj�}|jtjtj�}td|
d|d|�}|j|�
jtj�
S(NiNi
R�
R�
R�
(R�RHR�
R�
tencodingmodeR�
tfillR�
(R�R�
t
initindentt
hangindentt	maxindenttwrapper((s4/usr/lib64/python2.7/site-packages/mercurial/util.pytwrap�s







	
c
cs1x*|D]"}
x|
j�D]}|V
qWqWdS(
N(
t
splitlines(titeratorR�R�((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyt	iterlines�s



c

Cstj
jtj
j|�
�
S(
N(RdR�t
expandusert
expandvars(
R�((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyt
expandpath�s
c
Cst�rt
jg
St�S(
s�Return the command used to execute current hg

    This is different from hgexecutable() because on Windows we want
    to avoid things opening new shell windows like batch files, so we
    get either the python call or current executable.
    (R�R
R�tgethgcmd(((s4/usr/lib64/python2.7/site-packages/mercurial/util.pythgcmd�s	


cs�t���f
d
�}d}ttdd�}|dk	rQtj||�}nzXt|�
}xA|
�s�|�ks�t|�
r�|
�r�dStjd�

qcW|SWd|dk	r�tjtj|�
nXdS(s_
Execute the argument list in a detached process.

    condfn is a callable which is called repeatedly and should return
    True once the child process is known to have started successfully.
    At this point, the child process PID is returned. If the child
    process fails to start or finishes before condfn() evaluates to
    True, return -1.
    cs�jt
j��

dS(
N(taddRdR�(tsignumtframe(
t
terminated(s4/usr/lib64/python2.7/site-packages/mercurial/util.pythandler�s
tSIGCHLDi����g�������?N(	tsetRWRtsignalt
spawndetachedttestpidRp
tsleepR(R1tcondfnR
tprevhandlerRtpid((
Rs4/usr/lib64/python2.7/site-packages/mercurial/util.pytrundetached�s 	













c
Csx|D]}
|
rtSqWt
S(
N(RR�(titerableR9((s4/usr/lib64/python2.7/site-packages/mercurial/util.pytany�s




c
Csx|D]}
|
stSqWt
S(
N(R�R(RR9((s4/usr/lib64/python2.7/site-packages/mercurial/util.pytall�s




cs��pd
��dj�
j
��
}|rj|d|7}t|�
dkrW|d}n|}|�
|<ntjd||f�
}|j��
fd�|�S(s�
Return the result of interpolating items in the mapping into string s.

    prefix is a single character string, or a two character string with
    a backslash as the first character if the prefix needs to be escaped in
    a regular expression.

    fn is an optional function that will be applied to the replacement text
    just before replacement.

    escape_prefix is an optional flag that allows using doubled prefix for
    its escaping.
    c


Ss|S(
N((
R
((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyR�
�st
|i
s%s(%s)c

s��
|j�d
�
S(Ni
(
tgroup(
R�(R}tmapping(s4/usr/lib64/python2.7/site-packages/mercurial/util.pyR�
�s(R�tkeysRHR
R
tsub(R\RR
R}t
escape_prefixtpatternstprefix_charRw((R}Rs4/usr/lib64/python2.7/site-packages/mercurial/util.pytinterpolate�s










c

Csdyt|�
SWnt
k
r!


n
Xytj|�
SWn*tjk
r_


ttd
�
|�
�
n
XdS(s�Return the port for a given network service.

    If port is an integer, it's returned as is. If it's a string, it's
    looked up using socket.getservbyname(). If there's no matching
    service, util.Abort is raised.
    s+no port number associated with service '%s'N(R�
R
tsockett
getservbynameR�RkR(
tport((s4/usr/lib64/python2.7/site-packages/mercurial/util.pytgetport�s






R�tyesttruetonR�R�tnotfalsetoffR�c

Cstj
|j�d
�S(sLParse s into a boolean.

    If s is not a valid boolean, returns None.
    N(t	_booleansR�R�RW(
R
((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyt	parseboolst0123456789ABCDEFabcdefc
cs?|]5}
tD](}|
|t
t|
|d��
fV
q
qd
S(iN(t_hexdigtchrR�
(R�R�R�((s4/usr/lib64/python2.7/site-packages/mercurial/util.pys	<genexpr>s
c
Cs�|jd
�
}
t
|
�
dkr%|S|
d}x�|
dD]{}y|t|d |d7}Wq:tk
r


|d
|7}q:tk
r�


|tt|d d��
|d7}q:Xq:W|S(sQDecode HTTP/HTML % encoding.

    >>> _urlunquote('abc%20def')
    'abc def'
    R�
i
iii(R�RHt	_hextochrtKeyErrorR�
tunichrR�
(R
R�
titem((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyt_urlunquotes











-
turlcBsheZ
dZd
ZdZejd�
jZe	e	d�Z
d�Zd�Zd�Z
d�Zd	�ZRS(
s�Reliable URL parser.

    This parses URLs and provides attributes for the following
    components:

    <scheme>://<user>:<passwd>@<host>:<port>/<path>?<query>#<fragment>

    Missing components are set to None. The only exception is
    fragment, which is set to '' if present but empty.

    If parsefragment is False, fragment is included in query. If
    parsequery is False, query is included in path. If both are
    False, both fragment and query are included in path.

    See http://www.ietf.org/rfc/rfc2396.txt for more information.

    Note that for backward compatibility reasons, bundle URLs do not
    take host names. That means 'bundle://../' has a path of '../'.

    Examples:

    >>> url('http://www.ietf.org/rfc/rfc2396.txt')
    <url scheme: 'http', host: 'www.ietf.org', path: 'rfc/rfc2396.txt'>
    >>> url('ssh://[::1]:2200//home/joe/repo')
    <url scheme: 'ssh', host: '[::1]', port: '2200', path: '/home/joe/repo'>
    >>> url('file:///home/joe/repo')
    <url scheme: 'file', path: '/home/joe/repo'>
    >>> url('file:///c:/temp/foo/')
    <url scheme: 'file', path: 'c:/temp/foo/'>
    >>> url('bundle:foo')
    <url scheme: 'bundle', path: 'foo'>
    >>> url('bundle://../foo')
    <url scheme: 'bundle', path: '../foo'>
    >>> url(r'c:\foo\bar')
    <url path: 'c:\\foo\\bar'>
    >>> url(r'\\blah\blah\blah')
    <url path: '\\\\blah\\blah\\blah'>
    >>> url(r'\\blah\blah\blah#baz')
    <url path: '\\\\blah\\blah\\blah', fragment: 'baz'>

    Authentication credentials:

    >>> url('ssh://joe:xyz@x/repo')
    <url scheme: 'ssh', user: 'joe', passwd: 'xyz', host: 'x', path: 'repo'>
    >>> url('ssh://joe@x/repo')
    <url scheme: 'ssh', user: 'joe', host: 'x', path: 'repo'>

    Query strings and fragments:

    >>> url('http://host/a?b#c')
    <url scheme: 'http', host: 'host', path: 'a', query: 'b', fragment: 'c'>
    >>> url('http://host/a?b#c', parsequery=False, parsefragment=False)
    <url scheme: 'http', host: 'host', path: 'a?b#c'>
    s!~*'()+s	/!~*'()+:s^[a-zA-Z0-9+.\-]+:cCsd|_
|_|_|_d|_|_|_|_t	|_
d
|_|
|_|r�d|
kr�|
j
dd�\}
|_|
s�d}
q�nt|
�
s�|
jd�
r�|
|_dS|
jd�
r	
d|_
|
d}
|
jd�
r�|
d	}
n|
|_dS|j|
�
rR
|
j
d
d�}|drR
|\|_
}
t|_
qR
n|
sw
d}
|j
r�d
|_dSnF|j
r�
|
|_dS|r�
d|
kr�
|
j
dd�\}
|_|
s�
d}
n|js�
d|_q�
n|
r{|
jd�
r{|
d	j
d
d�}t|�
dkr0|\|_}
n|d|_d}
|js{d|_|
rxt|
�
rxd
|
}
qxq{n|jr�d|jkr�|jjdd�\|_|_d
|jkr�|jj
d
d�\|_|_n|js�d|_q�n|jr�d
|jkr�|jjd�
o8|jjd�
r�|j|_|jjd
d�\|_|_|js�d|_q�n|jr�|j
dkr�|jdkr�ttd�
�
�
n|
|_xBdD]:}t||�}|dk	r�t||t|�
�
q�q�WdS(NRt
#i
s\\sbundle:tbundleis//it
:it
?R�R�
t
[t
]tfilet	localhosts	127.0.0.1s[::1]s(file:// URLs can only refer to localhostR�
tpasswdthostRR�tfragment(R4s	127.0.0.1s[::1](suserspasswdshostsportspathsfragment(RWtschemeR�
R5R6RR�tqueryR7Rt
_localpatht	_hostportt	_origpathR�thasdriveletterR{t_matchschemeR�RHtrsplitR6
RkRRRVR+(R7R�t
parsequeryt
parsefragmenttpartsR�R:((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyRCgs�

	
	
	



	

	





	







	
	
	
	



	
	






	
	

!

$
	

%

!
	


	




c
Cs]g}
xCdD];}t||�}|dk	r
|
jd	||f�

q
q
Wd
dj|
�
S(
NR8R�
R5R6RR�R9R7s%s: %rs<url %s>s, (sschemesuserspasswdshostsportspathsquerysfragment(RRWRDR�(R7tattrsR�R:((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyt__repr__�s







c

Csm|jrO|j
}
|jd
kr.d|
}
n|jrK|
d|j7}
n|
S|jd}
|jsw|jsw|jr�|
d7}
n]|jr�|j
s�|j
jd�
s�t|j
�
r�|
d7}
t|j
�
r�|
d7}
q�n|jr
|
t	j
|jd|j�

7}
n|jr;
|
dt	j
|jd|j�

7}
n|jsM
|jrZ
|
d7}
n|jr�
|jjd	�
o�
|jjd
�
s�
|
t	j
|j�
7}
q�
|
|j7}
n|j
r�
|
dt	j
|j
�
7}
n|jr�
|
d7}
n|j
r|
t	j
|j
d|j�

7}
n|jr4|
d|j7}
n|jdk	ri|
dt	j
|jd|j�

7}
n|
S(
soJoin the URL's components back into a URL string.

        Examples:

        >>> str(url('http://user:pw@host:80/c:/bob?fo:oo#ba:ar'))
        'http://user:pw@host:80/c:/bob?fo:oo#ba:ar'
        >>> str(url('http://user:pw@host:80/?foo=bar&baz=42'))
        'http://user:pw@host:80/?foo=bar&baz=42'
        >>> str(url('http://user:pw@host:80/?foo=bar%3dbaz'))
        'http://user:pw@host:80/?foo=bar%3dbaz'
        >>> str(url('ssh://user:pw@[::1]:2200//home/joe#'))
        'ssh://user:pw@[::1]:2200//home/joe#'
        >>> str(url('http://localhost:80//'))
        'http://localhost:80//'
        >>> str(url('http://localhost:80/'))
        'http://localhost:80/'
        >>> str(url('http://localhost:80'))
        'http://localhost:80/'
        >>> str(url('bundle:foo'))
        'bundle:foo'
        >>> str(url('bundle://../foo'))
        'bundle:../foo'
        >>> str(url('path'))
        'path'
        >>> str(url('file:///tmp/foo/bar'))
        'file:///tmp/foo/bar'
        >>> str(url('file:///c:/tmp/foo/bar'))
        'file:///c:/tmp/foo/bar'
        >>> print url(r'bundle:foo\bar')
        bundle:foo\bar
        R.sbundle:R-R/s//R�tsafeR�
R1R2R0N(R:R�R8R7R�
R5R6R{R=turllibtquotet
_safecharsR6
Rt_safepcharsR9RW(R7R
((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyt__str__�sH 	
	



	






%





	
"
	
&



	
$

	

	


	"
	

&
c
Cs�|j|j
}
}z"d\|_|_
t|�
}Wd|
||_|_
X|js_|dfS|d||jf|j|j
p�d
ffS(NR(NN(R�
R5RWR�R6(R7R�
R5R
((s4/usr/lib64/python2.7/site-packages/mercurial/util.pytauthinfos




	


c

Cs_|jr|jd
krt
St|j�
r/t
S|jjd�
rEt
S|jjd�
r[t
StS(NR3s\\R�(R8RR=R�R{R�(
R7((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyR�)s








c
Cs�|jd
ks|jdkr�|j
p*d}
t|j�
rS|jd|j
}
n2|jdk	r�|j
r�t|
�
r�d|
}
n|
S|jS(NR3R.R�(R8R�R=R;R6RWR<(R7R�((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyR�4s









(R<R=RLRHRIR
R
tmatchR>RRCRDRJRKR�R�(((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyR,+s6

^			K		c

Cstt
|�
j�
S(
N(R�R,R8(
R�((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyt	hasschemeAs
c

Cs*|o)|d
d!dko)|dd
!j�S(Ni
iR/i(
tisalpha(
R�((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyR=Ds
c

Cst|d
t
dt
�
j�S(NR@RA(R,R�R�(
R�((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyturllocalpathGs
c

CsPtj
|�
}|jd
�
s-|jd�
rLtjtd�
|f
�
�
ndS(s\
check if a path / url is a potentially unsafe ssh exploit (SEC)

    This is a sanity check for ssh urls. ssh will parse the first item as
    an option; e.g. ssh://-oProxyCommand=curl${IFS}bad.server|sh/path.
    Let's prevent these potentially exploited urls entirely and warn the
    user.

    Raises an error.Abort when the url is unsafe.
    sssh://-ssvn+ssh://-spotentially unsafe url: %rN(RFtunquoteR{R�RkR(
R�((s4/usr/lib64/python2.7/site-packages/mercurial/util.pytchecksafesshJs



c

Cs+t|�
}|j
r!d
|_
nt|�
S(s$hide user credential in a url strings***(R,R5R�(
t
u((s4/usr/lib64/python2.7/site-packages/mercurial/util.pythidepasswordYs
	

c

Cs&t|�
}d
|_|_t|�
S(s7remove all authentication information from a url stringN(R,RWR�
R5R�(
RR((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyt
removeauth`s

c

Cs'y|j�SWnt
k
r"


tSXdS(
N(tisattyR�R�(
R4
((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyRUfs




g@�@s%.0f ss%.1f ss%.2f ss%.3f sg����MbP?s%.1f mss%.2f mss%.3f msg���ư>s%.1f uss%.2f uss%.3f usg��&�.>s%.1f nss%.2f nss%.3f nsc
s�f
d
�}
|
S(s�Report the execution time of a function call to stderr.

    During development, use as a decorator when you need to measure
    the cost of a function, e.g. as follows:

    @util.timed
    def foo(a, b, c):
        pass
    c	s�tj�}d
}t
dc|7<z�||
�SWdtj�|}t
dc|8<tjjddt
d�jt|�
f�

XdS(Niis	%s%s: %s
R�
(Rp
t_timenestingR
R'RfR<t	timecount(R1R�R�
R�
telapsed(
R/(s4/usr/lib64/python2.7/site-packages/mercurial/util.pyR�
�s








((R/R�
((
R/s4/usr/lib64/python2.7/site-packages/mercurial/util.pyttimed~s(�RLti18nRR�R�R�
tcollectionsR
R
R�R
RbR�RdRp
Rq
R�
R�
RR�RRFRPtwindowsRjRt	cachestatt	checkexect	checklinkR�texecutablepathtexpandglobsRlR�R�
tgetusertgroupmemberst	groupnamet
hidewindowtisexectisownerR�t	lookupregRQ
R0
R&
R"
t
openhardlinksR�tparsepatchoutputR�tpopenR
R�trealpathRN
t
samedevicetsamefiletsamestatt	setbinarytsetflagstsetsignalhandlert
shellquoteRR�tsshargsRRt
statisexect
statislinkt	termwidthRtumaskRot
unlinkpathtusernametobjectRRRR	Rt	NameErrorRRR RWR�R%R(R&R+R�
R�
R4R5R;R�R>RNROR[RxRyR~R�R�RkR�R�R�R�R�R�R�RiR�R�R�R�R�R

tcheckosfilenameR
R
R
R
R
R
R,R!
R(
R.
R5
R7
R�R<
RE
RF
RS
RX
RY
R[
R]
R^
R?
Ry
R�
R�
R�
R�
R�
R�
R�
R�
R�
R�
R�
t	bytecountR�
R�
R�
R�
R�
R�
RR
RRRRR"R#R%R�R'R+R,RMR=RORQRSRTRURWRVRY(((s4/usr/lib64/python2.7/site-packages/mercurial/util.pyt<module>s�

0
H
H
$
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	

	
	
	
	
	
	
	
			







		























	




	





			%


							
		9		


	'
			
	
			







	.	"			'&			0	
)M	L		
			









		n
				#



	
	&


	
	

	�