def main():

    # Do the trace, remember the values for later
    pycallgraph.start_trace()
    import HTMLParser
    pycallgraph.stop_trace()

    # Set the edge colour to black for all examples
    pycallgraph.settings['edge_colour'] = lambda a, b: 'black'

    # Default node colouring
    pycallgraph.make_dot_graph('colours-default.png')

    # Rainbow
    pycallgraph.settings['node_colour'] = rainbow
    pycallgraph.make_dot_graph('colours-rainbow.png')

    # Greyscale
    pycallgraph.settings['node_colour'] = greyscale
    pycallgraph.make_dot_graph('colours-greyscale.png')

    # Orange/Green
    pycallgraph.settings['node_colour'] = orange_green
    pycallgraph.make_dot_graph('colours-orange-green.png')

    # Random
    pycallgraph.settings['node_colour'] = rand
    pycallgraph.make_dot_graph('colours-random.png')

def filter_exclude():
    filter_func = pycallgraph.GlobbingFilter(exclude=['pycallgraph.*', \
        '*.secret_function'])
    pycallgraph.start_trace(filter_func=filter_func)
    banana = Banana()
    banana.eat()
    pycallgraph.make_dot_graph('filter-exclude.png')

 def run_profile(self, app, *args, **kwargs):
     pycallgraph = self.pycallgraph
     pycallgraph.start_trace(reset=True, filter_func=self._filter)
     try:
         return app(*args, **kwargs)
     finally:
         pycallgraph.stop_trace()

def filter_include():
    filter_func = pycallgraph.GlobbingFilter(include=['*.secret_function', \
        'Banana.__init__'])
    pycallgraph.start_trace(filter_func=filter_func)
    banana = Banana()
    banana.eat()
    pycallgraph.make_dot_graph('filter-include.png')

    def render (self, include=None, exclude=None, **kwargs): # {{{
        """
            Actually returns an image (as png), and will reset the trace if the
            include or exclude parameters are different.
        """
        
        inc = self.last_include
        exc = self.last_exclude

        if include or include == "":
            inc = include.split(',')

        if exclude or exclude == "":
            exc = exclude.split(',')

        if inc != self.last_include or exc != self.last_exclude:
            # New trace, resetting the old one.

            pycallgraph.stop_trace()
            pycallgraph.start_trace(filter_func = self.filter_func(inc, exc), reset=True)

        pycallgraph.make_dot_graph("." + self.image_file, stop=False)

        cherrypy.response.headers['Content-Type'] = "image/png"
        f = open("." + self.image_file, "r+b")
        return f.read()

 def callwrapper(*args, **kwargs):
     if not outfile: # allow deactivating
         return fn(*args, **kwargs)
     pycallgraph.start_trace()
     fn_output = fn(*args, **kwargs)
     pycallgraph.stop_trace()
     pycallgraph.make_dot_graph(outfile)
     return fn_output

def main():
    pycallgraph.settings['dont_exclude_anything'] = True
    import_list = ['pickle', 'htmllib']

    for imp in import_list:
        pycallgraph.start_trace()
        __import__(imp)
        pycallgraph.make_dot_graph('import-%s.png' % imp)

 def call_graph(fac, cmd='fac.query(1)'):
     import pycallgraph
     import Image
     iom = fac.hs.iom
     logmsg('Call Graph Command: '+cmd)
     callgraph_fpath = iom.get_temp_fpath('callgraph'+cmd+'.png')
     pycallgraph.start_trace()
     eval(cmd)
     pycallgraph.stop_trace()
     pycallgraph.make_dot_graph(callgraph_fpath)
     Image.open(callgraph_fpath).show()

def cuba():
    eqs = '''
    dv/dt = (ge+gi-(v+49*mV))/(20*ms) : volt
    dge/dt = -ge/(5*ms) : volt
    dgi/dt = -gi/(10*ms) : volt
    '''
    eqs = Equations(eqs)
    pycallgraph.start_trace(filter_func=ff)
    eqs.prepare()
    pycallgraph.stop_trace()
    pycallgraph.make_dot_graph('callgraphs/cuba-bigcallgraph-Equations.prepare.png')

def main():
    if PYCALLGRAPH:
        pycallgraph.start_trace()
        test_cetco()
        pycallgaph.make_dot_graph(os.path.join(os.path.dirname(__file__), 
            "..", "doc", "calcular_credito_disponible.png"))
    else:
        fechahora = time.localtime()
        fechahora = "%d%02d%02d%02d%02d%02d" % (fechahora.tm_year, 
                                                fechahora.tm_mon, 
                                                fechahora.tm_mday, 
                                                fechahora.tm_hour, 
                                                fechahora.tm_min, 
                                                fechahora.tm_sec)
        filestats = os.path.abspath(os.path.join(os.path.dirname(__file__), 
            "..", "doc", "credito_perf_%s.stats" % fechahora))
        #cProfile.run("test_cetco()", sort = 'cumulative')
        cProfile.run("test_cetco()", filestats, sort = 'cumulative')
        p = pstats.Stats(filestats)
        p.strip_dirs().sort_stats("time").print_stats("pclases", 10)
        p.strip_dirs().sort_stats("cumulative").print_stats("pclases", 10)

    def run(self):
        '''Main code runner for testing. To set a new test, update the self.callTest attribute in __init__(). 
        '''
        fp = environLocal.getTempFile('.png')
        gf = pycallgraph.GlobbingFilter(exclude=self.excludeList)
        # create instnace; will call setup routines
        ct = self.callTest()

        # start timer
        print('starting test')
        t = common.Timer()
        t.start()

        pycallgraph.start_trace(filter_func = gf)
        ct.testFocus() # run routine

        pycallgraph.stop_trace()
        pycallgraph.make_dot_graph(fp)

        print('elpased time: %s' % t)
        # open the completed file
        environLocal.launch('png', fp)

def callgraph():
	import pycallgraph
	l = prepare()
	l.reset()
	lx = l.lexicon
	gr = l.grammar
	prp = l.properties
	#Lexicon Compile
	pycallgraph.start_trace()
	lx.compile(prp, True)
	pycallgraph.make_dot_graph('lexicon_compile.png')
	#Grammar Compile
	pycallgraph.start_trace()
	gr.compile(True)
	pycallgraph.make_dot_graph('grammar_compile.png')
	#Read
	pycallgraph.start_trace()
	l.read(u"mi pona e ilo")
	pycallgraph.make_dot_graph('read.png')

    def run(self, runWithEnviron=False):
        '''Main code runner for testing. To set a new test, update the self.callTest attribute in __init__(). 
        '''
        suffix = '.svg'
        fmt = suffix[1:]
        _MOD = "test.timeGraphs.py"

        if runWithEnviron:
            from music21 import environment
            environLocal = environment.Environment(_MOD)
            fp = environLocal.getTempFile(suffix)
        # manually get a temporary file
        else:
            import tempfile
            import os
            import sys
            if os.name in ['nt'] or sys.platform.startswith('win'):
                platform = 'win'
            else:
                platform = 'other'
            
            tempdir = os.path.join(tempfile.gettempdir(), 'music21')
            if platform != 'win':
                fd, fp = tempfile.mkstemp(dir=tempdir, suffix=suffix)
                if isinstance(fd, int):
                # on MacOS, fd returns an int, like 3, when this is called
                # in some context (specifically, programmatically in a 
                # TestExternal class. the fp is still valid and works
                # TODO: this did not work on MacOS 10.6.8 w/ py 2.7
                    pass
                else:
                    fd.close() 
            else:
                tf = tempfile.NamedTemporaryFile(dir=tempdir, suffix=suffix)
                fp = tf.name
                tf.close()

 
        if self.includeList is not None:
            gf = pycallgraph.GlobbingFilter(include=self.includeList, exclude=self.excludeList)
        else:
            gf = pycallgraph.GlobbingFilter(exclude=self.excludeList)
        # create instance; will call setup routines
        ct = self.callTest()

        # start timer
        print('%s starting test' % _MOD)
        t = Timer()
        t.start()

        pycallgraph.start_trace(filter_func = gf)
        ct.testFocus() # run routine

        pycallgraph.stop_trace()
        pycallgraph.make_dot_graph(fp, format=fmt, tool='/usr/local/bin/dot')
        print('elapsed time: %s' % t)
        # open the completed file
        print('file path: ' + fp)
        try:
            environLocal = environment.Environment(_MOD)
            environLocal.launch(format, fp)
        except NameError:
            pass

 def wrapper(*args, **kwargs):
     pycallgraph.start_trace()
     func(*args, **kwargs)
     pycallgraph.save_dot('callgraph.log')
     pycallgraph.make_dot_graph('callgraph.png')

def main():
    pycallgraph.start_trace()
    banana = Banana()
    banana.eat()
    pycallgraph.make_dot_graph('basic.png')

 def __call__(self, *args, **kwargs):
     pycallgraph.start_trace(reset=False)
     return_value = self.func(*args, **kwargs)
     pycallgraph.stop_trace()
     return return_value

def filter_max_depth():
    filter_func = pycallgraph.GlobbingFilter(max_depth=1)
    pycallgraph.start_trace(filter_func=filter_func)
    banana = Banana()
    banana.eat()
    pycallgraph.make_dot_graph('filter-max-depth.png')

 def process_view(self, request, callback, callback_args, callback_kwargs):
     if settings.DEBUG and 'graph' in request.GET:
         filter_func = pycallgraph.GlobbingFilter(include=['*'],
                 exclude=['debug_toolbar.*', '*.debug.*'])
         pycallgraph.start_trace(filter_func=filter_func)

from brian import *
set_global_preferences(useweave=True)
import cuba_runopts
cuba_runopts.duration = 100 * ms
import pycallgraph
from cuba import *

cg_func = 'Connection.do_propagate'

def ff(pat):
    def f(call_stack, module_name, class_name, func_name, full_name):
        if not 'brian' in module_name: return False
        for n in call_stack + [full_name]:
            if pat in n:
                return True
        return False
    return f

def cuba(P, Pe, Pi, Ce, Ci, M, net):
    net.run(duration)

c = cubanetwork(4000)
pycallgraph.start_trace(filter_func=ff(cg_func))
cuba(*c)
pycallgraph.stop_trace()
pycallgraph.make_dot_graph('callgraphs/cuba-callgraph-' + cg_func + '.png')

 def start (self): # {{{
     self.started = True
     pycallgraph.start_trace(filter_func = self.filter_func())