{"id":640,"date":"2010-07-06T10:16:18","date_gmt":"2010-07-06T14:16:18","guid":{"rendered":"http:\/\/www.outofwhatbox.com\/blog\/?p=640"},"modified":"2010-07-09T16:48:58","modified_gmt":"2010-07-09T20:48:58","slug":"python-decorating-with-class","status":"publish","type":"post","link":"https:\/\/www.outofwhatbox.com\/blog\/2010\/07\/python-decorating-with-class\/","title":{"rendered":"Python: Decorating with class through descriptors"},"content":{"rendered":"
Update<\/strong>: If you find this article helpful, you may want to read the follow-up<\/a>.<\/div>\n

As a fairly new Python developer, my first attempt at decorators<\/a> hit a snag: my simple class-based decorator failed when decorating a method. I got around the immediate problem by rewriting the decorator as a function. Yet the episode left me wondering if there were some way to fix the class-based decorator to work when applied to methods. I’ve found what seems like an elegant solution, and picked up a better understanding of decorators and descriptors in the process.<\/p>\n

Here’s an example that illustrates the original problem. DebugTrace<\/code> is the decorator class:<\/p>\n

\r\nclass DebugTrace(object):\r\n    def __init__(self, f):\r\n        print("Tracing: {0}".format(f.__name__))\r\n        self.f = f\r\n\r\n    def __call__(self, *args, **kwargs):\r\n        print("Calling: {0}".format(self.f.__name__))\r\n        return self.f(*args, **kwargs)\r\n\r\n\r\nclass Greeter(object):\r\n    instances = 0\r\n\r\n    def __init__(self):\r\n        Greeter.instances += 1\r\n        self._inst = Greeter.instances\r\n\r\n    @DebugTrace\r\n    def hello(self):\r\n        print("*** Greeter {0} says hello!".format(self._inst))\r\n\r\n\r\n@DebugTrace\r\ndef greet():\r\n    g = Greeter()\r\n    g2 = Greeter()\r\n    g.hello()\r\n    g2.hello()\r\n\r\n\r\ngreet()\r\n<\/pre>\n
Running this with Python 2.6 or 3.1 results in an error:<\/p>\n
\r\nTracing: hello\r\nTracing: greet\r\nCalling greet\r\nCalling hello\r\nTraceback (most recent call last):\r\n  File ".\/DecoratorExample.py", line 31, in <module>\r\n    greet()\r\n  File ".\/DecoratorExample.py", line 8, in __call__\r\n    return self.f(*args, **kwargs)\r\n  File ".\/DecoratorExample.py", line 27, in greet\r\n    g.hello()\r\n  File ".\/DecoratorExample.py", line 8, in __call__\r\n    return self.f(*args, **kwargs)\r\nTypeError: hello() takes exactly 1 argument (0 given)\r\n<\/pre>\n
The output explains the problem. DebugTrace<\/code> was instantiated only twice: once for Greeter.hello<\/code>, and once for greet<\/code>. That’s a reminder that decoration occurs during compile time, not run time. Accordingly, DebugTrace<\/code>‘s reference to Greeter.hello<\/code> represents an unbound<\/em> function\u00e2\u20ac\u201dit doesn’t reference any Greeter<\/code> instances. So no ‘self’ argument was passed into the call to Greeter.hello<\/code>; hence the TypeError.<\/p>\n
All object-oriented languages that are worth knowing (and many that aren’t) allow container objects to redirect access to their contained objects. But of the languages that I’ve used, Python is unique in allowing object attributes<\/em> to redirect calls that attempt to access them. Objects that implement this capability are called descriptors<\/em><\/a>1<\/sup><\/a>. As we’ll soon see, function objects<\/em>, which Python uses to implement methods, are descriptors.<\/p>\n
A full description of descriptors would be too long to fit here. Here are the most important points for this post:<\/p>\n
    \n
  1. When the interpreter reads a class attribute, and the attribute value is an object that has a __get__<\/code> method, then the return value of that __get__<\/code> method is used as the attribute’s value.<\/li>\n
  2. Methods are class attributes.<\/li>\n
  3. Any callable object can serve as a method.<\/li>\n<\/ol>\n
    Here’s a good guide to descriptors<\/a>. There’s also a recent post by Guido van Rossum, Python’s BDFL<\/a>, that provides good background material<\/a> on the feature.<\/div>\n
    To see where descriptors come into play, let’s look at the calling sequences for different versions of Greeter.hello<\/code>. Here’s the rough sequence before<\/em> Greeter.hello<\/code> was decorated:<\/p>\n