class cached_property(object):
    """A decorator that converts a function into a lazy property.  The
    function wrapped is called the first time to retrieve the result
    and then that calculated result is used the next time you access
    the value::

        class Foo(object):

            @cached_property
            def foo(self):
                # calculate something important here
                return 42

    The class has to have a `__dict__` in order for this property to
    work.
    """

    # implementation detail: this property is implemented as non-data
    # descriptor.  non-data descriptors are only invoked if there is
    # no entry with the same name in the instance's __dict__.
    # this allows us to completely get rid of the access function call
    # overhead.  If one choses to invoke __get__ by hand the property
    # will still work as expected because the lookup logic is replicated
    # in __get__ for manual invocation.

    def __init__(self, func, name=None, doc=None):
        self.__name__ = name or func.__name__
        self.__module__ = func.__module__
        self.__doc__ = doc or func.__doc__
        self.func = func

    def __get__(self, obj, type=None):
        if obj is None:
            return self
        value = obj.__dict__.get(self.__name__, _missing)
        if value is _missing:
            value = self.func(obj)
            obj.__dict__[self.__name__] = value
        return value

I got around to benchmarking this and, surprisingly, creating a new class on each call is actually less expensive than the extra attribute access, even with __slots__ defined. I’m guessing this has to do with behind-the-scenes MRO stuff going on. The difference is very slight and probably isn’t a practical consideration, but just throwing that out there. Here’s the code and results (CPython 2.6 on single-core i386):

$ python test.py
30.59: MakeNewClass
30.48: MakeNewClass_Slots
33.97: StashObject
33.69: StashObject_Slots 

$ cat test.py
import sys
import time

class MakeNewClass(object):
    def __init__(self, func):
        self.func = func
    def __call__(self):
        self.func()
    def __get__(self, obj, type):
        return self.__class__(self.func.__get__(obj, type))

class MakeNewClass_Slots(object):
    __slots__ = ('func',)
    def __init__(self, func):
        self.func = func
    def __call__(self):
        self.func()
    def __get__(self, obj, type):
        return self.__class__(self.func.__get__(obj, type))

class StashObject(object):
    def __init__(self, func):
        self.func = func
    def __call__(self):
        self.func(self.obj)
    def __get__(self, obj, type):
        self.obj = obj
        return self

class StashObject_Slots(object):
    __slots__ = ('func', 'obj')
    def __init__(self, func):
        self.func = func
    def __call__(self):
        self.func(self.obj)
    def __get__(self, obj, type):
        self.obj = obj
        return self

class Test(object):
    @MakeNewClass
    def test_a(self):
        pass
    @MakeNewClass_Slots
    def test_b(self):
        pass
    @StashObject
    def test_c(self):
        pass
    @StashObject_Slots
    def test_d(self):
        pass

t = Test()
for func in t.test_a, t.test_b, t.test_c, t.test_d:
    start = time.time()
    for i in xrange(30000000):
        func()
    print '%.2f: %s' % (time.time() - start, func.__class__.__name__)

def wsgiapp(func):
    def inner(self, environ, start_response):
        resp = func(self, Request(environ))
        return resp(environ, start_response)
    return inner

Does the same thing, no magic.

I suppose class-based deco’s are useful if your decorator needs to save state between calls or share it with other decorated functions, but there are other ways to do that, such as having the inner function close over a dict. IMO, decorators are a functional idiom and trying to force them to work as an object by introducing all this magic might not be the best practical solution, although it’s a fun exercise in python internal hacking.

This will re-bind the inner function to the obj instance and then 
remove the __get__ method, however you just monkey-patched your 
decorator — meaning you can only decorate one function. Not very 
useful, obviously

From my point of view, very useful, since that means that if you transform it from a class to a function that returns a class, you are set.

ie

def deco():
    class inner(object):

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

        def __call__(self, arg):
            return self.func(arg)

        def __get__(self, obj, type=None):
            self.func = self.func.__get__(obj, type)
            del self.__class__.__get__
            return self
    return inner

Seems to work well, even though it’s an uglyish syntax.

Using a class decorator makes it a little more succinct:

def classIsADescriptorDecorator(klass):
    def __init__(self, func):
        self.func = func

    def __get__(self, obj, type=None):
        self.func = self.func.__get__(obj, type)
        del self.__class__.__get__
        return self

    klass.__init__ = __init__
    klass.__get__ = __get__

    return klass

def deco():
    @classIsADescriptorDecorator
    class inner(object):
        def __call__(self, arg):
            return self.func(arg)

And further, increasing the magic quotient by creating a new class on the fly, we can make it shorter:

def decorate(klass):
    newType = type('newType', klass.__class__.__bases__, dict(klass.__dict__))
    return classIsADescriptorDecorator(newType)

which can be used as following:

class Printer(object):
    def __call__(self, arg):
         print arg
         return self.func(arg)


@decorate(Printer)
def notAPrinter(arg):
     print "I'm not a printer: %s" % arg

This last one looks fragile.

class cache_descriptor(object):
    def __init__(self, attr, descriptor):
        self.attr = attr
        self.descriptor = descriptor
    def __get__(self, obj, type=None):
        result = self.descriptor.__get__(obj, type)
        if obj is not None:
            obj.__dict__[self.attr] = result
        return result
    def __set__(self, obj, value):
        self.descriptor.__set__(obj, value)
    def __delete__(self, obj):
        self.descriptor.__delete__(obj)

Then you could do something like:

class MyThingy(object):
    @whatever
    def __call__(self, ...): ...
    __call__ = cache_descriptor('__call__', __call__)

Or maybe separately:

def cache_descriptors(cls, *methods):
    for method in methods:
        setattr(cls, method, cache_descriptor(method, getattr(cls, method)))

class MyThingy(object): ...
cache_descriptors(MyThingy, '__call__', 'something_else', ...)

I don’t cache these values in WebOb, but I do use a pattern of nested descriptors (webob.converter).

class deco(object):

    def __init__(self, func):
        self.func = func
        self.obj = None

    def __call__(self, arg):
        return self.func(self.obj, arg)

    def __get__(self, obj, type=None):
        self.obj = obj
        return self

class deco(object):

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

    def __call__(self, arg):
        return self.func(arg)

    def __get__(self, obj, type=None):
        self.func = self.func.__get__(obj, type)
        del deco.__get__
        return self

This will re-bind the inner function to the obj instance and then remove the __get__ method, however you just monkey-patched your decorator — meaning you can only decorate one function. Not very useful, obviously. The reason this works is the reason you have to instantiate on every call: Descriptors operate on the class level.

To be honest, I think it makes more sense to decorate instance methods with functional rather than class-based decorators. For one, it does not have the problem of the unbound method failing to pass implicit self. Second of all, decorating is inherently a functional operation. Wrapping the whole thing in a class with __call__ defined is just ugly and confusing IMO. Then on top of that, overriding __get__ to re-bind the function is a hack; one that could have significant performance implications if called in a tight loop.

You originally tried:

class Foo: def bar(self,x): return x*3

class Baz: #what some TG decorators do: foo = Foo() foo.bar.expose = True

which gave you an AttributeError: ‘instancemethod’ object has no attribute ‘expose’.

What’s going on here is that foo.bar is a bound method (isinstance(foo.bar, types.MethodType)) and neither they (nor unbound methods like Foo.bar) have dict’s. Hence you can’t assign new attributes to them.

When you use the @deco technique instead:

class Foo: @deco def bar(self,x): return x*3

class Baz: foo = Foo() foo.bar.expose = True

now foo.bar is no longer a method. Instead, it’s an attribute of foo which has a deco object as its value. This object does have a dict and can be assigned arbitrary new attributes, like expose.