Stupid simple templatetags with Django

class SomeObjectsNode(Node):
    def __init__(self, queryset, var_name, limit=5):
        self.queryset = queryset
        self.var_name = var_name
        self.limit = int(limit)

    def render(self, context):
        queryset = template.Variable(self.queryset).resolve(context)
        try:
            objects = self.queryset[:self.limit]
        except:
            objects = None
        context[self.var_name] = objects
        return ''

@register.tag
def get_some_objects(parser, token):
    """
    Get me some objects

    usage:
    {% get_some_objects from queryset as [var_name] (limit [limit]) %}
    """
    bits = token.split_contents()
    if len(bits) not in (4, 6):
        raise TemplateSyntaxError('%s takes 2 or 3 arguments' % (bits[0]))
    elif len(bits) == 4:
        return LatestEntriesNode(bits[1], bits[3])
    elif len(bits) == 6:
        return LatestEntriesNode(bits[1], bits[3], bits[5])

def get_latest_entries(context, queryset, var_name, limit=5):
    try:
        objects = queryset[:limit]
    except:
        objects = None
    context[var_name] = objects

register = template.Library()

@simpletag(register)
def get_latest_entries(context, queryset, __as, _var_name, __limit, _limit=5):
    try:
        objects = queryset[:_limit]
    except:
        objects = None
    context[_var_name] = objects

import inspect
from django import template

def simpletag(register):
    def inner(func):
        register.tag(func.__name__, SimpleTag(func))
        return func
    return inner

class SimpleTag(object):
    def __init__(self, func):
        self.func = func

        # introspect the function, reading its arguments
        args, _, _, defaults = inspect.getargspec(self.func)
        assert args[0] == 'context', 'First argument of a simpletag must be "context"'

        # ignore the first arg, which is always 'context'
        self.args = args[1:]

        if defaults:
            self.num_defaults = len(defaults)
        else:
            self.num_defaults = 0

    def __call__(self, parser, token):
        bits = token.split_contents()[1:]

        if len(bits) > len(self.args):
            self._error('expects no more than %d arguments' % (len(self.args)))

        for indx, arg in enumerate(self.args):
            if arg.startswith('__'):
                try:
                    named_bit = bits[indx]
                    if named_bit != arg[2:]:
                        self._error('expected argument %d to be "%s"' % \
                            (indx + 1, arg[2:]))
                except IndexError:
                    # append an empty string to the bits
                    bits.append('')

        if len(bits) < len(self.args) - self.num_defaults:
            self._error('expects at least %d arguments' % \
                (len(self.args) - self.num_defaults - 1))

        return SimpleNode(self.func, bits, self.args)

    def _error(self, message):
        raise template.TemplateSyntaxError('%s %s' % \
            (self.func.__name__, message))

class SimpleNode(template.Node):
    def __init__(self, func, params, args):
        self.func = func
        self.params = params
        self.args = args

    def render(self, context):
        for indx, bit in enumerate(self.params):
            if not self.args[indx].startswith('_'):
                self.params[indx] = template.Variable(bit).resolve(context)
        return_value = self.func(context, *self.params)
        return return_value or ''