Question

I would like to provide a decorator that allows for an optional configuration when applied to a function.

A simple implementation follows:

import functools


class Deco(object):
    config = {'message': 'hello'}

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

    def __call__(self, *args, **kwargs):
         print self.config['message']
         return self.func(*args, **kwargs)

    @classmethod
    def customize(cls, **kwargs):
         """Return a customized instance of this class. """
         return type(cls.__name__, (Deco, ), {'config': kwargs})


@Deco
def add(a, b): 
    return a + b 


@Deco.customize(message='bye')
def sub(a, b): 
    return a - b 


>>> add(1, 2)
'hello'
>>> sub(2, 1)
'bye'

I would like to use it to provide user-friendly decorators for Django views.

This approach works without errors, but is there something bad about allowing a class to have a static factory method instantiating customized instances of it self, as a decorator?

Answer 1

You could work without creating an extra sub-class for each time the decorator is used there, but your code is fine. The way without extra subclass could be something along:

class Deco(object):
    config = {'message': 'hello'}

    def __init__(self, func=None, **kwargs):
         if kwargs:
             self.config = kwargs
         if func is not None:
             self._decorate(func)

    def _decorate(self, func):
        self.func = func
        functools.wraps(func)(self)

    def __call__(self, *args, **kwargs):
        if not hasattr(self, "func"):
            self._decorate(func)
            return self
        print self.config['message']
        return self.func(*args, **kwargs)

So, while performance wise there would be no difference to your code (unless you would be decorating at least hundreds of thousands of functions – your code create an extra object – a class – for each time the decorator is used, besides the instance of that class) – there is an impact on people would review your code (either to use your modules, or to maintain it after you are done). I mean “a decorator that dynamically generates subclasses of itself” may sound too advanced and scare people away. Although it is as simple as my suggestion above once one understands the mechanisms of class generation in Python as you had.