Injecting code into a function

[George Sakkis]

Is there a general way of injecting code into a function, typically
before and/or after the existing code ? I know that for most purposes,
an OO solution, such as the template pattern, is a cleaner way to get
the same effect, but it's not always applicable (e.g. if you have no
control over the design and you are given a function to start with). In
particular, I want to get access to the function's locals() just before
it exits, i.e. something like:

def analyzeLocals(f unc):
func_locals = {}
def probeFunc():
# insert func's code here
sys._getframe(1 ).f_locals["func_local s"].update(locals( ))
probeFunc()
# func_locals now contains func's locals

So, how can I add func's code in probeFunc so that the injected code
(the update line here) is always called before the function exits ?
That is, don't just inject it lexically in the end of the function if
there are more than one exit points. I guess a solution will involve a
good deal bytecode hacking, on which i know very little; if there's a
link to a (relatively) simple HOWTO, it would be very useful.

Thanks,
George

[ajikoe]

use eval.
eval will accept any string and treat the string as a code.

pujo

[Steffen Glückselig]

Perhalps metaclasses are of interest to you. You can decorate existing
methods with additional behavior using metaclasses. A simple example
can be found at http://soiland.no/software/logmeta
I've gathered some more links under
http://www.gungfu.de/facts/wiki/fiel...etaProgramming
regards
Steffen

[Ron]

George Sakkis wrote:

Is there a general way of injecting code into a function, typically
before and/or after the existing code ? I know that for most purposes,
an OO solution, such as the template pattern, is a cleaner way to get
the same effect, but it's not always applicable (e.g. if you have no
control over the design and you are given a function to start with). In
particular, I want to get access to the function's locals() just before
it exits, i.e. something like:

def analyzeLocals(f unc):
func_locals = {}
def probeFunc():
# insert func's code here
sys._getframe(1 ).f_locals["func_local s"].update(locals( ))
probeFunc()
# func_locals now contains func's locals

So, how can I add func's code in probeFunc so that the injected code
(the update line here) is always called before the function exits ?
That is, don't just inject it lexically in the end of the function if
there are more than one exit points. I guess a solution will involve a
good deal bytecode hacking, on which i know very little; if there's a
link to a (relatively) simple HOWTO, it would be very useful.

Thanks,
George

I'd like to know this as well. :)

I think you will have to modify the function func in some way to get
locals when it exits.

def func():
x = 20
y = 40
func.locals = locals() # inserted line

func()
print func.locals
On a related note, I'd like to know how to import locals into a function.

Cheers,
Ron

[Paddy]

Try searching for: 'python aspect-oriented' as aspect oriented
programming is about modifying existing class-methods (not exactly
functions which is what you asked for).
You might also do a search for "AOP considered harmful"
http://www.infosun.fmi.uni-passau.de...op_harmful.pdf

The main point is that when you are reading the source you don't know
what the code is as it may be augmented by an "external" change.

[Steve Holden]

George Sakkis wrote:

Is there a general way of injecting code into a function, typically
before and/or after the existing code ? I know that for most purposes,
an OO solution, such as the template pattern, is a cleaner way to get
the same effect, but it's not always applicable (e.g. if you have no
control over the design and you are given a function to start with). In
particular, I want to get access to the function's locals() just before
it exits, i.e. something like:

def analyzeLocals(f unc):
func_locals = {}
def probeFunc():
# insert func's code here
sys._getframe(1 ).f_locals["func_local s"].update(locals( ))
probeFunc()
# func_locals now contains func's locals

So, how can I add func's code in probeFunc so that the injected code
(the update line here) is always called before the function exits ?
That is, don't just inject it lexically in the end of the function if
there are more than one exit points. I guess a solution will involve a
good deal bytecode hacking, on which i know very little; if there's a
link to a (relatively) simple HOWTO, it would be very useful.

Thanks,
George

A decorator would seem to be the sensible way to do this, assuming you
are using Python 2.4.

def decorated(func) :
def wrapper(arg1, arg2, arg3):
print "Arg2:", arg2
func(arg1)
print "Arg3:", arg3
return wrapper

@decorated
def f1(x):
print "F1:", x

f1('ARG1', 'ARG2', 'ARG3')

Arg2: ARG2
F1: ARG1
Arg3: ARG3

All the decorator really does is compute one function from another.
There's been enough discussion on the list recently that I won't repeat
the theory.

regards
Steve
--
Steve Holden [phone] [phone]
Holden Web LLC http://www.holdenweb.com/
Python Web Programming http://pydish.holdenweb.com/

[Lonnie Princehouse]

I expect you could combine the following with decorators as an easy way
to grab a function's locals just before it exits... you could also use
exec or eval to execute code in the function's local namespace.
---------------------------------------

# Try it:

def trace_returns(f rame, event, arg):
if event == 'return':
print "[frame locals just before return: %s]" % frame.f_locals
return trace_returns

def foo(a, b):
return a + b

import sys
sys.settrace(tr ace_returns)

foo(1,2)

[George Sakkis]

"Lonnie Princehouse" wrote:

I expect you could combine the following with decorators as an easy way to grab a function's locals just before it exits... you could also use exec or eval to execute code in the function's local namespace.
---------------------------------------

# Try it:

def trace_returns(f rame, event, arg):
if event == 'return':
print "[frame locals just before return: %s]" % frame.f_locals
return trace_returns

def foo(a, b):
return a + b

import sys
sys.settrace(tr ace_returns)

foo(1,2)

Thanks, that's the closest to what I wanted. A minor point I didn't
quite get from the documentation is how to set a local trace instead of
a global (sys) trace. Also, there's no sys.gettrace() to return the
current tracer; is there a way around this ?

George

[Kay Schluehr]

George Sakkis wrote:

Thanks, that's the closest to what I wanted. A minor point I didn't
quite get from the documentation is how to set a local trace instead of a global (sys) trace.
You never do. "Local" in this context only means that those local trace
functions are called inside the one global trace-function and return
the global trace function again.

In Lonnies example there are no local-trace functions at all.
Also, there's no sys.gettrace() to return the
current tracer; is there a way around this ?

The default tracer is None i.e. no debugging. The programmer has to
control his tracer which might not be to hard:
class Analyzer:
def trace_returns(s elf, frame, event, arg):
if event == 'return':
self.func_local s = frame.f_locals
return self.trace_retu rns

def analyzeLocals(s elf, func,*args,**kw ):
sys.settrace(se lf.trace_return s)
func(*args,**kw )
sys.settrace(No ne)

Ciao,
Kay

[Lonnie Princehouse]

I don't know of a way to get the current global trace function. This
could certainly cause trouble if you're trying to be compatible with
other packages that want to use their own trace functions (like psyco,
or debuggers). Does anyone know how to get the global trace?

On the other hand, the local trace function is in the f_trace attribute
of a frame.

It looks like global trace functions only get the "call" event, and are
expected to return a local trace function that will receive "line" and
"return" events, so you will need a global trace in order to set local
traces (setting myframe.f_trace explicitly doesn't seem to do it).