« Template Designer Documentation | Extensions | Integration »


Jinja2 supports extensions that can add extra filters, tests, globals or even extend the parser. The main motivation of extensions is it to move often used code into a reusable class like adding support for internationalization.

Adding Extensions

Extensions are added to the Jinja2 environment at creation time. Once the environment is created additional extensions cannot be added. To add an extension pass a list of extension classes or import paths to the environment parameter of the Environment constructor. The following example creates a Jinja2 environment with the i18n extension loaded:

jinja_env = Environment(extensions=['jinja2.ext.i18n'])

i18n Extension

Import name: jinja2.ext.i18n

Jinja2 currently comes with one extension, the i18n extension. It can be used in combination with gettext or babel. If the i18n extension is enabled Jinja2 provides a trans statement that marks the wrapped string as translatable and calls gettext.

After enabling dummy _ function that forwards calls to gettext is added to the environment globals. An internationalized application then has to provide at least an gettext and optoinally a ngettext function into the namespace. Either globally or for each rendering.

After enabling of the extension the environment provides the following additional methods:

Installs a translation globally for that environment. The tranlations object provided must implement at least ugettext and ungettext. The gettext.NullTranslations and gettext.GNUTranslations classes as well as Babels Translations class are supported.
Install dummy gettext functions. This is useful if you want to prepare the application for internationalization but don’t want to implement the full internationalization system yet.
Uninstall the translations again.

Extract localizable strings from the given template node or source.

For every string found this function yields a (lineno, function, message) tuple, where:

  • lineno is the number of the line on which the string was found,
  • function is the name of the gettext function used (if the string was extracted from embedded Python code), and
  • message is the string itself (a unicode object, or a tuple of unicode objects for functions with multiple string arguments).

If Babel is installed the babel integration can be used to extract strings for babel.

For a web application that is available in multiple languages but gives all the users the same language (for example a multilingual forum software installed for a French community) may load the translations once and add the translation methods to the environment at environment generation time:

translations = get_gettext_translations()
env = Environment(extensions=['jinja2.ext.i18n'])

The get_gettext_translations function would return the translator for the current configuration. (For example by using gettext.find)

The usage of the i18n extension for template designers is covered as part of the template documentation.

Expression Statement

Import name: jinja2.ext.do

The “do” aka expression-statement extension adds a simple do tag to the template engine that works like a variable expression but ignores the return value.

Loop Controls

Import name: jinja2.ext.loopcontrols

This extension adds support for break and continue in loops. After enabling Jinja2 provides those two keywords which work exactly like in Python.

Writing Extensions

By writing extensions you can add custom tags to Jinja2. This is a non trival task and usually not needed as the default tags and expressions cover all common use cases. The i18n extension is a good example of why extensions are useful, another one would be fragment caching.

When writing extensions you have to keep in mind that you are working with the Jinja2 template compiler which does not validate the node tree you are possing to it. If the AST is malformed you will get all kinds of compiler or runtime errors that are horrible to debug. Always make sure you are using the nodes you create correctly. The API documentation below shows which nodes exist and how to use them.

Example Extension

The following example implements a cache tag for Jinja2 by using the Werkzeug caching contrib module:

from jinja2 import nodes
from jinja2.ext import Extension

class FragmentCacheExtension(Extension):
    # a set of names that trigger the extension.
    tags = set(['cache'])

    def __init__(self, environment):
        super(FragmentCacheExtension, self).__init__(environment)

        # add the defaults to the environment

    def parse(self, parser):
        # the first token is the token that started the tag.  In our case
        # we only listen to ``'cache'`` so this will be a name token with
        # `cache` as value.  We get the line number so that we can give
        # that line number to the nodes we create by hand.
        lineno = parser.stream.next().lineno

        # now we parse a single expression that is used as cache key.
        args = [parser.parse_expression()]

        # if there is a comma, the user provided a timeout.  If not use
        # None as second parameter.
        if parser.stream.skip_if('comma'):

        # now we parse the body of the cache block up to `endcache` and
        # drop the needle (which would always be `endcache` in that case)
        body = parser.parse_statements(['name:endcache'], drop_needle=True)

        # now return a `CallBlock` node that calls our _cache_support
        # helper method on this extension.
        return nodes.CallBlock(self.call_method('_cache_support', args),
                               [], [], body).set_lineno(lineno)

    def _cache_support(self, name, timeout, caller):
        """Helper callback."""
        key = self.environment.fragment_cache_prefix + name

        # try to load the block from the cache
        # if there is no fragment in the cache, render it and store
        # it in the cache.
        rv = self.environment.fragment_cache.get(key)
        if rv is not None:
            return rv
        rv = caller()
        self.environment.fragment_cache.add(key, rv, timeout)
        return rv

And here is how you use it in an environment:

from jinja2 import Environment
from werkzeug.contrib.cache import SimpleCache

env = Environment(extensions=[FragmentCacheExtension])
env.fragment_cache = SimpleCache()

Inside the template it’s then possible to mark blocks as cacheable. The following example caches a sidebar for 300 seconds:

{% cache 'sidebar', 300 %}
<div class="sidebar">
{% endcache %}

Extension API

Extensions always have to extend the jinja2.ext.Extension class:

class jinja2.ext.Extension(environment)

Extensions can be used to add extra functionality to the Jinja template system at the parser level. Custom extensions are bound to an environment but may not store environment specific data on self. The reason for this is that an extension can be bound to another environment (for overlays) by creating a copy and reassigning the environment attribute.

As extensions are created by the environment they cannot accept any arguments for configuration. One may want to work around that by using a factory function, but that is not possible as extensions are identified by their import name. The correct way to configure the extension is storing the configuration values on the environment. Because this way the environment ends up acting as central configuration storage the attributes may clash which is why extensions have to ensure that the names they choose for configuration are not too generic. prefix for example is a terrible name, fragment_cache_prefix on the other hand is a good name as includes the name of the extension (fragment cache).

The identifier of the extension. This is always the true import name of the extension class and must not be changed.
If the extension implements custom tags this is a set of tag names the extension is listening for.
preprocess(source, name, filename=None)
This method is called before the actual lexing and can be used to preprocess the source. The filename is optional. The return value must be the preprocessed source.

It’s passed a TokenStream that can be used to filter tokens returned. This method has to return an iterable of Tokens, but it doesn’t have to return a TokenStream.

In the ext folder of the Jinja2 source distribution there is a file called inlinegettext.py which implements a filter that utilizes this method.

If any of the tags matched this method is called with the parser as first argument. The token the parser stream is pointing at is the name token that matched. This method has to return one or a list of multiple nodes.
attr(name, lineno=None)

Return an attribute node for the current extension. This is useful to pass constants on extensions to generated template code:

self.attr('_my_attribute', lineno=lineno)
call_method(name, args=None, kwargs=None, dyn_args=None, dyn_kwargs=None, lineno=None)
Call a method of the extension. This is a shortcut for attr() + jinja2.nodes.Call.

Parser API

The parser passed to Extension.parse() provides ways to parse expressions of different types. The following methods may be used by extensions:

class jinja2.parser.Parser(environment, source, name=None, filename=None, state=None)

This is the central parsing class Jinja2 uses. It’s passed to extensions and can be used to parse expressions or statements.

The filename of the template the parser processes. This is not the load name of the template. For the load name see name. For templates that were not loaded form the file system this is None.
The load name of the template.
The current TokenStream
Parse an expression. Per default all expressions are parsed, if the optional with_condexpr parameter is set to False conditional expressions are not parsed.
parse_tuple(simplified=False, with_condexpr=True, extra_end_rules=None)

Works like parse_expression but if multiple expressions are delimited by a comma a Tuple node is created. This method could also return a regular expression instead of a tuple if no commas where found.

The default parsing mode is a full tuple. If simplified is True only names and literals are parsed. The no_condexpr parameter is forwarded to parse_expression().

Because tuples do not require delimiters and may end in a bogus comma an extra hint is needed that marks the end of a tuple. For example for loops support tuples between for and in. In that case the extra_end_rules is set to ['name:in'].

parse_assign_target(with_tuple=True, name_only=False, extra_end_rules=None)
Parse an assignment target. As Jinja2 allows assignments to tuples, this function can parse all allowed assignment targets. Per default assignments to tuples are parsed, that can be disable however by setting with_tuple to False. If only assignments to names are wanted name_only can be set to True. The extra_end_rules parameter is forwarded to the tuple parsing function.
parse_statements(end_tokens, drop_needle=False)
Parse multiple statements into a list until one of the end tokens is reached. This is used to parse the body of statements as it also parses template data if appropriate. The parser checks first if the current token is a colon and skips it if there is one. Then it checks for the block end and parses until if one of the end_tokens is reached. Per default the active token in the stream at the end of the call is the matched end token. If this is not wanted drop_needle can be set to True and the end token is removed.
Return a new free identifier as InternalName.
fail(msg, lineno=None, exc=<class 'jinja2.exceptions.TemplateSyntaxError'>)
Convenience method that raises exc with the message, passed line number or last line number as well as the current name and filename.
class jinja2.lexer.TokenStream(generator, name, filename)

A token stream is an iterable that yields Tokens. The parser however does not iterate over it but calls next() to go one token ahead. The current active token is stored as current.

The current Token.
Push a token back to the stream.
Look at the next token.
Are we at the end of the stream?
Got n tokens ahead.
Go one token ahead and return the old one
Perform the token test and return the token if it matched. Otherwise the return value is None.
Like next_if() but only returns True or False.
Expect a given token type and return it. This accepts the same argument as jinja2.lexer.Token.test().
class jinja2.lexer.Token

Token class.

The line number of the token
The type of the token. This string is interned so you may compare it with arbitrary strings using the is operator.
The value of the token.
Test a token against a token expression. This can either be a token type or 'token_type:token_value'. This can only test against string values and types.
Test against multiple token expressions.

There is also a utility function in the lexer module that can count newline characters in strings:

Count the number of newline characters in the string. This is useful for extensions that filter a stream.


The AST (Abstract Syntax Tree) is used to represent a template after parsing. It’s build of nodes that the compiler then converts into executable Python code objects. Extensions that provide custom statements can return nodes to execute custom Python code.

The list below describes all nodes that are currently available. The AST may change between Jinja2 versions but will stay backwards compatible.

For more information have a look at the repr of jinja2.Environment.parse().

class jinja2.nodes.Node

Baseclass for all Jinja2 nodes. There are a number of nodes available of different types. There are three major types:

All nodes have fields and attributes. Fields may be other nodes, lists, or arbitrary values. Fields are passed to the constructor as regular positional arguments, attributes as keyword arguments. Each node has two attributes: lineno (the line number of the node) and environment. The environment attribute is set at the end of the parsing process for all nodes automatically.

Find the first node of a given type. If no such node exists the return value is None.
Find all the nodes of a given type. If the type is a tuple, the check is performed for any of the tuple items.
iter_child_nodes(exclude=None, only=None)
Iterates over all direct child nodes of the node. This iterates over all fields and yields the values of they are nodes. If the value of a field is a list all the nodes in that list are returned.
iter_fields(exclude=None, only=None)
This method iterates over all fields that are defined and yields (key, value) tuples. Per default all fields are returned, but it’s possible to limit that to some fields by providing the only parameter or to exclude some using the exclude parameter. Both should be sets or tuples of field names.
Reset the context of a node and all child nodes. Per default the parser will all generate nodes that have a ‘load’ context as it’s the most common one. This method is used in the parser to set assignment targets and other nodes to a store context.
Set the environment for all nodes.
set_lineno(lineno, override=False)
Set the line numbers of the node and children.
class jinja2.nodes.Expr

Baseclass for all expressions.

Node type:Node

Return the value of the expression as constant or raise Impossible if this was not possible:

>>> Add(Const(23), Const(42)).as_const()
>>> Add(Const(23), Name('var', 'load')).as_const()
Traceback (most recent call last):

This requires the environment attribute of all nodes to be set to the environment that created the nodes.

Check if it’s possible to assign something to this node.
class jinja2.nodes.BinExpr(left, right)

Baseclass for all binary expressions.

Node type:Expr
class jinja2.nodes.Add(left, right)

Add the left to the right node.

Node type:BinExpr
class jinja2.nodes.And(left, right)

Short circuited AND.

Node type:BinExpr
class jinja2.nodes.Div(left, right)

Divides the left by the right node.

Node type:BinExpr
class jinja2.nodes.FloorDiv(left, right)

Divides the left by the right node and truncates conver the result into an integer by truncating.

Node type:BinExpr
class jinja2.nodes.Mod(left, right)

Left modulo right.

Node type:BinExpr
class jinja2.nodes.Mul(left, right)

Multiplies the left with the right node.

Node type:BinExpr
class jinja2.nodes.Or(left, right)

Short circuited OR.

Node type:BinExpr
class jinja2.nodes.Pow(left, right)

Left to the power of right.

Node type:BinExpr
class jinja2.nodes.Sub(left, right)

Substract the right from the left node.

Node type:BinExpr
class jinja2.nodes.Call(node, args, kwargs, dyn_args, dyn_kwargs)

Calls an expression. args is a list of arguments, kwargs a list of keyword arguments (list of Keyword nodes), and dyn_args and dyn_kwargs has to be either None or a node that is used as node for dynamic positional (*args) or keyword (**kwargs) arguments.

Node type:Expr
class jinja2.nodes.Compare(expr, ops)

Compares an expression with some other expressions. ops must be a list of Operands.

Node type:Expr
class jinja2.nodes.Concat(nodes)

Concatenates the list of expressions provided after converting them to unicode.

Node type:Expr
class jinja2.nodes.CondExpr(test, expr1, expr2)

A conditional expression (inline if expression). ({{ foo if bar else baz }})

Node type:Expr
class jinja2.nodes.ContextReference

Returns the current template context.

Node type:Expr
class jinja2.nodes.EnvironmentAttribute(name)

Loads an attribute from the environment object. This is useful for extensions that want to call a callback stored on the environment.

Node type:Expr
class jinja2.nodes.ExtensionAttribute(identifier, name)

Returns the attribute of an extension bound to the environment. The identifier is the identifier of the Extension.

This node is usually constructed by calling the attr() method on an extension.

Node type:Expr
class jinja2.nodes.Filter(node, name, args, kwargs, dyn_args, dyn_kwargs)

This node applies a filter on an expression. name is the name of the filter, the rest of the fields are the same as for Call.

If the node of a filter is None the contents of the last buffer are filtered. Buffers are created by macros and filter blocks.

Node type:Expr
class jinja2.nodes.Getattr(node, attr, ctx)

Get an attribute or item from an expression that is a ascii-only bytestring and prefer the attribute.

Node type:Expr
class jinja2.nodes.Getitem(node, arg, ctx)

Get an attribute or item from an expression and prefer the item.

Node type:Expr
class jinja2.nodes.ImportedName(importname)

If created with an import name the import name is returned on node access. For example ImportedName('cgi.escape') returns the escape function from the cgi module on evaluation. Imports are optimized by the compiler so there is no need to assign them to local variables.

Node type:Expr
class jinja2.nodes.InternalName(name)

An internal name in the compiler. You cannot create these nodes yourself but the parser provides a free_identifier() method that creates a new identifier for you. This identifier is not available from the template and is not threated specially by the compiler.

Node type:Expr
class jinja2.nodes.Literal

Baseclass for literals.

Node type:Expr
class jinja2.nodes.Const(value)

All constant values. The parser will return this node for simple constants such as 42 or "foo" but it can be used to store more complex values such as lists too. Only constants with a safe representation (objects where eval(repr(x)) == x is true).

Node type:Literal
class jinja2.nodes.Dict(items)

Any dict literal such as {1: 2, 3: 4}. The items must be a list of Pair nodes.

Node type:Literal
class jinja2.nodes.List(items)

Any list literal such as [1, 2, 3]

Node type:Literal
class jinja2.nodes.TemplateData(data)

A constant template string.

Node type:Literal
class jinja2.nodes.Tuple(items, ctx)

For loop unpacking and some other things like multiple arguments for subscripts. Like for Name ctx specifies if the tuple is used for loading the names or storing.

Node type:Literal
class jinja2.nodes.MarkSafe(expr)

Mark the wrapped expression as safe (wrap it as Markup).

Node type:Expr
class jinja2.nodes.Name(name, ctx)

Looks up a name or stores a value in a name. The ctx of the node can be one of the following values:

  • store: store a value in the name
  • load: load that name
  • param: like store but if the name was defined as function parameter.
Node type:Expr
class jinja2.nodes.Slice(start, stop, step)

Represents a slice object. This must only be used as argument for Subscript.

Node type:Expr
class jinja2.nodes.Test(node, name, args, kwargs, dyn_args, dyn_kwargs)

Applies a test on an expression. name is the name of the test, the rest of the fields are the same as for Call.

Node type:Expr
class jinja2.nodes.UnaryExpr(node)

Baseclass for all unary expressions.

Node type:Expr
class jinja2.nodes.Neg(node)

Make the expression negative.

Node type:UnaryExpr
class jinja2.nodes.Not(node)

Negate the expression.

Node type:UnaryExpr
class jinja2.nodes.Pos(node)

Make the expression positive (noop for most expressions)

Node type:UnaryExpr
class jinja2.nodes.Helper

Nodes that exist in a specific context only.

Node type:Node
class jinja2.nodes.Keyword(key, value)

A key, value pair for keyword arguments where key is a string.

Node type:Helper
class jinja2.nodes.Operand(op, expr)

Holds an operator and an expression. The following operators are available: %, **, *, +, -, //, /, eq, gt, gteq, in, lt, lteq, ne, not, notin

Node type:Helper
class jinja2.nodes.Pair(key, value)

A key, value pair for dicts.

Node type:Helper
class jinja2.nodes.Stmt

Base node for all statements.

Node type:Node
class jinja2.nodes.Assign(target, node)

Assigns an expression to a target.

Node type:Stmt
class jinja2.nodes.Block(name, body, scoped)

A node that represents a block.

Node type:Stmt
class jinja2.nodes.Break

Break a loop.

Node type:Stmt
class jinja2.nodes.CallBlock(call, args, defaults, body)

Like a macro without a name but a call instead. call is called with the unnamed macro as caller argument this node holds.

Node type:Stmt
class jinja2.nodes.Continue

Continue a loop.

Node type:Stmt
class jinja2.nodes.ExprStmt(node)

A statement that evaluates an expression and discards the result.

Node type:Stmt
class jinja2.nodes.Extends(template)

Represents an extends statement.

Node type:Stmt
class jinja2.nodes.FilterBlock(body, filter)

Node for filter sections.

Node type:Stmt
class jinja2.nodes.For(target, iter, body, else_, test, recursive)

The for loop. target is the target for the iteration (usually a Name or Tuple), iter the iterable. body is a list of nodes that are used as loop-body, and else_ a list of nodes for the else block. If no else node exists it has to be an empty list.

For filtered nodes an expression can be stored as test, otherwise None.

Node type:Stmt
class jinja2.nodes.FromImport(template, names, with_context)

A node that represents the from import tag. It’s important to not pass unsafe names to the name attribute. The compiler translates the attribute lookups directly into getattr calls and does not use the subscript callback of the interface. As exported variables may not start with double underscores (which the parser asserts) this is not a problem for regular Jinja code, but if this node is used in an extension extra care must be taken.

The list of names may contain tuples if aliases are wanted.

Node type:Stmt
class jinja2.nodes.If(test, body, else_)

If test is true, body is rendered, else else_.

Node type:Stmt
class jinja2.nodes.Import(template, target, with_context)

A node that represents the import tag.

Node type:Stmt
class jinja2.nodes.Include(template, with_context, ignore_missing)

A node that represents the include tag.

Node type:Stmt
class jinja2.nodes.Macro(name, args, defaults, body)

A macro definition. name is the name of the macro, args a list of arguments and defaults a list of defaults if there are any. body is a list of nodes for the macro body.

Node type:Stmt
class jinja2.nodes.Output(nodes)

A node that holds multiple expressions which are then printed out. This is used both for the print statement and the regular template data.

Node type:Stmt</