Search code examples
pythondjangodecoratorlazy-evaluationclass-attributes

Lazy class property decorator


I have one django model which needs to do some processing referring the custom user model.

I can't work with the class of this model at class loading time because the loading order of the classes is unknown.

So I need to add some class attributes at runtime, at the moment I'm adding them in the __init__ or __new__ like:

def __new__(cls, *args, **kwargs):
    # hack to avoid INSTALLED_APPS initialization conflicts.
    # get_user_model() can't be called from this module at class loading time,
    # so some class attributes must be added later.
    # Metaclasses could me more appropiate but I don't want to override
    # dango's metaclasses.
    if not hasattr(cls, '_reverse_field_name_to_user'):
        cls._find_reverse_field_name_to_user()
    return Group.__new__(cls, *args, **kwargs)

It works but looks horrible so I've thought about using something like @lazyclassproperty for these attributes.

I've found several @classproperty and @lazyproperty decorators but not one for both and I have no idea how to write one myself.

Question: How could I code such decorator? or suggest another cleaner alternative to my current silly implementation.


Solution

  • Pyramid framework has a very nice decorator called reify, but it only works at instance level, and you want class level, so let's modify it a bit

    class class_reify(object):
        def __init__(self, wrapped):
            self.wrapped = wrapped
            try:
                self.__doc__ = wrapped.__doc__
            except: # pragma: no cover
                pass
    
        # original sets the attributes on the instance
        # def __get__(self, inst, objtype=None):
        #    if inst is None:
        #        return self
        #    val = self.wrapped(inst)
        #    setattr(inst, self.wrapped.__name__, val)
        #    return val
    
        # ignore the instance, and just set them on the class
        # if called on a class, inst is None and objtype is the class
        # if called on an instance, inst is the instance, and objtype 
        # the class
        def __get__(self, inst, objtype=None):
            # ask the value from the wrapped object, giving it
            # our class
            val = self.wrapped(objtype)
    
            # and set the attribute directly to the class, thereby
            # avoiding the descriptor to be called multiple times
            setattr(objtype, self.wrapped.__name__, val)
    
            # and return the calculated value
            return val
    
    class Test(object):
        @class_reify
        def foo(cls):
            print("foo called for class", cls)
            return 42
    
    print(Test.foo)
    print(Test.foo)
    

    Run the program and it prints

    foo called for class <class '__main__.Test'>
    42
    42