def __init__(
self,
block_start_string="{%",
block_end_string="%}",
variable_start_string="{{",
variable_end_string="}}",
comment_start_string="{#",
comment_end_string="#}",
trim_blocks=False,
auto_escape=False,
default_filters=None,
template_charset="utf-8",
charset="utf-8",
namespace=None,
loader=None,
filters=None,
tests=None,
context_class=Context,
undefined_singleton=SilentUndefined,
disable_regexps=False,
friendly_traceback=True,
translator_factory=None,
template_translator=PythonTranslator,
):
"""
Here the possible initialization parameters:
========================= ============================================
`block_start_string` * the string marking the begin of a block.
this defaults to ``'{%'``.
`block_end_string` * the string marking the end of a block.
defaults to ``'%}'``.
`variable_start_string` * the string marking the begin of a print
statement. defaults to ``'{{'``.
`comment_start_string` * the string marking the begin of a
comment. defaults to ``'{#'``.
`comment_end_string` * the string marking the end of a comment.
defaults to ``'#}'``.
`trim_blocks` * If this is set to ``True`` the first newline
after a block is removed (block, not
variable tag!). Defaults to ``False``.
`auto_escape` If this is set to ``True`` Jinja will
automatically escape all variables using xml
escaping methods. If you don't want to
escape a string you have to wrap it in a
``Markup`` object from the
``jinja.datastructure`` module. If
`auto_escape` is ``True`` there will be also
a ``Markup`` object in the template
namespace to define partial html fragments.
Note that we do not recommend this feature.
`default_filters` list of tuples in the form (``filter_name``,
``arguments``) where ``filter_name`` is the
name of a registered filter and
``arguments`` a tuple with the filter
arguments. The filters specified here will
always be applied when printing data to the
template. *new in Jinja 1.1*
`template_charset` The charset of the templates. Defaults
to ``'utf-8'``.
`charset` Charset of all string input data. Defaults
to ``'utf-8'``.
`namespace` Global namespace for all templates.
`loader` Specify a template loader.
`filters` dict of filters or the default filters if
not defined.
`tests` dict of tests of the default tests if not
defined.
`context_class` the context class this template should use.
See the `Context` documentation for more
details.
`undefined_singleton` The singleton value that is used for missing
variables. *new in Jinja 1.1*
`disable_regexps` Disable support for regular expresssions.
`friendly_traceback` Set this to `False` to disable the developer
friendly traceback rewriting. Whenever an
runtime or syntax error occours jinja will
try to make a developer friendly traceback
that shows the error in the template line.
This however can be annoying when debugging
broken functions that are called from the
template. *new in Jinja 1.1*
`translator_factory` A callback function that is called with
the context as first argument to get the
translator for the current instance.
*new in Jinja 1.2*
`template_translator` An class that defines a static method called
process which can be used to process the
template's AST into a compiled python module.
*new in Jinja 1.2*
========================= ============================================
All of these variables except those marked with a star (*) are
modifiable after environment initialization.
"""
# lexer / parser information
self.block_start_string = block_start_string
self.block_end_string = block_end_string
self.variable_start_string = variable_start_string
self.variable_end_string = variable_end_string
self.comment_start_string = comment_start_string
self.comment_end_string = comment_end_string
self.trim_blocks = trim_blocks
# other stuff
self.template_charset = template_charset
self.charset = charset
self.loader = loader
if filters is None:
filters = DEFAULT_FILTERS.copy()
self.filters = filters
if tests is None:
tests = DEFAULT_TESTS.copy()
self.tests = tests
self.default_filters = default_filters or []
self.context_class = context_class
self.undefined_singleton = undefined_singleton
self.disable_regexps = disable_regexps
self.friendly_traceback = friendly_traceback
# global namespace
if namespace is None:
namespace = DEFAULT_NAMESPACE.copy()
self.globals = namespace
# jinja 1.0 compatibility
if auto_escape:
self.default_filters.append(("escape", (True,)))
self.globals["Markup"] = Markup
# and here the translator factory
self.translator_factory = translator_factory
# and here the AST translator
self.template_translator = template_translator
# create lexer
self.lexer = Lexer(self)
def __init__(self,
block_start_string='{%',
block_end_string='%}',
variable_start_string='{{',
variable_end_string='}}',
comment_start_string='{#',
comment_end_string='#}',
trim_blocks=False,
auto_escape=False,
default_filters=None,
template_charset='utf-8',
charset='utf-8',
namespace=None,
loader=None,
filters=None,
tests=None,
context_class=Context,
undefined_singleton=SilentUndefined,
disable_regexps=False,
friendly_traceback=True,
translator_factory=None):
"""
Here the possible initialization parameters:
========================= ============================================
`block_start_string` * the string marking the begin of a block.
this defaults to ``'{%'``.
`block_end_string` * the string marking the end of a block.
defaults to ``'%}'``.
`variable_start_string` * the string marking the begin of a print
statement. defaults to ``'{{'``.
`comment_start_string` * the string marking the begin of a
comment. defaults to ``'{#'``.
`comment_end_string` * the string marking the end of a comment.
defaults to ``'#}'``.
`trim_blocks` * If this is set to ``True`` the first newline
after a block is removed (block, not
variable tag!). Defaults to ``False``.
`auto_escape` If this is set to ``True`` Jinja will
automatically escape all variables using xml
escaping methods. If you don't want to
escape a string you have to wrap it in a
``Markup`` object from the
``jinja.datastructure`` module. If
`auto_escape` is ``True`` there will be also
a ``Markup`` object in the template
namespace to define partial html fragments.
Note that we do not recommend this feature.
`default_filters` list of tuples in the form (``filter_name``,
``arguments``) where ``filter_name`` is the
name of a registered filter and
``arguments`` a tuple with the filter
arguments. The filters specified here will
always be applied when printing data to the
template. *new in Jinja 1.1*
`template_charset` The charset of the templates. Defaults
to ``'utf-8'``.
`charset` Charset of all string input data. Defaults
to ``'utf-8'``.
`namespace` Global namespace for all templates.
`loader` Specify a template loader.
`filters` dict of filters or the default filters if
not defined.
`tests` dict of tests of the default tests if not
defined.
`context_class` the context class this template should use.
See the `Context` documentation for more
details.
`undefined_singleton` The singleton value that is used for missing
variables. *new in Jinja 1.1*
`disable_regexps` Disable support for regular expresssions.
`friendly_traceback` Set this to `False` to disable the developer
friendly traceback rewriting. Whenever an
runtime or syntax error occours jinja will
try to make a developer friendly traceback
that shows the error in the template line.
This however can be annoying when debugging
broken functions that are called from the
template. *new in Jinja 1.1*
`translator_factory` A callback function that is called with
the context as first argument to get the
translator for the current instance.
*new in Jinja 1.2*
========================= ============================================
All of these variables except those marked with a star (*) are
modifiable after environment initialization.
"""
# lexer / parser information
self.block_start_string = block_start_string
self.block_end_string = block_end_string
self.variable_start_string = variable_start_string
self.variable_end_string = variable_end_string
self.comment_start_string = comment_start_string
self.comment_end_string = comment_end_string
self.trim_blocks = trim_blocks
# other stuff
self.template_charset = template_charset
self.charset = charset
self.loader = loader
if filters is None:
filters = DEFAULT_FILTERS.copy()
self.filters = filters
if tests is None:
tests = DEFAULT_TESTS.copy()
self.tests = tests
self.default_filters = default_filters or []
self.context_class = context_class
self.undefined_singleton = undefined_singleton
self.disable_regexps = disable_regexps
self.friendly_traceback = friendly_traceback
# global namespace
if namespace is None:
namespace = DEFAULT_NAMESPACE.copy()
self.globals = namespace
# jinja 1.0 compatibility
if auto_escape:
self.default_filters.append(('escape', (True, )))
self.globals['Markup'] = Markup
# and here the translator factory
self.translator_factory = translator_factory
# create lexer
self.lexer = Lexer(self)
class Environment(object):
"""
The Jinja environment.
The core component of Jinja is the `Environment`. It contains
important shared variables like configuration, filters, tests,
globals and others.
"""
def __init__(
self,
block_start_string="{%",
block_end_string="%}",
variable_start_string="{{",
variable_end_string="}}",
comment_start_string="{#",
comment_end_string="#}",
trim_blocks=False,
auto_escape=False,
default_filters=None,
template_charset="utf-8",
charset="utf-8",
namespace=None,
loader=None,
filters=None,
tests=None,
context_class=Context,
undefined_singleton=SilentUndefined,
disable_regexps=False,
friendly_traceback=True,
translator_factory=None,
template_translator=PythonTranslator,
):
"""
Here the possible initialization parameters:
========================= ============================================
`block_start_string` * the string marking the begin of a block.
this defaults to ``'{%'``.
`block_end_string` * the string marking the end of a block.
defaults to ``'%}'``.
`variable_start_string` * the string marking the begin of a print
statement. defaults to ``'{{'``.
`comment_start_string` * the string marking the begin of a
comment. defaults to ``'{#'``.
`comment_end_string` * the string marking the end of a comment.
defaults to ``'#}'``.
`trim_blocks` * If this is set to ``True`` the first newline
after a block is removed (block, not
variable tag!). Defaults to ``False``.
`auto_escape` If this is set to ``True`` Jinja will
automatically escape all variables using xml
escaping methods. If you don't want to
escape a string you have to wrap it in a
``Markup`` object from the
``jinja.datastructure`` module. If
`auto_escape` is ``True`` there will be also
a ``Markup`` object in the template
namespace to define partial html fragments.
Note that we do not recommend this feature.
`default_filters` list of tuples in the form (``filter_name``,
``arguments``) where ``filter_name`` is the
name of a registered filter and
``arguments`` a tuple with the filter
arguments. The filters specified here will
always be applied when printing data to the
template. *new in Jinja 1.1*
`template_charset` The charset of the templates. Defaults
to ``'utf-8'``.
`charset` Charset of all string input data. Defaults
to ``'utf-8'``.
`namespace` Global namespace for all templates.
`loader` Specify a template loader.
`filters` dict of filters or the default filters if
not defined.
`tests` dict of tests of the default tests if not
defined.
`context_class` the context class this template should use.
See the `Context` documentation for more
details.
`undefined_singleton` The singleton value that is used for missing
variables. *new in Jinja 1.1*
`disable_regexps` Disable support for regular expresssions.
`friendly_traceback` Set this to `False` to disable the developer
friendly traceback rewriting. Whenever an
runtime or syntax error occours jinja will
try to make a developer friendly traceback
that shows the error in the template line.
This however can be annoying when debugging
broken functions that are called from the
template. *new in Jinja 1.1*
`translator_factory` A callback function that is called with
the context as first argument to get the
translator for the current instance.
*new in Jinja 1.2*
`template_translator` An class that defines a static method called
process which can be used to process the
template's AST into a compiled python module.
*new in Jinja 1.2*
========================= ============================================
All of these variables except those marked with a star (*) are
modifiable after environment initialization.
"""
# lexer / parser information
self.block_start_string = block_start_string
self.block_end_string = block_end_string
self.variable_start_string = variable_start_string
self.variable_end_string = variable_end_string
self.comment_start_string = comment_start_string
self.comment_end_string = comment_end_string
self.trim_blocks = trim_blocks
# other stuff
self.template_charset = template_charset
self.charset = charset
self.loader = loader
if filters is None:
filters = DEFAULT_FILTERS.copy()
self.filters = filters
if tests is None:
tests = DEFAULT_TESTS.copy()
self.tests = tests
self.default_filters = default_filters or []
self.context_class = context_class
self.undefined_singleton = undefined_singleton
self.disable_regexps = disable_regexps
self.friendly_traceback = friendly_traceback
# global namespace
if namespace is None:
namespace = DEFAULT_NAMESPACE.copy()
self.globals = namespace
# jinja 1.0 compatibility
if auto_escape:
self.default_filters.append(("escape", (True,)))
self.globals["Markup"] = Markup
# and here the translator factory
self.translator_factory = translator_factory
# and here the AST translator
self.template_translator = template_translator
# create lexer
self.lexer = Lexer(self)
def loader(self, value):
"""
Get or set the template loader.
"""
self._loader = LoaderWrapper(self, value)
loader = property(lambda s: s._loader, loader, doc=loader.__doc__)
def parse(self, source, filename=None):
"""
Parse the sourcecode and return the abstract syntax tree. This tree
of nodes is used by the `translators`_ to convert the template into
executable source- or bytecode.
.. _translators: translators.txt
"""
parser = Parser(self, source, filename)
return parser.parse()
def lex(self, source, filename=None):
"""
Lex the given sourcecode and return a generator that yields tokens.
The stream returned is not usable for Jinja but can be used if
Jinja templates should be processed by other tools (for example
syntax highlighting etc)
The tuples are returned in the form ``(lineno, token, value)``.
"""
return self.lexer.tokeniter(source, filename)
def from_string(self, source):
"""
Load and parse a template source and translate it into eval-able
Python code. This code is wrapped within a `Template` class that
allows you to render it.
"""
from jinja.translators.python import PythonTranslator
try:
rv = PythonTranslator.process(self, Parser(self, source).parse(), source)
except TemplateSyntaxError, e:
# on syntax errors rewrite the traceback if wanted
if not self.friendly_traceback:
raise
from jinja.debugger import raise_syntax_error
if __debug__:
__traceback_hide__ = True
raise_syntax_error(e, self, source)
else:
class Environment(object):
"""
The Jinja environment.
The core component of Jinja is the `Environment`. It contains
important shared variables like configuration, filters, tests,
globals and others.
"""
def __init__(self,
block_start_string='{%',
block_end_string='%}',
variable_start_string='{{',
variable_end_string='}}',
comment_start_string='{#',
comment_end_string='#}',
trim_blocks=False,
auto_escape=False,
default_filters=None,
template_charset='utf-8',
charset='utf-8',
namespace=None,
loader=None,
filters=None,
tests=None,
context_class=Context,
undefined_singleton=SilentUndefined,
disable_regexps=False,
friendly_traceback=True,
translator_factory=None):
"""
Here the possible initialization parameters:
========================= ============================================
`block_start_string` * the string marking the begin of a block.
this defaults to ``'{%'``.
`block_end_string` * the string marking the end of a block.
defaults to ``'%}'``.
`variable_start_string` * the string marking the begin of a print
statement. defaults to ``'{{'``.
`comment_start_string` * the string marking the begin of a
comment. defaults to ``'{#'``.
`comment_end_string` * the string marking the end of a comment.
defaults to ``'#}'``.
`trim_blocks` * If this is set to ``True`` the first newline
after a block is removed (block, not
variable tag!). Defaults to ``False``.
`auto_escape` If this is set to ``True`` Jinja will
automatically escape all variables using xml
escaping methods. If you don't want to
escape a string you have to wrap it in a
``Markup`` object from the
``jinja.datastructure`` module. If
`auto_escape` is ``True`` there will be also
a ``Markup`` object in the template
namespace to define partial html fragments.
Note that we do not recommend this feature.
`default_filters` list of tuples in the form (``filter_name``,
``arguments``) where ``filter_name`` is the
name of a registered filter and
``arguments`` a tuple with the filter
arguments. The filters specified here will
always be applied when printing data to the
template. *new in Jinja 1.1*
`template_charset` The charset of the templates. Defaults
to ``'utf-8'``.
`charset` Charset of all string input data. Defaults
to ``'utf-8'``.
`namespace` Global namespace for all templates.
`loader` Specify a template loader.
`filters` dict of filters or the default filters if
not defined.
`tests` dict of tests of the default tests if not
defined.
`context_class` the context class this template should use.
See the `Context` documentation for more
details.
`undefined_singleton` The singleton value that is used for missing
variables. *new in Jinja 1.1*
`disable_regexps` Disable support for regular expresssions.
`friendly_traceback` Set this to `False` to disable the developer
friendly traceback rewriting. Whenever an
runtime or syntax error occours jinja will
try to make a developer friendly traceback
that shows the error in the template line.
This however can be annoying when debugging
broken functions that are called from the
template. *new in Jinja 1.1*
`translator_factory` A callback function that is called with
the context as first argument to get the
translator for the current instance.
*new in Jinja 1.2*
========================= ============================================
All of these variables except those marked with a star (*) are
modifiable after environment initialization.
"""
# lexer / parser information
self.block_start_string = block_start_string
self.block_end_string = block_end_string
self.variable_start_string = variable_start_string
self.variable_end_string = variable_end_string
self.comment_start_string = comment_start_string
self.comment_end_string = comment_end_string
self.trim_blocks = trim_blocks
# other stuff
self.template_charset = template_charset
self.charset = charset
self.loader = loader
if filters is None:
filters = DEFAULT_FILTERS.copy()
self.filters = filters
if tests is None:
tests = DEFAULT_TESTS.copy()
self.tests = tests
self.default_filters = default_filters or []
self.context_class = context_class
self.undefined_singleton = undefined_singleton
self.disable_regexps = disable_regexps
self.friendly_traceback = friendly_traceback
# global namespace
if namespace is None:
namespace = DEFAULT_NAMESPACE.copy()
self.globals = namespace
# jinja 1.0 compatibility
if auto_escape:
self.default_filters.append(('escape', (True, )))
self.globals['Markup'] = Markup
# and here the translator factory
self.translator_factory = translator_factory
# create lexer
self.lexer = Lexer(self)
def loader(self, value):
"""
Get or set the template loader.
"""
self._loader = LoaderWrapper(self, value)
loader = property(lambda s: s._loader, loader, doc=loader.__doc__)
def parse(self, source, filename=None):
"""
Parse the sourcecode and return the abstract syntax tree. This tree
of nodes is used by the `translators`_ to convert the template into
executable source- or bytecode.
.. _translators: translators.txt
"""
parser = Parser(self, source, filename)
return parser.parse()
def lex(self, source, filename=None):
"""
Lex the given sourcecode and return a generator that yields tokens.
The stream returned is not usable for Jinja but can be used if
Jinja templates should be processed by other tools (for example
syntax highlighting etc)
The tuples are returned in the form ``(lineno, token, value)``.
"""
return self.lexer.tokeniter(source, filename)
def from_string(self, source):
"""
Load and parse a template source and translate it into eval-able
Python code. This code is wrapped within a `Template` class that
allows you to render it.
"""
from jinja.translators.python import PythonTranslator
try:
rv = PythonTranslator.process(self,
Parser(self, source).parse(), source)
except TemplateSyntaxError, e:
# on syntax errors rewrite the traceback if wanted
if not self.friendly_traceback:
raise
from jinja.debugger import raise_syntax_error
if __debug__:
__traceback_hide__ = True
raise_syntax_error(e, self, source)
else:
