test.py

import functools


class ObservableFunction(object):

    def __init__(self, func):
        self.func = func
        self.observers = []

    def __call__(self, *args, **kwargs):
        ret = self.func(*args, **kwargs)

        for observer in self.observers:
            observer()

        return ret

    def register(self, observer):
        self.observers.append(observer)

    def deregister(self, observer):
        self.observers.remove(observer)


def observable(func):
    func._observable = True
    return func


class ObserverPattern(object):

    def __new__(cls, *args, **kwargs):
        obj = super(ObserverPattern, cls).__new__(cls)

        for name in dir(obj):
            attr = getattr(obj, name)
            if callable(attr) and hasattr(attr, '_observable'):
                wrapper = functools.wraps(attr)(ObservableFunction(attr))
                setattr(obj, name, wrapper)

        return obj


if __name__ == '__main__':
    class Foobar(ObserverPattern):

        def __init__(self, name):
            self.name = name

        @observable
        def mofo(self):
            print(self.name, 'poop on my knee')

        def poop(self):
            print(self.name, 'everybody poops')

    foo = Foobar('FOO')
    bar = Foobar('BAR')

    foo.mofo()
    foo.poop()

    def callback():
        print('I got called')

    foo.mofo.register(callback)
    foo.mofo()
    bar.mofo()

    foo.mofo.deregister(callback)
    foo.mofo()