Question

I’m trying to write a class method decorator that modifies its class’ state. I’m having troubles implementing it at the moment.

Side question: When does a decorator get called? Does it load when the class is instantiated or on during read time when the class read?

What I’m trying to do is this:

class ObjMeta(object):
    methods = []

    # This should be a decorator that magically updates the 'methods'
    # attribute (or list) of this class that's being read by the proxying
    # class below.
    def method_wrapper(method):
        @functools.wraps(method)
        def wrapper(*args, **kwargs):
            ObjMeta.methods.append(method.__name__)
            return method(*args, **kwargs)
        return wrapper

    # Our methods
    @method_wrapper
    def method1(self, *args):
        return args

    @method_wrapper
    def method2(self, *args):
        return args


class Obj(object):

    klass = None

    def __init__(self, object_class=ObjMeta):
        self.klass = object_class
        self._set_methods(object_class)

    # We dynamically load the method proxies that calls to our meta class
    # that actually contains the methods. It's actually dependent to the 
    # meta class' methods attribute that contains a list of names of its
    # existing methods. This is where I wanted it to be done automagically with
    # the help of decorators
    def _set_methods(self, object_class):
        for method_name in object_class:
            setattr(self, method_name, self._proxy_method(method_name))

    # Proxies the method that's being called to our meta class
    def _proxy_method(self, method_name):
        def wrapper(*fargs, **fkwargs):
            return getattr(self.klass(*fargs, **fkwargs), method_name)
        return wrapper()

I think it’s ugly to write a list of methods manually in the class so perhaps a decorator would fix this.

It’s for an open-source project I’m working that ports underscore.js to python. I understand that it says I should just use itertools or something. I’m just doing this just for the love of programming and learning. BTW, project is hosted here

Thanks!

Answer 1

There are a few things wrong here.

Anything inside the inner wrapper is called when the method itself is called. Basically, you’re replacing the method with that function, which wraps the original. So, your code as it stands would add the method name to the list each time it is called, which probably isn’t what you want. Instead, that append should be at the method_wrapper level, ie outside of the inner wrapper. This is called when the method is defined, which happens the first time the module containing the class is imported.

The second thing wrong is that you never actually call the method – you simply return it. Instead of return method you should be returning the value of calling the method with the supplied args – return method(*args, **kwargs).