def __init__(self, templates, cache, cache_dir):
# PERF: This function is simply constructing a Jinja environment and
# would be trivial, except that we optimise re-execution of template
# code by compiling the templates to Python bytecode the first time
# they are seen. This happens when the compilation cache is enabled and
# should speed the execution of the template code itself in future
# runs.
self.templates = templates
# Directory in which to store and fetch pre-compiled Jinja2 templates.
template_cache = os.path.join(cache_dir, version(),
'precompiled-templates')
loaders = []
if cache and os.path.exists(template_cache):
# Pre-compiled templates.
loaders.append(jinja2.ModuleLoader(template_cache))
# Source templates.
loaders.extend(
jinja2.FileSystemLoader(os.path.abspath(x))
for x in templates.get_roots())
self.env = jinja2.Environment(
loader=jinja2.ChoiceLoader(loaders),
extensions=["jinja2.ext.do", "jinja2.ext.loopcontrols"],
block_start_string=START_BLOCK,
block_end_string=END_BLOCK,
variable_start_string=START_VARIABLE,
variable_end_string=END_VARIABLE,
comment_start_string=START_COMMENT,
comment_end_string=END_COMMENT,
auto_reload=False,
undefined=jinja2.StrictUndefined)
if cache and not os.path.exists(template_cache):
# The pre-compiled template cache is enabled but does not exist.
# We build it here for next time.
# We filter the templates that Jinja compiles to only the ones we
# know of in order to avoid errors or wasted time on other stray
# garbage in the template directory (vim swp files, pycs, ...).
templates = list(get_leaves(TEMPLATES))
mkdirp(template_cache)
# Compile the templates. Note that we only compile them to PYCs on
# Python 2, because this has no effect on Python 3 or PyPy.
self.env.compile_templates(
template_cache,
filter_func=(lambda x: x in templates),
zip=None,
ignore_errors=False,
py_compile=platform.python_implementation() == 'CPython'
and six.PY2)
def __init__(self, templates, cache, cache_dir):
# PERF: This function is simply constructing a Jinja environment and
# would be trivial, except that we optimise re-execution of template
# code by compiling the templates to Python bytecode the first time
# they are seen. This happens when the compilation cache is enabled and
# should speed the execution of the template code itself in future
# runs.
self.templates = templates
# Directory in which to store and fetch pre-compiled Jinja2 templates.
template_cache = os.path.join(cache_dir, version(),
'precompiled-templates')
loaders = []
if cache and os.path.exists(template_cache):
# Pre-compiled templates.
loaders.append(jinja2.ModuleLoader(template_cache))
# Source templates.
loaders.extend(jinja2.FileSystemLoader(os.path.abspath(x)) for x in
templates.get_roots())
self.env = jinja2.Environment(
loader=jinja2.ChoiceLoader(loaders),
extensions=["jinja2.ext.do", "jinja2.ext.loopcontrols"],
block_start_string=START_BLOCK,
block_end_string=END_BLOCK,
variable_start_string=START_VARIABLE,
variable_end_string=END_VARIABLE,
comment_start_string=START_COMMENT,
comment_end_string=END_COMMENT,
auto_reload=False,
undefined=jinja2.StrictUndefined)
if cache and not os.path.exists(template_cache):
# The pre-compiled template cache is enabled but does not exist.
# We build it here for next time.
# We filter the templates that Jinja compiles to only the ones we
# know of in order to avoid errors or wasted time on other stray
# garbage in the template directory (vim swp files, pycs, ...).
templates = list(get_leaves(TEMPLATES))
mkdirp(template_cache)
# Compile the templates. Note that we only compile them to PYCs on
# Python 2, because this has no effect on Python 3 or PyPy.
self.env.compile_templates(template_cache,
filter_func=(lambda x: x in templates), zip=None,
ignore_errors=False, py_compile=
platform.python_implementation() == 'CPython' and six.PY2)
def __init__(self, template_paths, options):
# PERF: This function is simply constructing a Jinja environment and
# would be trivial, except that we optimise re-execution of template
# code by compiling the templates to Python bytecode the first time
# they are seen. This happens when the compilation cache is enabled and
# should speed the execution of the template code itself in future
# runs.
# Directory in which to store and fetch pre-compiled Jinja2 templates.
template_cache = os.path.join(options.cache_dir, version_hash(),
'precompiled-templates')
loaders = []
if options.cache in ['on', 'readonly'] and \
os.path.exists(template_cache):
# Pre-compiled templates.
loaders.append(jinja2.ModuleLoader(template_cache))
# Source templates.
loaders.extend(
map(jinja2.FileSystemLoader,
[os.path.abspath(x) for x in template_paths]))
self.env = jinja2.Environment(
loader=jinja2.ChoiceLoader(loaders),
extensions=["jinja2.ext.do", "jinja2.ext.loopcontrols"],
block_start_string=START_BLOCK,
block_end_string=END_BLOCK,
variable_start_string=START_VARIABLE,
variable_end_string=END_VARIABLE,
comment_start_string=START_COMMENT,
comment_end_string=END_COMMENT,
auto_reload=False)
if options.cache in ['on', 'writeonly'] and \
not os.path.exists(template_cache):
# The pre-compiled template cache is enabled but does not exist.
# We build it here for next time.
# We filter the templates that Jinja compiles to only the ones we
# know of in order to avoid errors or wasted time on other stray
# garbage in the template directory (vim swp files, pycs, ...).
templates = list(get_leaves(TEMPLATES))
mkdirp(template_cache)
self.env.compile_templates(template_cache,
filter_func=(lambda x: x in templates),
zip=None,
ignore_errors=False,
py_compile=True)
def __init__(self, template_paths, options):
# PERF: This function is simply constructing a Jinja environment and
# would be trivial, except that we optimise re-execution of template
# code by compiling the templates to Python bytecode the first time
# they are seen. This happens when the compilation cache is enabled and
# should speed the execution of the template code itself in future
# runs.
# Directory in which to store and fetch pre-compiled Jinja2 templates.
template_cache = os.path.join(options.cache_dir, version(),
'precompiled-templates')
loaders = []
if options.cache in ['on', 'readonly'] and \
os.path.exists(template_cache):
# Pre-compiled templates.
loaders.append(jinja2.ModuleLoader(template_cache))
# Source templates.
loaders.extend(map(jinja2.FileSystemLoader,
[os.path.abspath(x) for x in template_paths]))
self.env = jinja2.Environment(
loader=jinja2.ChoiceLoader(loaders),
extensions=["jinja2.ext.do", "jinja2.ext.loopcontrols"],
block_start_string=START_BLOCK,
block_end_string=END_BLOCK,
variable_start_string=START_VARIABLE,
variable_end_string=END_VARIABLE,
comment_start_string=START_COMMENT,
comment_end_string=END_COMMENT,
auto_reload=False)
if options.cache in ['on', 'writeonly'] and \
not os.path.exists(template_cache):
# The pre-compiled template cache is enabled but does not exist.
# We build it here for next time.
# We filter the templates that Jinja compiles to only the ones we
# know of in order to avoid errors or wasted time on other stray
# garbage in the template directory (vim swp files, pycs, ...).
templates = list(get_leaves(TEMPLATES))
mkdirp(template_cache)
self.env.compile_templates(template_cache,
filter_func=(lambda x: x in templates), zip=None,
ignore_errors=False, py_compile=True)