pytracer.py

importsys
importinspect
fromcollectionsimportOrderedDict


classTracebackFancy:
def__init__(self, traceback):
self.t=traceback

defgetFrame(self):
returnFrameFancy(self.t.tb_frame)

defgetLineNumber(self):
returnself.t.tb_linenoifself.tisnotNoneelseNone

defgetNext(self):
returnTracebackFancy(self.t.tb_next)

def__str__(self):
ifself.tisNone:
return""
str_self="%s @ %s"% (self.getFrame().getName(), self.getLineNumber())
returnstr_self+"\n"+self.getNext().__str__()


classExceptionFancy:
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

defgetTraceback(self):
returnTracebackFancy(self.etraceback)

def__nonzero__(self):
return (
self.etracebackisnotNone
orself.etypeisnotNone
orself.evalueisnotNone
 )

defgetType(self):
returnstr(self.etype)

defgetValue(self):
returnself.evalue


classCodeFancy:
def__init__(self, code):
self.c=code

defgetArgCount(self):
returnself.c.co_argcountifself.cisnotNoneelse0

defgetFilename(self):
returnself.c.co_filenameifself.cisnotNoneelse""

defgetVariables(self):
returnself.c.co_varnamesifself.cisnotNoneelse []

defgetName(self):
returnself.c.co_nameifself.cisnotNoneelse""

defgetFileName(self):
returnself.c.co_filenameifself.cisnotNoneelse""


classArgsFancy:
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)
forarginargs:
ret=ret+ ("%s = %s"% (arg, args[arg]))
count=count+1
ifcount<size:
ret=ret+", "
ifvarargs:
ifsize>0:
ret=ret+" "
ret=ret+"varargs are "+str(varargs)
ifkwargs:
ifsize>0:
ret=ret+" "
ret=ret+"kwargs are "+str(kwargs)
returnret

defgetNumArgs(wantVarargs=False, wantKWArgs=False):
args, varargs, keywords, values=self.a
size=len(args)
ifvarargsandwantVarargs:
size=size+len(self.getVarArgs())
ifkeywordsandwantKWArgs:
size=size+len(self.getKWArgs())
returnsize

defgetArgs(self):
args, _, _, values=self.a
argWValues=OrderedDict()
forarginargs:
argWValues[arg] =values[arg]
returnargWValues

defgetVarArgs(self):
_, vargs, _, _=self.a
ifvargs:
returnself.f.f_locals[vargs]
return ()

defgetKWArgs(self):
_, _, kwargs, _=self.a
ifkwargs:
returnself.f.f_locals[kwargs]
return {}


classFrameFancy:
def__init__(self, frame):
self.f=frame

defgetCaller(self):
returnFrameFancy(self.f.f_back)

defgetLineNumber(self):
returnself.f.f_linenoifself.fisnotNoneelse0

defgetCodeInformation(self):
returnCodeFancy(self.f.f_code) ifself.fisnotNoneelseNone

defgetExceptionInfo(self):
returnExceptionFancy(self.f) ifself.fisnotNoneelseNone

defgetName(self):
returnself.getCodeInformation().getName() ifself.fisnotNoneelse""

defgetFileName(self):
returnself.getCodeInformation().getFileName() ifself.fisnotNoneelse""

defgetLocals(self):
returnself.f.f_localsifself.fisnotNoneelse {}

defgetArgumentInfo(self):
return (
ArgsFancy(self.f, inspect.getargvalues(self.f))
ifself.fisnotNone
elseNone
 )


classTracerClass:
defcallEvent(self, frame):
pass

deflineEvent(self, frame):
pass

defreturnEvent(self, frame, retval):
pass

defexceptionEvent(self, frame, exception, value, traceback):
pass

defcCallEvent(self, frame, cfunct):
pass

defcReturnEvent(self, frame, cfunct):
pass

defcExceptionEvent(self, frame, cfunct):
pass


tracer_impl=TracerClass()


defthe_tracer_entrypoint(frame, event, args):
iftracer_implisNone:
returnNone
ifevent=="call":
call_retval=tracer_impl.callEvent(FrameFancy(frame))
ifnotcall_retval:
returnNone
returnthe_tracer_entrypoint
elifevent=="line":
line_retval=tracer_impl.lineEvent(FrameFancy(frame))
ifnotline_retval:
returnNone
returnthe_tracer_entrypoint
elifevent=="return":
tracer_impl.returnEvent(FrameFancy(frame), args)
elifevent=="exception":
exty, exva, extb=args
exception_retval=tracer_impl.exceptionEvent(
FrameFancy(frame), ExceptionFancy(extb, exty, exva)
 )
ifnotexception_retval:
returnNone
returnthe_tracer_entrypoint
elifevent=="c_call":
tracer_impl.cCallEvent(FrameFancy(frame), args)
elifevent=="c_return":
tracer_impl.cReturnEvent(FrameFancy(frame), args)
elifevent=="c_exception":
tracer_impl.cExceptionEvent(FrameFancy(frame), args)
returnNone


defenable(t=None):
globaltracer_impl
ift:
tracer_impl=t
sys.settrace(the_tracer_entrypoint)


defdisable():
sys.settrace(None)


classLoggingTracer:
defcallEvent(self, frame):
print(
"call "
+frame.getName()
+" from "
+frame.getCaller().getName()
+" @ "
+str(frame.getCaller().getLineNumber())
+" args are "
+str(frame.getArgumentInfo())
 )

deflineEvent(self, frame):
print(
"running "
+frame.getName()
+" @ "
+str(frame.getLineNumber())
+" locals are "
+str(frame.getLocals())
+" in "
+frame.getFileName()
 )

defreturnEvent(self, frame, retval):
print(
"return from "
+frame.getName()
+" value is "
+str(retval)
+" locals are "
+str(frame.getLocals())
 )

defexceptionEvent(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


classLLDBAwareTracer:
defcallEvent(self, frame):
ifframe.getName() =="<module>":
return
ifframe.getName() =="run_one_line":
print(
"call run_one_line(%s)"
% (frame.getArgumentInfo().getArgs()["input_string"])
 )
return
if"Python.framework"inframe.getFileName():
print("call into Python at "+frame.getName())
return
if (
frame.getName() =="__init__"
andframe.getCaller().getName() =="run_one_line"
andframe.getCaller().getLineNumber() ==101
 ):
returnFalse
strout="call "+frame.getName()
ifframe.getCaller().getFileName() =="":
strout+=" from LLDB - args are "
args=frame.getArgumentInfo().getArgs()
forarginargs:
ifarg=="dict"orarg=="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)

deflineEvent(self, frame):
ifframe.getName() =="<module>":
return
ifframe.getName() =="run_one_line":
print(
"running run_one_line(%s) @ %s"
% (
frame.getArgumentInfo().getArgs()["input_string"],
frame.getLineNumber(),
 )
 )
return
if"Python.framework"inframe.getFileName():
print(
"running into Python at "
+frame.getName()
+" @ "
+str(frame.getLineNumber())
 )
return
strout= (
"running "
+frame.getName()
+" @ "
+str(frame.getLineNumber())
+" locals are "
 )
ifframe.getCaller().getFileName() =="":
locals=frame.getLocals()
forlocalinlocals:
iflocal=="dict"orlocal=="internal_dict":
continue
strout=strout+ ("%s = %s "% (local, locals[local]))
else:
strout=strout+str(frame.getLocals())
strout=strout+" in "+frame.getFileName()
print(strout)

defreturnEvent(self, frame, retval):
ifframe.getName() =="<module>":
return
ifframe.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"inframe.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 "
 )
ifframe.getCaller().getFileName() =="":
locals=frame.getLocals()
forlocalinlocals:
iflocal=="dict"orlocal=="internal_dict":
continue
strout=strout+ ("%s = %s "% (local, locals[local]))
else:
strout=strout+str(frame.getLocals())
strout=strout+" in "+frame.getFileName()
print(strout)

defexceptionEvent(self, frame, exception):
ifframe.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()))


deff(x, y=None):
ifx>0:
return2+f(x-2)
return35


defg(x):
return1.134/x


defprint_keyword_args(**kwargs):
# kwargs is a dict of the keyword args passed to the function
forkey, valueinkwargs.items():
print("%s = %s"% (key, value))


deftotal(initial=5, *numbers, **keywords):
count=initial
fornumberinnumbers:
count+=number
forkeyinkeywords:
count+=keywords[key]
returncount


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()