modifying a python callable so it calls before() , actual function then after()

Question

Hello

I am not sure if this is the best way to have before and after functions be called around a function f1().

class ba(object):
    def __init__(self, call, before, after):
        self.call = call
        self.before = before
        self.after = after

    def __call__(self, *args):
        self.before()
        r = self.call(*args)
        self.after()
        return r


class test1(object):
    def mybefore(self):
        print "before func call"

    def myafter(self):
        print "after func call"

def meth1(a1, a2):
    print "meth1(a1=%d, a2=%d)" % (a1, a2)

t = test1()

wmeth1 = ba(meth1, t.mybefore, t.myafter)

wmeth1(1, 2)

Please advise.

Answer 1

I'd use a decorator, like so:

from functools import wraps

class withBeforeAfter(object):
    def __init__(self, before, after):
        self.before = before
        self.after = after
    def __call__(self, wrappedCall):
        @wraps(wrappedCall)
        def wrapCall(*args, **kwargs):
            try:
                self.before()
                r = wrappedCall(*args, **kwargs)
            finally:
                self.after()
            return r
        return wrapCall

 # to use it:
 @withBeforeAfter(myBefore, myAFter)
 def myFunc(...):
     ...

 # or:
 def myFunc(...):
     ...
 # later...
 myFunc = withBeforeAfter(myBefore, myAfter)(myFunc)

Answer 2

You could use the @contextmanager decorator in the contextlib module along with a with statement for something along these lines:

from contextlib import contextmanager

class test1(object):
    def mybefore(self):
        print "before func call"
    def myafter(self):
        print "after func call"

@contextmanager
def wrapper(cls):
    test = cls()
    test.mybefore()
    try:
        yield
    finally:
        test.myafter()

def f1(a1, a2):
    print "f1(a1=%d, a2=%d)" % (a1, a2)

with wrapper(test1):
    f1(1, 2)