trace
index
/usr/local/lib/python2.3/trace.py

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
 
Sample use, programmatically
   # create a Trace object, telling it what to ignore, and whether to
   # do tracing or line-counting or both.
   trace = trace.Trace(ignoredirs=[sys.prefix, sys.exec_prefix,], trace=0,
                       count=1)
   # run the new command using the given trace
   trace.run(coverage.globaltrace, 'main()')
   # make a report, telling it where you want output
   r = trace.results()
   r.write_results(show_missing=True)

 
Modules
       
cPickle
linecache
marshal
os
cPickle
re
sys
threading
token
tokenize
types

 
Classes
       
CoverageResults
Ignore
Trace

 
class CoverageResults
     Methods defined here:
__init__(self, counts=None, calledfuncs=None, infile=None, outfile=None)
update(self, other)
Merge in the data from another CoverageResults
write_results(self, show_missing=True, summary=False, coverdir=None)
@param coverdir
write_results_file(self, path, lines, lnotab, lines_hit)
Return a coverage results file in path.

 
class Ignore
     Methods defined here:
__init__(self, modules=None, dirs=None)
names(self, filename, modulename)

 
class Trace
     Methods defined here:
__init__(self, count=1, trace=1, countfuncs=0, ignoremods=(), ignoredirs=(), infile=None, outfile=None)
@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
globaltrace_countfuncs(self, frame, why, arg)
Handler for call events.
 
Adds (filename, modulename, funcname) to the self._calledfuncs dict.
globaltrace_lt(self, frame, why, arg)
Handler for call events.
 
If the code block being entered is to be ignored, returns `None',
else returns self.localtrace.
localtrace_count(self, frame, why, arg)
localtrace_trace(self, frame, why, arg)
localtrace_trace_and_count(self, frame, why, arg)
results(self)
run(self, cmd)
runctx(self, cmd, globals=None, locals=None)
runfunc(self, func, *args, **kw)

 
Functions
       
find_executable_linenos(filename)
Return dict where keys are line numbers in the line number table.
find_lines(code, strs)
Return lineno dict for all code objects reachable from code.
find_lines_from_code(code, strs)
Return dict where keys are lines in the line number table.
find_strings(filename)
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.
fullmodname(path)
Return a plausible module name for the path.
main(argv=None)
modname(path)
Return a plausible module name for the patch.
usage(outfile)

 
Data
        PRAGMA_NOCOVER = '#pragma NO COVER'
rx_blank = <_sre.SRE_Pattern object>