�`^c@s�dZd
dl
Z
d
dlZd
dlZd
dlZd
dlZd
dlZd
dlZd
dlZd
dl	Z	d
dl
Z
yd
dlZeZWne
k
r�


d
dlZn
Xyd
dlZWn#e
k
r�

ejZd�ZnXd�Zd�Zd�ZdZejd�Zd	dd
��YZd�Zd�Zd
dd��YZd�Zd�Zd�Zd�Zddd��YZd�Zdd�Z!e"dkr�e!�
ndS(s�program/module to trace Python program or function execution

Sample use, command line:
  trace.py -c -f counts --ignore-dir '$prefix' spam.py eggs
  trace.py -t --ignore-dir '$prefix' spam.py eggs
  trace.py --trackcalls spam.py eggs

Sample use, programmatically
  import sys

  # create a Trace object, telling it what to ignore, and whether to
  # do tracing or line-counting or both.
  tracer = trace.Trace(ignoredirs=[sys.prefix, sys.exec_prefix,], trace=0,
                    count=1)
  # run the new command using the given tracer
  tracer.run('main()')
  # make a report, placing output in /tmp
  r = tracer.results()
  r.write_results(show_missing=True, coverdir="/tmp")
i�NcCstj
d�
dS(
N(tsystsettracetNone(((s/sys/lib/python2.7/trace.pyt_unsettraceHs
c

Cstj
|�
tj
|�
dS(
N(t	threadingR
R(
tfunc((s/sys/lib/python2.7/trace.pyt	_settraceKs


cCstj
d�
tj
d�
dS(
N(RR
RR(((s/sys/lib/python2.7/trace.pyROs


c

Cs|jd
t
jd�
dS(Ns	Usage: %s [OPTIONS] <file> [ARGS]

Meta-options:
--help                Display this help then exit.
--version             Output version information then exit.

Otherwise, exactly one of the following three options must be given:
-t, --trace           Print each line to sys.stdout before it is executed.
-c, --count           Count the number of times each line is executed
                      and write the counts to <module>.cover for each
                      module executed, in the module's directory.
                      See also `--coverdir', `--file', `--no-report' below.
-l, --listfuncs       Keep track of which functions are executed at least
                      once and write the results to sys.stdout after the
                      program exits.
-T, --trackcalls      Keep track of caller/called pairs and write the
                      results to sys.stdout after the program exits.
-r, --report          Generate a report from a counts file; do not execute
                      any code.  `--file' must specify the results file to
                      read, which must have been created in a previous run
                      with `--count --file=FILE'.

Modifiers:
-f, --file=<file>     File to accumulate counts over several runs.
-R, --no-report       Do not generate the coverage report files.
                      Useful if you want to accumulate over several runs.
-C, --coverdir=<dir>  Directory where the report files.  The coverage
                      report for <package>.<module> is written to file
                      <dir>/<package>/<module>.cover.
-m, --missing         Annotate executable lines that were not executed
                      with '>>>>>> '.
-s, --summary         Write a brief summary on stdout for each file.
                      (Can only be used with --count or --report.)
-g, --timing          Prefix each line with the time since the program started.
                      Only used while tracing.

Filters, may be repeated multiple times:
--ignore-module=<mod> Ignore the given module(s) and its submodules
                      (if it is a package).  Accepts comma separated
                      list of module names
--ignore-dir=<dir>    Ignore files in the given directory (multiple
                      directories can be joined by os.pathsep).
i(twriteRtargv(
toutfile((s/sys/lib/python2.7/trace.pytusageSs
*s#pragma NO COVERs^\s*(#.*)?$tIgnorecBs eZ
ddd�Zd
�ZRS(cCsM|
p	g|_|pg|_
ttjj|j
�|_
i
d
d6|_dS(Ni
s<string>(t_modst_dirstmaptostpathtnormpatht_ignore(tselftmodulestdirs((s/sys/lib/python2.7/trace.pyt__init__�s


cCs�||jkr|j|Sxk|j
D]`}||krGd
|j|<d
St|�}||| kr$||dkr$d
|j|<d
Sq$W|
dkr�d
|j|<d
Sx8|jD]-}|
j|tj�r�d
|j|<d
Sq�Wd|j|<dS(Ni
t
.i(RRtlenRR
t
startswithRtsep(Rtfilenamet
modulenametmodt
nt
d((s/sys/lib/python2.7/trace.pytnames�s&





 









N(t__name__t
__module__RRR (((s/sys/lib/python2.7/trace.pyR�s
c
Cs.tj
j|�}
tj
j|
�\}}|S(
s-Return a plausible module name for the patch.(RRtbasenametsplitext(RtbaseRtext((s/sys/lib/python2.7/trace.pytmodname�s

c
Cs 
tj
j|�}
d
}xotj
D]d}tj
j|�}|
j|�r"|
t|�tjkr"t|�t|�kr�|}q�q"q"W|r�|t|�d}n|}tj
j|�\}}|jtjd�}tj	r�jtj	d�}ntj
j
|�\}}|jd�S(s,Return a plausible module name for the path.ti
R(RRtnormcaseRRRRt
splitdrivetreplacetaltsepR$tlstrip(RtcomparepathtlongesttdirR%tdriveRR&((s/sys/lib/python2.7/trace.pytfullmodname�s 



(




	


tCoverageResultscBsDeZ
dddddd�Zd
�Zeedd�Zd�ZRS(cCsA
|
|_|jdkr$i|_n|jj�|_||_|jdkrZi|_n|jj�|_||_|jdkr�i|_n|jj�|_||_||_|jr=
yDtj	t
|jd
��\}
}}|j|j|
||��
Wq=
t
ttfk
r9

}
tjd|j|fIJq=
XndS(NtrbsSkipping counts file %r: %s(tcountsRtcopytcountertcalledfuncstcallerstinfileR	tpickletloadtopentupdatet	__class__tIOErrortEOFErrort
ValueErrorRtstderr(RR5R8R:R9R	terr((s/sys/lib/python2.7/trace.pyR�s*	



	



	



	
	
	$
 



c	Cs�|j}|j
}|j}|
j}|
j
}|
j}x2|j�D]$}|j|d
�||||<qCWx|j�D]}d||<qxWx|j�D]}d||<q�WdS(s.Merge in the data from another CoverageResultsii
N(R5R8R9tkeystget(	RtotherR5R8R9tother_countstother_calledfuncst
other_callerstkey((s/sys/lib/python2.7/trace.pyR>�s	
	
	
	
	
	
"

cCs�|jrWHd
GH|jj
�}|j�
x,|D]!\}}}d|||fGHq/Wn|jr
HdGH|jj
�}|j�
d}}	x�|D]�\\}
}}\}
}}|
|kr�HdG|
GdGH|
}d}	n|
|
kr

|	|
kr

dG|
GH|
}	nd||||fGHq�Wni}xN|jj
�D]=\}}|j|i�}||<|j||f||<q3
Wi}x^
|j�D]P
\}}|dkr�q�n|jd	�r�q�n|jd�r�|d }n|dkrt
jjt
jj
|��}t|�}n4|}t
jj|�s7t
j|�
nt|�}|
rXt|�}ni}tj|�}t
jj||d
�}|j||||�\}}|r�|r�d||}||||f||<q�q�W|r9|r9|j
�}|j�
dGHx4|D])}||\}}}}d||GHq	Wn|jr�y5tj|j|j|jft|jd�d�
Wq�tk
r�
}
tjd|IJq�XndS(s!
        @param coverdir
        sfunctions called:s*filename: %s, modulename: %s, funcname: %sscalling relationships:R(s***s  -->s    %s.%s -> %s.%ss<string>s	<doctest s.pycs.pyoi�s.coveridslines   cov%   module   (path)s%5d   %3d%%   %s   (%s)twbi
s"Can't save counts files because %sN(s.pycs.pyo(R8REtsortR9R5RFt	iteritemsRtendswithRRRtdirnametabspathR'texiststmakedirsR2tfind_executable_linenost	linecachetgetlinestjointwrite_results_fileR	R;tdumpR=R@RRC(Rtshow_missingtsummarytcoverdirtcallsRRtfuncnametlastfilet	lastcfiletpfiletpmodtpfunctcfiletcmodtcfunctper_filetlinenot	lines_hittsumstcountR0tlnotabtsourcet	coverpathtn_hitstn_linestpercenttmodst
mRD((s/sys/lib/python2.7/trace.pyt
write_results

s�	








	








%






	

	
	



























	



cCs<
yt|
d
�}Wn+t
k
r@
}
tjd|
|fIJd	SXd}d}x�t|�D]�\}	}
|	d}||kr�|jd||�
|d7}|d7}nbtj|
�r�|jd�
nC||kr�||	kr�jd�
|d7}n
|jd�
|j||	j	d��
qZW|j
�
||fS(
s'Return a coverage results file in path.t
ws2trace: Could not open %r for writing: %s- skippingii
s%5d: s       s>>>>>> i(ii(R=R@RRCt	enumerateRtrx_blanktmatchtPRAGMA_NOCOVERt
expandtabstclose(RRtlinesRlRiR	RDRpRot
itlineRh((s/sys/lib/python2.7/trace.pyRXe
s.

























N(	R!R"RRR>tTruetFalseRtRX(((s/sys/lib/python2.7/trace.pyR3�s

	
	[cCsCi}x6tj
|�D]%\}}||
krd
||<qqW|S(s:Return dict where keys are lines in the line number table.i
(tdistfindlinestarts(tcodetstrstlinenost
_Rh((s/sys/lib/python2.7/trace.pytfind_lines_from_code�s


cCsOt||
�}x9|j
D].}tj|�r|jt||
��
qqW|S(
s<Return lineno dict for all code objects reachable from code.(R�t	co_conststinspecttiscodeR>t
find_lines(R�R�R�t
c((s/sys/lib/python2.7/trace.pyR��s


c
Cs�i}
tj
}t|�}x�tj|j�D]\}}}}}|tjkr�|tj
kr�|\}	}
|\}}x(t|	|d
�D]}
d
|
|
<q�Wq�n|}q.W|j�
|
S(s�Return a dict of possible docstring positions.

    The dict maps line numbers to strings.  There is an entry for
    line that contains only a string or a part of a triple-quoted
    string.
    i
(	ttokentINDENTR=ttokenizetgenerate_tokenstreadlinetSTRINGtrangeR{(RRt
prev_ttypet
ftttypettstrtstarttendR~tslinetscoltelinetecolR}((s/sys/lib/python2.7/trace.pytfind_strings�s	

(










c
Csryt|d
�j
�}
Wn+tk
rF
}
tjd||fIJiSXt|
|d�}t|�}t||�S(sAReturn dict where keys are line numbers in the line number table.trUs%Not printing coverage data for %r: %stexec(R=treadR@RRCtcompileR�R�(RtprogRDR�R�((s/sys/lib/python2.7/trace.pyRT�s









tTracec
Bs�eZ
ddd
d
dddded�Zd�Zddd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Zd�Z
d�Zd
�ZRS(i
ic

Cs-
||_||_
t||�|_i|_i|_i|_d
|_||_i|_	i|_
i|_d|_
|	r�tj�|_
n|r�|j|_n�|r�|j|_nr|r�|
r�|j|_|j|_nK|r�j|_|j|_n*|
r 
|j|_|j|_n	d|_dS(sx
        @param count true iff it should count number of times each
                     line is executed
        @param trace true iff it should print out each line that is
                     being counted
        @param countfuncs true iff it should just output a list of
                     (filename, modulename, funcname,) for functions
                     that were called at least once;  This overrides
                     `count' and `trace'
        @param ignoremods a list of the names of modules to ignore
        @param ignoredirs a list of the names of directories to ignore
                     all of the (recursive) contents of
        @param infile file from which to read stored counts to be
                     added into the results
        @param outfile file in which to write the results
        @param timing true iff timing information be displayed
        ii
N(R:R	RtignoreR5tblabbedtpathtobasenamet	donothingttracet_calledfuncst_callerst
_caller_cacheRt
start_timettimetglobaltrace_trackcallerstglobaltracetglobaltrace_countfuncstglobaltrace_lttlocaltrace_trace_and_countt
localtracetlocaltrace_tracetlocaltrace_count(
RRkR�t
countfuncstcountcallerst
ignoremodst
ignoredirsR:R	ttiming((s/sys/lib/python2.7/trace.pyR�s8	
	

	
	
	
	
	
	
	
	
	














cCs,d
dl}|j
}|j|
||�
dS(Ni�(t__main__t__dict__trunctx(RtcmdR�tdict((s/sys/lib/python2.7/trace.pytrun�s

	
cBsl|dkri}n|dkr*i}n|j
sCe|j�
nz|
||UWd|j
sge�
nXdS(
N(RR�RR�R(RR�tglobalstlocals((s/sys/lib/python2.7/trace.pyR��s
	
	
	


	
cOsVd}|j
s"tj|j�
nz|
||�}Wd|j
sQtjd�
nX|S(
N(RR�RR
R�(RRtargstkwtresult((s/sys/lib/python2.7/trace.pytrunfuncs

	


	

c
Cs�|
j}|j
}|r't|�}nd}|j}d}||jkrq|j|dk	rr
|j|}qr
n

d|j|<gtj|�D]}tj	|�r�|^q�}t
|�d
krr
gtj|d�D]}	t|	t�r�|	^q�}
t
|
�d
krr
gtj|
d�D]}t
|d�r
|^q
}t
|�d
kro
|dj}||j|<qo
qr
n|dk	r�d||f}n|||fS(Ni
it	__bases__s%s.%s(tf_codetco_filenameR'Rtco_nameR�tgct
get_referrersR�t
isfunctionRt
isinstanceR�thasattrR!(
RtframeR�RRR^tclsnameR�tfuncsRtdictsR�tclasses((s/sys/lib/python2.7/trace.pytfile_module_function_ofs2
	
	

	














cCsG|d
krC|j|
�}|j|
j
�}d|j||f<ndS(skHandler for call events.

        Adds information about who called who to the self._callers dict.
        tcalli
N(R�tf_backR�(RR�twhytargt	this_functparent_func((s/sys/lib/python2.7/trace.pyR�:s

cCs/|d
kr+|j|
�}d|j
|<ndS(soHandler for call events.

        Adds (filename, modulename, funcname) to the self._calledfuncs dict.
        R�i
N(R�R�(RR�R�R�R�((s/sys/lib/python2.7/trace.pyR�Es

cCs�|d
kr�|
j}|
j
jdd�}|r�t|�}|dk	r�|jj||�}|s�|jr�d||jfGHn|j	Sq�q�dSndS(s�Handler for call events.

        If the code block being entered is to be ignored, returns `None',
        else returns self.localtrace.
        R�t__file__s! --- modulename: %s, funcname: %sN(
R�t	f_globalsRFRR'R�R R�R�R�(RR�R�R�R�RRt	ignore_it((s/sys/lib/python2.7/trace.pyR�Ns
	





	



cCs�|d
kr�|
jj
}|
j}||f}|jj|d�d|j|<|jrndtj�|jGntjj	|�}d||t
j||�fGn|jS(NR~ii
s%.2fs
%s(%d): %s(
R�R�tf_linenoR5RFR�R�RRR#RUtgetlineR�(RR�R�R�RRhRKtbname((s/sys/lib/python2.7/trace.pyR�es

	

 	


	

cCs{|d
krt|
jj
}|
j}|jrBdtj�|jGntjj|�}d||tj	||�fGn|j
S(NR~s%.2fs
%s(%d): %s(R�R�R�R�R�RRR#RUR�R�(RR�R�R�RRhR�((s/sys/lib/python2.7/trace.pyR�ts

		


	

cCsW|d
krP|
jj
}|
j}||f}|jj|d�d|j|<n|jS(NR~ii
(R�R�R�R5RFR�(RR�R�R�RRhRK((s/sys/lib/python2.7/trace.pyR��s


	

#
c


Cs1t|j
d
|jd|jd|jd|j�S(NR:R	R8R9(R3R5R:R	R�R�(
R((s/sys/lib/python2.7/trace.pytresults�s

	
	
((N(R!R"RR�RR�R�R�R�R�R�R�R�R�R�R�(((s/sys/lib/python2.7/trace.pyR��s


1			)						
	c

Cs2tj
jd
tjd|f�
tjd�
dS(Ns%s: %s
ii
(RRCRRtexit(
tmsg((s/sys/lib/python2.7/trace.pyt	_err_exit�s
!
c
Cs:d
dl}
|dkr$tj}nyP|
j|dddddddd	d
ddd
dddddg�\}}Wn_|
jk
r�
}
tjjdtjd|f�
tjjdtjd�
tjd�
n
Xd}d}d}d}d}	d}
g}g}d}
d}t}t}t}x�D]�}}|dkr`
t	tj
�
tjd�
n|dkr�tj
jd�
tjd�
n|dks�|dkr�t}q+
n|dks�|dkr�t}q+
n|dks�dkr�}q+
n|dks|d krd}q+
n|d!ks4|d"kr@d}q+
n|d#ksX|d$krdd}q+
n|d%ks||d&kr�d}q+
n|d'ks�|d(kr�|}	q+
n|d)ks�|d*kr�d}
q+
n|d+ks�d,kr�}
q+
n|d-ks|d.krd}q+
n|d/krWx*|jd0�D]}|j
|j��
q4Wq+
n|d1kr+
x�|jtj�D]�}tjj|�}|jd2tjjtjd3d4tjd5 ��}|jd6tjjtjd3d4tjd5 ��}tjj|�}|j
|�
qvWq+
q+
q+
W|r>|s1|r>td7�
n|pY|pY|pY|pY|sitd8�
n|r�|r�td9�
n|r�|	r�td:�
n|r�t|�dkr�td;�
n|r�d<|	d=|	�}|j|
d
|d>|
�
n>
|t_|d}tjj|�dtjd<t||d?|d@|dA|dB|d<|	d=|	d|�}yft|��}t|j �|dC�}WdQXi|dD6dEdF6ddG6ddH6}|j!|||�
Wn>t"k
r�
tdItjd|f�
nt#k
r


n
X|j$�}|s6|j|
d
|d>|
�
ndS(JNi�i
stcrRf:d:msC:lTgthelptversionR�Rktreports	no-reportR[sfile=tmissingsignore-module=signore-dir=s	coverdir=t	listfuncst
trackcallsR�s%s: %s
is%Try `%s --help' for more information
s--helps	--versions
trace 2.0
s-Ts--trackcallss-ls--listfuncss-gs--timings-ts--traces-cs--counts-rs--reports-Rs--no-reports-fs--files-ms	--missings-Cs
--coverdirs-ss	--summarys--ignore-modulet
,s--ignore-dirs$prefixtlibtpythonis$exec_prefixs8cannot specify both --listfuncs and (--trace or --count)sLmust specify one of --trace, --count, --report, --listfuncs, or --trackcallss,cannot specify both --report and --no-reports--report requires a --filesmissing name of file to runR:R	R\R�R�R�R�R�R�R�R!t__package__t
__cached__sCannot run file %r because: %s(%tgetoptRRRterrorRCRR�R�R
tstdoutRtsplittappendtstripRtpathsepRt
expandvarsR+RWtprefixR�texec_prefixRR�RR3RtR�R=R�R�R�R@t
SystemExitR�(RR�toptst	prog_argvR�R�RkR�t	no_reporttcounts_fileR�tignore_modulestignore_dirsR\R[R�R�R�topttvalRt
sR�tprognamet
ttfpR�tglobsRD((s/sys/lib/python2.7/trace.pytmain�s�





	




!















































	


	

















	



















R�((((#t__doc__RURtreRR�R�R�R�R�R�tcPickleR;tImportErrorRR
RRR
RyR�RwRR'R2R3R�R�R�RTR�R�RR

R!(((s/sys/lib/python2.7/trace.pyt<module>1sL



















	
			-5		�
			��