Used the decorator syntax consistently to register template filters.

from django.utils.translation import pgettext, ungettext, ugettext as _

from django.utils.tzinfo import LocalTimezone

register = template.Library()

@register.filter

def ordinal(value):

    """

    Converts an integer to its ordinal as a string. 1 is '1st', 2 is '2nd',

        return u"%d%s" % (value, suffixes[0])

    return u"%d%s" % (value, suffixes[value % 10])

ordinal.is_safe = True

register.filter(ordinal)

@register.filter

def intcomma(value, use_l10n=True):

    """

    Converts an integer to a string containing commas every three digits.

    else:

        return intcomma(new, use_l10n)

intcomma.is_safe = True

register.filter(intcomma)

# A tuple of standard large number to their converters

intword_converters = (

    )),

)

@register.filter

def intword(value):

    """

    Converts a large integer to a friendly text representation. Works best

            return _check_for_i18n(new_value, *converters(new_value))

    return value

intword.is_safe = False

register.filter(intword)

@register.filter

def apnumber(value):

    """

    For numbers 1-9, returns the number spelled out. Otherwise, returns the

        return value

    return (_('one'), _('two'), _('three'), _('four'), _('five'), _('six'), _('seven'), _('eight'), _('nine'))[value-1]

apnumber.is_safe = True

register.filter(apnumber)

@register.filter

def naturalday(value, arg=None):

register = template.Library()

@register.filter

def textile(value):

    try:

        import textile

        return mark_safe(force_unicode(textile.textile(smart_str(value), encoding='utf-8', output='utf-8')))

textile.is_safe = True

@register.filter

def markdown(value, arg=''):

    """

    Runs Markdown over a given value, optionally using various

            return mark_safe(force_unicode(markdown.markdown(smart_str(value))))

markdown.is_safe = True

@register.filter

def restructuredtext(value):

    try:

        from docutils.core import publish_parts

        return mark_safe(force_unicode(parts["fragment"]))

restructuredtext.is_safe = True

register.filter(textile)

register.filter(markdown)

register.filter(restructuredtext)

# STRINGS         #

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

@register.filter

@stringfilter

def addslashes(value):

    """

    return value.replace('\\', '\\\\').replace('"', '\\"').replace("'", "\\'")

addslashes.is_safe = True

@register.filter

@stringfilter

def capfirst(value):

    """Capitalizes the first character of the value."""

nan = (1e200 * 1e200) // (1e200 * 1e200)

special_floats = [str(pos_inf), str(neg_inf), str(nan)]

@register.filter

def floatformat(text, arg=-1):

    """

    Displays a float to a specified number of decimal places.

        return input_val

floatformat.is_safe = True

@register.filter

@stringfilter

def iriencode(value):

    """Escapes an IRI value for use in a URL."""

    return force_unicode(iri_to_uri(value))

iriencode.is_safe = True

@register.filter

@stringfilter

def linenumbers(value, autoescape=None):

    """Displays text with line numbers."""

linenumbers.is_safe = True

linenumbers.needs_autoescape = True

@register.filter

@stringfilter

def lower(value):

    """Converts a string into all lowercase."""

    return value.lower()

lower.is_safe = True

@register.filter

@stringfilter

def make_list(value):

    """

    return list(value)

make_list.is_safe = False

@register.filter

@stringfilter

def slugify(value):

    """

    return mark_safe(re.sub('[-\s]+', '-', value))

slugify.is_safe = True

@register.filter

def stringformat(value, arg):

    """

    Formats the variable according to the arg, a string formatting specifier.

        return u""

stringformat.is_safe = True

@register.filter

@stringfilter

def title(value):

    """Converts a string into titlecase."""

    return re.sub("\d([A-Z])", lambda m: m.group(0).lower(), t)

title.is_safe = True

@register.filter

@stringfilter

def truncatechars(value, arg):

    """

    return Truncator(value).chars(length)

truncatechars.is_safe = True

@register.filter

@stringfilter

def truncatewords(value, arg):

    """

    return Truncator(value).words(length, truncate=' ...')

truncatewords.is_safe = True

@register.filter

@stringfilter

def truncatewords_html(value, arg):

    """

    return Truncator(value).words(length, html=True, truncate=' ...')

truncatewords_html.is_safe = True

@register.filter

@stringfilter

def upper(value):

    """Converts a string into all uppercase."""

    return value.upper()

upper.is_safe = False

@register.filter

@stringfilter

def urlencode(value, safe=None):

    """

urlize.is_safe = True

urlize.needs_autoescape = True

@register.filter

@stringfilter

def urlizetrunc(value, limit, autoescape=None):

    """

urlizetrunc.is_safe = True

urlizetrunc.needs_autoescape = True

@register.filter

@stringfilter

def wordcount(value):

    """Returns the number of words."""

    return len(value.split())

wordcount.is_safe = False

@register.filter

@stringfilter

def wordwrap(value, arg):

    """

    return wrap(value, int(arg))

wordwrap.is_safe = True

@register.filter

@stringfilter

def ljust(value, arg):

    """

    return value.ljust(int(arg))

ljust.is_safe = True

@register.filter

@stringfilter

def rjust(value, arg):

    """

    return value.rjust(int(arg))

rjust.is_safe = True

@register.filter

@stringfilter

def center(value, arg):

    """Centers the value in a field of a given width."""

    return value.center(int(arg))

center.is_safe = True

@register.filter

@stringfilter

def cut(value, arg):

    """

    return mark_for_escaping(value)

escape_filter.is_safe = True

@register.filter

@stringfilter

def force_escape(value):

    """

linebreaks_filter.is_safe = True

linebreaks_filter.needs_autoescape = True

@register.filter

@stringfilter

def linebreaksbr(value, autoescape=None):

    """

linebreaksbr.is_safe = True

linebreaksbr.needs_autoescape = True

@register.filter

@stringfilter

def safe(value):

    """

    return mark_safe(value)

safe.is_safe = True

@register.filter

def safeseq(value):

    """

    A "safe" filter for sequences. Marks each element in the sequence,

    return [mark_safe(force_unicode(obj)) for obj in value]

safeseq.is_safe = True

@register.filter

@stringfilter

def removetags(value, tags):

    """Removes a space separated list of [X]HTML tags from the output."""

    return value

removetags.is_safe = True

@register.filter

@stringfilter

def striptags(value):

    """Strips all [X]HTML tags."""

# LISTS           #

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

@register.filter

def dictsort(value, arg):

    """

    Takes a list of dicts, returns that list sorted by the property given in

    return sorted(value, key=Variable(arg).resolve)

dictsort.is_safe = False

@register.filter

def dictsortreversed(value, arg):

    """

    Takes a list of dicts, returns that list sorted in reverse order by the

    return sorted(value, key=Variable(arg).resolve, reverse=True)

dictsortreversed.is_safe = False

@register.filter

def first(value):

    """Returns the first item in a list."""

    try:

        return u''

first.is_safe = False

@register.filter

def join(value, arg, autoescape=None):

    """

    Joins a list with a string, like Python's ``str.join(list)``.

join.is_safe = True

join.needs_autoescape = True

@register.filter

def last(value):

    "Returns the last item in a list"

    try:

        return u''

last.is_safe = True

@register.filter

def length(value):

    """Returns the length of the value - useful for lists."""

    try:

        return ''

length.is_safe = True

@register.filter

def length_is(value, arg):

    """Returns a boolean of whether the value's length is the argument."""

    try:

        return ''

length_is.is_safe = False

@register.filter

def random(value):

    """Returns a random item from the list."""

    return random_module.choice(value)

random.is_safe = True

@register.filter("slice")

def slice_(value, arg):

    """

    Returns a slice of the list.

        return value # Fail silently.

slice_.is_safe = True

@register.filter

def unordered_list(value, autoescape=None):

    """

    Recursively takes a self-nested list and returns an HTML unordered list --

# INTEGERS        #

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

@register.filter

def add(value, arg):

    """Adds the arg to the value."""

    try:

            return ''

add.is_safe = False

@register.filter

def get_digit(value, arg):

    """

    Given a whole number, returns the requested digit of it, where 1 is the

# DATES           #

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

@register.filter

def date(value, arg=None):

    """Formats a date according to the given format."""

    if not value:

            return ''

date.is_safe = False

@register.filter

def time(value, arg=None):

    """Formats a time according to the given format."""

    if value in (None, u''):

# LOGIC           #

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

@register.filter

def default(value, arg):

    """If value is unavailable, use given default."""

    return value or arg

default.is_safe = False

@register.filter

def default_if_none(value, arg):

    """If value is None, use given default."""

    if value is None:

    return value

default_if_none.is_safe = False

@register.filter

def divisibleby(value, arg):

    """Returns True if the value is devisible by the argument."""

    return int(value) % int(arg) == 0

divisibleby.is_safe = False

@register.filter

def yesno(value, arg=None):

    """

    Given a string mapping values for true, false and (optionally) None,

# MISC            #

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

@register.filter

def filesizeformat(bytes):

    """

    Formats the value like a 'human-readable' file size (i.e. 13 KB, 4.1 MB,

    return ugettext("%s PB") % filesize_number_format(bytes / (1024 * 1024 * 1024 * 1024 * 1024))

filesizeformat.is_safe = True

@register.filter

def pluralize(value, arg=u's'):

    """

    Returns a plural suffix if the value is not 1. By default, 's' is used as

    return phone2numeric(value)

phone2numeric_filter.is_safe = True

@register.filter

def pprint(value):

    """A wrapper around pprint.pprint -- for debugging, really."""

    try:

    except Exception, e:

        return u"Error in formatting: %s" % force_unicode(e, errors="replace")

pprint.is_safe = True

# Syntax: register.filter(name of filter, callback)

register.filter(add)

register.filter(addslashes)

register.filter(capfirst)

register.filter(center)

register.filter(cut)

register.filter(date)

register.filter(default)

register.filter(default_if_none)

register.filter(dictsort)

register.filter(dictsortreversed)

register.filter(divisibleby)

register.filter(filesizeformat)

register.filter(first)

register.filter(floatformat)

register.filter(force_escape)

register.filter(get_digit)

register.filter(iriencode)

register.filter(join)

register.filter(last)

register.filter(length)

register.filter(length_is)

register.filter(linebreaksbr)

register.filter(linenumbers)

register.filter(ljust)

register.filter(lower)

register.filter(make_list)

register.filter(pluralize)

register.filter(pprint)

register.filter(removetags)

register.filter(random)

register.filter(rjust)

register.filter(safe)

register.filter(safeseq)

register.filter('slice', slice_)

register.filter(slugify)

register.filter(stringformat)

register.filter(striptags)

register.filter(time)

register.filter(title)

register.filter(truncatechars)

register.filter(truncatewords)

register.filter(truncatewords_html)

register.filter(unordered_list)

register.filter(upper)

register.filter(urlencode)

register.filter(urlizetrunc)

register.filter(wordcount)

register.filter(wordwrap)

register.filter(yesno)

from django.utils import formats

from django.utils.encoding import force_unicode

register = Library()

@register.filter

def localize(value):

    """

    Forces a value to be rendered as a localized value,

    return force_unicode(formats.localize(value, use_l10n=True))

localize.is_safe = False

@register.filter

def unlocalize(value):

    """

    Forces a value to be rendered as a non-localized value,

    nodelist = parser.parse(('endlocalize',))

    parser.delete_first_token()

    return LocalizeNode(nodelist, use_l10n)

register.filter(localize)

register.filter(unlocalize)