Django templatetags mixins

__init__.py

from dictnode import *

dictnode.py

import re
from django import template

register = template.Library()

class DictMixinNotAvailable(Exception):
    def __init__(self, value=None):
        self.parameter = value
    def __str__(self):
        return repr(self.paremeter)


class DictNode(template.Node):
    compulsory = ()
    DictMixins = []

    @classmethod
    def handle_token(cls, parser, token):
        kwargs = {}
        for clase in cls.DictMixins:
            key = clase.key_word
            try:
                value = clase.parse_tokens(parser, token)
                kwargs[key] = value
            except DictMixinNotAvailable:
                if clase.__name__ in cls.compulsory or key in cls.compulsory:
                    raise template.TemplateSyntaxError("%r tag requires %s argument." % (token.contents.split()[0], key))
                elif clase.default:
                    kwargs[key] = clase.default
                else:
                    kwargs[key] = None
            except:
                raise

        class _Node(cls):
            pass

        for key, value in kwargs.items():
            if hasattr(value, '__call__'):
                setattr(_Node, key, property(value))
            else:
                setattr(_Node, key, value)

        return _Node()

    def render(self, context):
        self.context = context
        return ''


class DictMixin(object):
    key_word = None
    pattern = None
    default = None
    @classmethod
    def get_pattern(cls):
        if cls.pattern:
            return cls.pattern
        elif cls.key_word:
            pattern = r'(.*?)'+cls.key_word+' (\w+)(.*?)'
            return pattern
        else:
            raise template.TemplateSyntaxError('DictMixin must have either a \'pattern\' specified or a \'key_word\' to compose it.')

    @classmethod
    def parse_tokens(cls, parser, token):
        try:
            tag_name, arg = token.contents.split(None, 1)
        except ValueError:
            return cls.default
        m = re.search(cls.get_pattern(), arg)
        if not m:
            raise DictMixinNotAvailable
            #return cls.default
        else:
            return m.groups()[1]

####################################

class ValueMixin(DictMixin):
    pass

class ObjectMixin(DictMixin):
    @classmethod
    def parse_tokens(cls, parser, token):
        value = super(ObjectMixin, cls).parse_tokens(parser, token)
        if value:
            expression = parser.compile_filter(value)
            return lambda self: expression.resolve(self.context)
        else:
            raise DictMixinNotAvailable

class MixMixin(DictMixin):
    @classmethod
    def parse_tokens(cls, parser, token):
        value = super(MixMixin, cls).parse_tokens(parser, token)
        if value:
            try:
                expression = parser.compile_filter(value)
                return lambda self: expression.resolve(self.context)
            except:
                return value
        else:
            raise DictMixinNotAvailable

class StringMixin(DictMixin):
    @classmethod
    def parse_tokens(cls, parser, token):
        value = super(StringMixin, cls).parse_tokens(parser, token)
        print "StringMixin::parse_tokens %s " % value
        if value:
            expression = template.Variable(value)
            return lambda self: expression.resolve(self.context)
        else:
            raise DictMixinNotAvailable

######################################