Fixed #17255 -- Removed "as" prefix from new timezone template filter names...

    elif value is None:

        return EMPTY_CHANGELIST_VALUE

    elif isinstance(field, models.DateTimeField):

        return formats.localize(timezone.aslocaltime(value))

        return formats.localize(timezone.localtime(value))

    elif isinstance(field, models.DateField) or isinstance(field, models.TimeField):

        return formats.localize(value)

    elif isinstance(field, models.DecimalField):

from django.utils.formats import localize

from django.utils.html import escape

from django.utils.module_loading import module_has_submodule

from django.utils.timezone import aslocaltime

from django.utils.timezone import localtime

TOKEN_TEXT = 0

                else:

                    arg_vals.append(arg.resolve(context))

            if getattr(func, 'expects_localtime', False):

                obj = aslocaltime(obj, context.use_tz)

                obj = localtime(obj, context.use_tz)

            if getattr(func, 'needs_autoescape', False):

                new_obj = func(obj, autoescape=context.autoescape, *arg_vals)

            else:

    means escaping, if required, and conversion to a unicode object. If value

    is a string, it is expected to have already been translated.

    """

    value = aslocaltime(value, use_tz=context.use_tz)

    value = localtime(value, use_tz=context.use_tz)

    value = localize(value, use_l10n=context.use_l10n)

    value = force_unicode(value)

    if ((context.autoescape and not isinstance(value, SafeData)) or

from django.utils.html import escape

from django.utils.safestring import SafeData, EscapeData

from django.utils.formats import localize

from django.utils.timezone import aslocaltime

from django.utils.timezone import localtime

class DebugLexer(Lexer):

    def render(self, context):

        try:

            output = self.filter_expression.resolve(context)

            output = aslocaltime(output, use_tz=context.use_tz)

            output = localtime(output, use_tz=context.use_tz)

            output = localize(output, use_l10n=context.use_l10n)

            output = force_unicode(output)

        except UnicodeDecodeError:

register = Library()

# HACK: datetime is an old-style class, create a new-style equivalent

# so we can define additional attributes.

class datetimeobject(datetime, object):

# Template filters

@register.filter

def aslocaltime(value):

def localtime(value):

    """

    Converts a datetime to local time in the active time zone.

    This only makes sense within a {% localtime off %} block.

    """

    return astimezone(value, timezone.get_current_timezone())

    return do_timezone(value, timezone.get_current_timezone())

@register.filter

def asutc(value):

def utc(value):

    """

    Converts a datetime to UTC.

    """

    return astimezone(value, timezone.utc)

    return do_timezone(value, timezone.utc)

@register.filter

def astimezone(value, arg):

@register.filter('timezone')

def do_timezone(value, arg):

    """

    Converts a datetime to local time in a given time zone.

        context.use_tz = old_setting

        return output

class TimezoneNode(Node):

    """

    Template node class used by ``timezone_tag``.

            output = self.nodelist.render(context)

        return output

class GetCurrentTimezoneNode(Node):

    """

    Template node class used by ``get_current_timezone_tag``.

        context[self.variable] = timezone.get_current_timezone_name()

        return ''

@register.tag('localtime')

def localtime_tag(parser, token):

    """

    if len(bits) == 1:

        use_tz = True

    elif len(bits) > 2 or bits[1] not in ('on', 'off'):

        raise TemplateSyntaxError("%r argument should be 'on' or 'off'" % bits[0])

        raise TemplateSyntaxError("%r argument should be 'on' or 'off'" %

                                  bits[0])

    else:

        use_tz = bits[1] == 'on'

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

    parser.delete_first_token()

    return LocalTimeNode(nodelist, use_tz)

@register.tag('timezone')

def timezone_tag(parser, token):

    """

    """

    bits = token.split_contents()

    if len(bits) != 2:

        raise TemplateSyntaxError("'%s' takes one argument (timezone)" % bits[0])

        raise TemplateSyntaxError("'%s' takes one argument (timezone)" %

                                  bits[0])

    tz = parser.compile_filter(bits[1])

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

    parser.delete_first_token()

    return TimezoneNode(nodelist, tz)

@register.tag("get_current_timezone")

def get_current_timezone_tag(parser, token):

    """

    """

    args = token.contents.split()

    if len(args) != 3 or args[1] != 'as':

        raise TemplateSyntaxError("'get_current_timezone' requires 'as variable' (got %r)" % args)

        raise TemplateSyntaxError("'get_current_timezone' requires "

                                  "'as variable' (got %r)" % args)

    return GetCurrentTimezoneNode(args[2])

__all__ = [

    'utc', 'get_default_timezone', 'get_current_timezone',

    'activate', 'deactivate', 'override',

    'aslocaltime', 'isnaive',

    'localtime', 'isnaive',

]

# Utilities

def aslocaltime(value, use_tz=None):

def localtime(value, use_tz=None):

    """

    Checks if value is a datetime and converts it to local time if necessary.