Python – Class decorators in Python: practical use cases

decoratorpython

I am looking for practical and non-synthetic use cases of Python class decorators. So far, the only case which made sense to me is registering a class in a publisher-subscriber system, e.g. plugins or events, something like:

@register
class MyPlugin(Plugin):
    pass

@recieves_notifications
class Console:
    def print(self, text):
        ...

Any other sane cases I've been thinking of could have been built on top of inheritance, metaclasses or decorating methods. Could you please share any good (or bad!) examples of using class decorators?

Thank you!

Best Answer

When writing unit tests having the @unittest.skipIf and @unittest.skipUnless can be used on either individual methods or on an entire unittest.TestCase class definition. This makes for writing tests for platform specific problems so much easier.

Example from asyncio/test_selectors

# Some platforms don't define the select.kqueue object for these tests.
# On those platforms, this entire grouping of tests will be skipped.

@unittest.skipUnless(hasattr(selectors, 'KqueueSelector'),
                 "Test needs selectors.KqueueSelector)")
class KqueueSelectorTestCase(BaseSelectorTestCase, ScalableSelectorMixIn):
...

Related Solutions

Python Class Layout – Conventions and Best Practices

Look for such answers in here: http://www.python.org/dev/peps/

Basics is in the most famous one: http://www.python.org/dev/peps/pep-0008/

By the looks and code i have seen, you got pretty good idea about that. Good luck, hope it'll help :)

UPDATE: While following pep rules you come up with about the same anyway :) so pure convention for classes - yes there is none or i haven't heard of it. How you should write it - pep8. By common programming sense you write you variables, fields above methods. Same things happen with everything else. Just code as the Holy Zen of Python teaches you:

Beautiful is better than ugly.

Explicit is better than implicit.

Simple is better than complex.

Complex is better than complicated.

Flat is better than nested.

Sparse is better than dense.

Readability counts.

Special cases aren't special enough to break the rules.

Although practicality beats purity.

Errors should never pass silently. Unless explicitly silenced.

In the face of ambiguity, refuse the temptation to guess.

There should be one - and preferably only one - obvious way to do it.

Although that way may not be obvious at first unless you're Dutch.

Now is better than never.

Although never is often better than right now.

If the implementation is hard to explain, it's a bad idea.

If the implementation is easy to explain, it may be a good idea.

Namespaces are one honking great idea - let's do more of those!

Python – Understanding Decorators in Python

Yes, it probably does, but it proprably retains a reference to the original get(self) definition.

Python decorators are nothing more than a callable themselves (a function, or a class instance with a __call__ method). Whatever that callable returns is used as the definition for the decorated function instead.

If I define a simple no-op decorator like this, that means that I replace the original with.... the original:

def noopDecorator(func):
    return func

The @ symbol used for decorators is syntactic sugar, you could also write it as:

class AuthHandler(BaseHandler, tornado.auth.GoogleMixin):
    def get(self):
        if self.get_argument("openid.mode", None):
            self.get_authenticated_user(self.async_callback(self._on_auth))
            return
        self.authenticate_redirect()
    get = tornado.web.asynchronous(get)

In the case of the tornado asynchronous decorator, the decorator probably returns a deferred handler, to handle the decorated function asynchronously, keeping you, the programmer of a tornado-based application, from having to remember the intricacies of how to do that, time and again. In short, it let's you focus on the details of your application instead.

Best Answer

Related Solutions

Python Class Layout – Conventions and Best Practices

Python – Understanding Decorators in Python

Related Topic