| import sys |
| import inspect |
| from collections import OrderedDict |
| |
| class TracebackFancy: |
| def __init__(self,traceback): |
| self.t = traceback |
| |
| def getFrame(self): |
| return FrameFancy(self.t.tb_frame) |
| |
| def getLineNumber(self): |
| return self.t.tb_lineno if self.t != None else None |
| |
| def getNext(self): |
| return TracebackFancy(self.t.tb_next) |
| |
| def __str__(self): |
| if self.t == None: |
| return "" |
| str_self = "%s @ %s" % (self.getFrame().getName(), self.getLineNumber()) |
| return str_self + "\n" + self.getNext().__str__() |
| |
| class ExceptionFancy: |
| def __init__(self,frame): |
| self.etraceback = frame.f_exc_traceback |
| self.etype = frame.exc_type |
| self.evalue = frame.f_exc_value |
| |
| def __init__(self,tb,ty,va): |
| self.etraceback = tb |
| self.etype = ty |
| self.evalue = va |
| |
| def getTraceback(self): |
| return TracebackFancy(self.etraceback) |
| |
| def __nonzero__(self): |
| return self.etraceback != None or self.etype != None or self.evalue != None |
| |
| def getType(self): |
| return str(self.etype) |
| |
| def getValue(self): |
| return self.evalue |
| |
| class CodeFancy: |
| def __init__(self,code): |
| self.c = code |
| |
| def getArgCount(self): |
| return self.c.co_argcount if self.c != None else 0 |
| |
| def getFilename(self): |
| return self.c.co_filename if self.c != None else "" |
| |
| def getVariables(self): |
| return self.c.co_varnames if self.c != None else [] |
| |
| def getName(self): |
| return self.c.co_name if self.c != None else "" |
| |
| def getFileName(self): |
| return self.c.co_filename if self.c != None else "" |
| |
| class ArgsFancy: |
| def __init__(self,frame,arginfo): |
| self.f = frame |
| self.a = arginfo |
| |
| def __str__(self): |
| args, varargs, kwargs = self.getArgs(), self.getVarArgs(), self.getKWArgs() |
| ret = "" |
| count = 0 |
| size = len(args) |
| for arg in args: |
| ret = ret + ("%s = %s" % (arg, args[arg])) |
| count = count + 1 |
| if count < size: |
| ret = ret + ", " |
| if varargs: |
| if size > 0: |
| ret = ret + " " |
| ret = ret + "varargs are " + str(varargs) |
| if kwargs: |
| if size > 0: |
| ret = ret + " " |
| ret = ret + "kwargs are " + str(kwargs) |
| return ret |
| |
| def getNumArgs(wantVarargs = False, wantKWArgs=False): |
| args, varargs, keywords, values = self.a |
| size = len(args) |
| if varargs and wantVarargs: |
| size = size+len(self.getVarArgs()) |
| if keywords and wantKWArgs: |
| size = size+len(self.getKWArgs()) |
| return size |
| |
| def getArgs(self): |
| args, _, _, values = self.a |
| argWValues = OrderedDict() |
| for arg in args: |
| argWValues[arg] = values[arg] |
| return argWValues |
| |
| def getVarArgs(self): |
| _, vargs, _, _ = self.a |
| if vargs: |
| return self.f.f_locals[vargs] |
| return () |
| |
| def getKWArgs(self): |
| _, _, kwargs, _ = self.a |
| if kwargs: |
| return self.f.f_locals[kwargs] |
| return {} |
| |
| class FrameFancy: |
| def __init__(self,frame): |
| self.f = frame |
| |
| def getCaller(self): |
| return FrameFancy(self.f.f_back) |
| |
| def getLineNumber(self): |
| return self.f.f_lineno if self.f != None else 0 |
| |
| def getCodeInformation(self): |
| return CodeFancy(self.f.f_code) if self.f != None else None |
| |
| def getExceptionInfo(self): |
| return ExceptionFancy(self.f) if self.f != None else None |
| |
| def getName(self): |
| return self.getCodeInformation().getName() if self.f != None else "" |
| |
| def getFileName(self): |
| return self.getCodeInformation().getFileName() if self.f != None else "" |
| |
| def getLocals(self): |
| return self.f.f_locals if self.f != None else {} |
| |
| def getArgumentInfo(self): |
| return ArgsFancy(self.f,inspect.getargvalues(self.f)) if self.f != None else None |
| |
| class TracerClass: |
| def callEvent(self,frame): |
| pass |
| |
| def lineEvent(self,frame): |
| pass |
| |
| def returnEvent(self,frame,retval): |
| pass |
| |
| def exceptionEvent(self,frame,exception,value,traceback): |
| pass |
| |
| def cCallEvent(self,frame,cfunct): |
| pass |
| |
| def cReturnEvent(self,frame,cfunct): |
| pass |
| |
| def cExceptionEvent(self,frame,cfunct): |
| pass |
| |
| tracer_impl = TracerClass() |
| |
| |
| def the_tracer_entrypoint(frame,event,args): |
| if tracer_impl == None: |
| return None |
| if event == "call": |
| call_retval = tracer_impl.callEvent(FrameFancy(frame)) |
| if call_retval == False: |
| return None |
| return the_tracer_entrypoint |
| elif event == "line": |
| line_retval = tracer_impl.lineEvent(FrameFancy(frame)) |
| if line_retval == False: |
| return None |
| return the_tracer_entrypoint |
| elif event == "return": |
| tracer_impl.returnEvent(FrameFancy(frame),args) |
| elif event == "exception": |
| exty,exva,extb = args |
| exception_retval = tracer_impl.exceptionEvent(FrameFancy(frame),ExceptionFancy(extb,exty,exva)) |
| if exception_retval == False: |
| return None |
| return the_tracer_entrypoint |
| elif event == "c_call": |
| tracer_impl.cCallEvent(FrameFancy(frame),args) |
| elif event == "c_return": |
| tracer_impl.cReturnEvent(FrameFancy(frame),args) |
| elif event == "c_exception": |
| tracer_impl.cExceptionEvent(FrameFancy(frame),args) |
| return None |
| |
| def enable(t=None): |
| global tracer_impl |
| if t: |
| tracer_impl = t |
| sys.settrace(the_tracer_entrypoint) |
| |
| def disable(): |
| sys.settrace(None) |
| |
| class LoggingTracer: |
| def callEvent(self,frame): |
| print "call " + frame.getName() + " from " + frame.getCaller().getName() + " @ " + str(frame.getCaller().getLineNumber()) + " args are " + str(frame.getArgumentInfo()) |
| |
| def lineEvent(self,frame): |
| print "running " + frame.getName() + " @ " + str(frame.getLineNumber()) + " locals are " + str(frame.getLocals()) + " in " + frame.getFileName() |
| |
| def returnEvent(self,frame,retval): |
| print "return from " + frame.getName() + " value is " + str(retval) + " locals are " + str(frame.getLocals()) |
| |
| def exceptionEvent(self,frame,exception): |
| print "exception %s %s raised from %s @ %s" % (exception.getType(), str(exception.getValue()), frame.getName(), frame.getLineNumber()) |
| print "tb: " + str(exception.getTraceback()) |
| |
| # the same functionality as LoggingTracer, but with a little more lldb-specific smarts |
| class LLDBAwareTracer: |
| def callEvent(self,frame): |
| if frame.getName() == "<module>": |
| return |
| if frame.getName() == "run_one_line": |
| print "call run_one_line(%s)" % (frame.getArgumentInfo().getArgs()["input_string"]) |
| return |
| if "Python.framework" in frame.getFileName(): |
| print "call into Python at " + frame.getName() |
| return |
| if frame.getName() == "__init__" and frame.getCaller().getName() == "run_one_line" and frame.getCaller().getLineNumber() == 101: |
| return False |
| strout = "call " + frame.getName() |
| if (frame.getCaller().getFileName() == ""): |
| strout += " from LLDB - args are " |
| args = frame.getArgumentInfo().getArgs() |
| for arg in args: |
| if arg == "dict" or arg == "internal_dict": |
| continue |
| strout = strout + ("%s = %s " % (arg,args[arg])) |
| else: |
| strout += " from " + frame.getCaller().getName() + " @ " + str(frame.getCaller().getLineNumber()) + " args are " + str(frame.getArgumentInfo()) |
| print strout |
| |
| def lineEvent(self,frame): |
| if frame.getName() == "<module>": |
| return |
| if frame.getName() == "run_one_line": |
| print "running run_one_line(%s) @ %s" % (frame.getArgumentInfo().getArgs()["input_string"],frame.getLineNumber()) |
| return |
| if "Python.framework" in frame.getFileName(): |
| print "running into Python at " + frame.getName() + " @ " + str(frame.getLineNumber()) |
| return |
| strout = "running " + frame.getName() + " @ " + str(frame.getLineNumber()) + " locals are " |
| if (frame.getCaller().getFileName() == ""): |
| locals = frame.getLocals() |
| for local in locals: |
| if local == "dict" or local == "internal_dict": |
| continue |
| strout = strout + ("%s = %s " % (local,locals[local])) |
| else: |
| strout = strout + str(frame.getLocals()) |
| strout = strout + " in " + frame.getFileName() |
| print strout |
| |
| def returnEvent(self,frame,retval): |
| if frame.getName() == "<module>": |
| return |
| if frame.getName() == "run_one_line": |
| print "return from run_one_line(%s) return value is %s" % (frame.getArgumentInfo().getArgs()["input_string"],retval) |
| return |
| if "Python.framework" in frame.getFileName(): |
| print "return from Python at " + frame.getName() + " return value is " + str(retval) |
| return |
| strout = "return from " + frame.getName() + " return value is " + str(retval) + " locals are " |
| if (frame.getCaller().getFileName() == ""): |
| locals = frame.getLocals() |
| for local in locals: |
| if local == "dict" or local == "internal_dict": |
| continue |
| strout = strout + ("%s = %s " % (local,locals[local])) |
| else: |
| strout = strout + str(frame.getLocals()) |
| strout = strout + " in " + frame.getFileName() |
| print strout |
| |
| def exceptionEvent(self,frame,exception): |
| if frame.getName() == "<module>": |
| return |
| print "exception %s %s raised from %s @ %s" % (exception.getType(), str(exception.getValue()), frame.getName(), frame.getLineNumber()) |
| print "tb: " + str(exception.getTraceback()) |
| |
| def f(x,y=None): |
| if x > 0: |
| return 2 + f(x-2) |
| return 35 |
| |
| def g(x): |
| return 1.134 / x |
| |
| def print_keyword_args(**kwargs): |
| # kwargs is a dict of the keyword args passed to the function |
| for key, value in kwargs.iteritems(): |
| print "%s = %s" % (key, value) |
| |
| def total(initial=5, *numbers, **keywords): |
| count = initial |
| for number in numbers: |
| count += number |
| for key in keywords: |
| count += keywords[key] |
| return count |
| |
| if __name__ == "__main__": |
| enable(LoggingTracer()) |
| f(5) |
| f(5,1) |
| print_keyword_args(first_name="John", last_name="Doe") |
| total(10, 1, 2, 3, vegetables=50, fruits=100) |
| try: |
| g(0) |
| except: |
| pass |
| disable() |
