Elegant (?) AoP for methods and functions (Python recipe) by Alec Thomas

ActiveState Code (http://code.activestate.com/recipes/577082/)

import functools
import sys
import types


def advise(*join_points):
    """Hook advice to a function or method.

    advise() is a decorator that takes a set of functions or methods and
    injects the decorated function in their place. The decorated function should
    have the signature:

        @advise(some_function, Class.some_method, Class.some_class_method,
                Class.some_static_method, ...)
        def interceptor(on, next, *args, **kwargs):
            ...

    Where "on" is the object that hosts the intercepted function (ie. a module,
    class or instance) and "next" is the next function in the interception
    chain.

    >>> def eat(lunch):
    ...   print 'eating', lunch

    >>> @advise(eat)
    ... def replace_sandwich(on, next, lunch):
    ...   if lunch == 'sandwich':
    ...     print 'delicious sandwich!'
    ...     return next('dirt')
    ...   else:
    ...     return next(lunch)

    >>> eat('soup')
    eating soup

    >>> eat('sandwich')
    delicious sandwich!
    eating dirt

    >>> class Eater(object):
    ...   def eat(self):
    ...     print 'tastes like identity!'
    ...   @classmethod
    ...   def eat_class(cls):
    ...     print 'let them eat cake!'
    ...   @staticmethod
    ...   def eat_static():
    ...     print 'mmm, static cling'
    ...   def eat_instance(self):
    ...     print 'a moment in time'

    >>> eater = Eater()

    Multiple functions can be intercepted in one call to @advise, including
    classmethods and staticmethods:

    >>> @advise(Eater.eat, Eater.eat_class, Eater.eat_static, eater.eat_instance)
    ... def delicious(on, next):
    ...   print 'delicious!'
    ...   return next()

    Normal method intercepted on the class:

    >>> Eater().eat()
    delicious!
    tastes like identity!

    Normal method intercepted on the instance:

    >>> eater.eat_instance()
    delicious!
    a moment in time

    Class method:

    >>> Eater.eat_class()
    delicious!
    let them eat cake!

    Static method:

    >>> Eater.eat_static()
    delicious!
    mmm, static cling

    Functions can be intercepted multiple times:

    >>> @advise(Eater.eat)
    ... def intercept(on, next):
    ...   print 'intercepted...AGAIN'
    ...   return next()

    >>> Eater().eat()
    intercepted...AGAIN
    delicious!
    tastes like identity!

    """
    hook = []
    def hook_advice(join_point):
        def intercept(*args, **kwargs):
            return hook[0](on, join_point, *args, **kwargs)
        intercept = functools.update_wrapper(intercept, join_point)

        # Either a normal method or a class method?
        if type(join_point) is types.MethodType:
            # Class method intercept or instance intercept
            if join_point.im_self:
                on = join_point.im_self
                # If we have hooked onto an instance method...
                if type(on) is type:
                    def intercept(cls, *args, **kwargs):
                        return hook[0](cls, join_point, *args, **kwargs)
                    intercept = functools.update_wrapper(intercept, join_point)
                    intercept = classmethod(intercept)
            else:
                # Normal method, we curry "self" to make "next" uniform
                def intercept(self, *args, **kwargs):
                    curry = functools.update_wrapper(
                        lambda *a, **kw: join_point(self, *a, **kw), join_point)
                    return hook[0](self, curry, *args, **kwargs)
                intercept = functools.update_wrapper(intercept, join_point)
                on = join_point.im_class
        else:
            # Static method or global function
            on = sys.modules[join_point.__module__]
            caller_globals = join_point.func_globals
            name = join_point.__name__
            # Global function
            if caller_globals.get(name) is join_point:
                caller_globals[name] = intercept
            else:
                # Probably a staticmethod, try to find the attached class
                for on in caller_globals.values():
                    if getattr(on, name, None) is join_point:
                        intercept = staticmethod(intercept)
                        break
                else:
                    raise ValueError('%s is not a global scope function and '
                                     'could not be found in top-level classes'
                                     % name)
        name = join_point.__name__
        setattr(on, name, intercept)

    for join_point in join_points:
        hook_advice(join_point)

    def add_hook(func):
        hook.append(func)
        return func
    return add_hook


if __name__ == '__main__':
    import doctest
    doctest.testmod()