def test_from_environ_not_set():
processor = JinjaTemplateProcessor("", None)
# overide the default loader
templates = {"test.sql": "some text {{ env_var('MYVAR') }}"}
processor.override_loader(DictLoader(templates))
with pytest.raises(ValueError) as e:
context = processor.render("test.sql", None, True)
assert str(
e.value
) == "Could not find environmental variable MYVAR and no default value was provided"
def __init__(self, error_type, message, template="error", **kwargs):
super(RESTError, self).__init__()
env = Environment(loader=DictLoader(self.templates))
self.error_type = error_type
self.message = message
self.description = env.get_template(template).render(
error_type=error_type,
message=message,
request_id_tag=self.request_id_tag_name,
**kwargs
)
self.content_type = "application/xml"
def test_env_async():
env = Environment(
loader=DictLoader(
dict(
module="{% macro test() %}[{{ foo }}|{{ bar }}]{% endmacro %}",
header="[{{ foo }}|{{ 23 }}]",
o_printer="({{ o }})",
)
),
enable_async=True,
)
env.globals["bar"] = 23
return env
def test_template_is_rendered_with_parameters():
jinja_env = jinja2.Environment(
loader=DictLoader(
{"example.html.jinja2": "", "example.text.jinja2": "hello {{ value }}"}
)
)
template = Template(
MagicMock(),
jinja_env.get_template("example.html.jinja2"),
jinja_env.get_template("example.text.jinja2"),
)
_, text = template.render({"value": "world"})
assert text == "hello world"
def env():
return Environment(
loader=DictLoader({
"layout": LAYOUTTEMPLATE,
"level1": LEVEL1TEMPLATE,
"level2": LEVEL2TEMPLATE,
"level3": LEVEL3TEMPLATE,
"level4": LEVEL4TEMPLATE,
"working": WORKINGTEMPLATE,
"doublee": DOUBLEEXTENDS,
}),
trim_blocks=True,
)
def configure_env(self, templates_dict=TEST_TEMPLATES, base_path='/'):
env = Environment(loader=DictLoader(templates_dict),
extensions=[
'statik.jinja2ext.StatikUrlExtension',
'statik.jinja2ext.StatikAssetExtension'
])
env.filters['date'] = filter_datetime
env.statik_base_url = base_path
env.statik_base_asset_url = add_url_path_component(
base_path,
'assets',
)
return env
def on_run(self, book, renderer, context):
for item in renderer.items:
path = os.path.dirname(item.path)
env = Environment(loader=ChoiceLoader([
DictLoader({'__markdown__': item.raw_text}),
ChapterLoader(item.path)
]),
autoescape=False)
template = env.get_template('__markdown__')
content = template.render(context.data)
item.raw_text = content
class TestWidgetWithCss(TkOutWidget):
strfield = StringField(default='str', max_length=5)
boolfield = BoolField(default=True)
intfield = IntField(default=10)
layout = "test.html"
loader = DictLoader({'test.html': layout_html, 'test.css': layout_css})
context = {'css_name': 'test.css', 'test_grid': False}
data_dict = {'button_text': 'test button'}
def test(self):
for b in self.select('button'):
b.config(text='change')
def test_custom_context(self, env):
from jinja2.runtime import Context
class MyContext(Context):
pass
class MyEnvironment(Environment):
context_class = MyContext
loader = DictLoader({'base': '{{ foobar }}',
'test': '{% extends "base" %}'})
env = MyEnvironment(loader=loader)
assert env.get_template('test').render(foobar='test') == 'test'
def test_in_memory_template_tplx(self):
# Loads in an in memory latex template (.tplx) using jinja2.DictLoader
# creates a class that uses this template with the template_file argument
# converts an empty notebook using this mechanism
my_loader_tplx = DictLoader(
{'my_template': "{%- extends 'article.tplx' -%}"})
class MyExporter(LatexExporter):
template_file = 'my_template'
exporter = MyExporter(extra_loaders=[my_loader_tplx])
nb = v4.new_notebook()
out, resources = exporter.from_notebook_node(nb)
def load_config(self):
config = configparser.ConfigParser(allow_no_value=True, interpolation=None)
if os.path.isfile(os.path.expanduser(self.dotfile)):
config.read_file(open(os.path.expanduser(self.dotfile)))
self.profiles = config.get('EC2SSH', 'profiles').split(',')
self.regions = config.get('EC2SSH', 'regions').split(',')
self.filters = [tuple(x.split(',')) for x in config.get('EC2SSH', 'filters').split('|')]
self.anti_filter = [tuple(x.split(',')) for x in config.get('EC2SSH', 'anti_filters').split('|')]
self.raw_template = config.get('TEMPLATE', 'template').split('\n')
template = [self.raw_template[0]] + ['\t\t{}'.format(x) for x in self.raw_template[1:]]
self.env = Environment(
loader=DictLoader({'default': '\n'.join(template)}),
enable_async=True
)
def test_multi_inheritance(self, env):
env = Environment(loader=DictLoader({
"default1":
"DEFAULT1{% block x %}{% endblock %}",
"default2":
"DEFAULT2{% block x %}{% endblock %}",
"child": ("{% if default %}{% extends default %}{% else %}"
"{% extends 'default1' %}{% endif %}"
"{% block x %}CHILD{% endblock %}"),
}))
tmpl = env.get_template("child")
assert tmpl.render(default="default2") == "DEFAULT2CHILD"
assert tmpl.render(default="default1") == "DEFAULT1CHILD"
assert tmpl.render() == "DEFAULT1CHILD"
def replace_vars(self, html: str) -> str:
vars_manager = VariablesConverter(self.problem_attr)
env = Environment(
variable_start_string="{@",
variable_end_string="}",
loader=DictLoader({"task": html}),
undefined=StrictUndefined,
)
template = env.get_template("task")
replaced_html = template.render(
constraints=vars_manager["constraints"],
samples=vars_manager["samples"],
)
return replaced_html
def __init__(self, *args, **kwargs):
"""
Overwrites the extra loaders to get the right template.
"""
filename = os.path.join(os.path.dirname(__file__), 'rst_modified.tpl')
with open(filename, 'r', encoding='utf-8') as f:
content = f.read()
filename = os.path.join(os.path.dirname(__file__), 'rst.tpl')
with open(filename, 'r', encoding='utf-8') as f:
content2 = f.read()
dl = DictLoader({'rst_modified.tpl': content, 'rst.tpl': content2})
kwargs['extra_loaders'] = [dl]
RSTExporter.__init__(self, *args, **kwargs)
def main():
import re # cut the example out of the doc string.
template_text = re.sub(r'.*---cut here---',
'',
Incer.__doc__,
flags=re.DOTALL)
template_text = re.sub(r'^\s+', '', template_text,
flags=re.MULTILINE) # unindent
loader = DictLoader({'template_text': template_text})
environment = Environment(loader=loader)
template = environment.get_template('template_text')
print(template.render(_=Incer(template_text)))
def test_unoptimized_scopes_autoescape(self):
env = Environment(loader=DictLoader(dict(o_printer='({{ o }})', )),
autoescape=True,
enable_async=True)
t = env.from_string("""
{% macro outer(o) %}
{% macro inner() %}
{% include "o_printer" %}
{% endmacro %}
{{ inner() }}
{% endmacro %}
{{ outer("FOO") }}
""")
assert t.render().strip() == '(FOO)'
def dump(obj):
current_path = os.path.dirname(os.path.abspath(__file__))
with open(os.path.join(current_path, 'templates/dump.html'), 'r') as f:
dump = f.read()
with open(os.path.join(current_path, 'templates/obj_loop.html'),
'r') as f:
obj_loop = f.read()
with open(os.path.join(current_path, 'templates/css/tailwind.css'),
'r') as f:
tailwind_template = f.read()
loader = DictLoader({
'dump.html': dump,
'obj_loop.html': obj_loop,
'css/tailwind.css': tailwind_template,
})
environment = Environment(loader=loader,
autoescape=select_autoescape(['html',
'xml']))
return environment.get_template('dump.html').render({
'obj':
obj,
'type':
type,
'list':
list,
'id':
id,
'inspect':
inspect,
'members':
inspect.getmembers(obj, predicate=inspect.ismethod),
'properties':
inspect.getmembers(obj),
'hasattr':
hasattr,
'getattr':
getattr,
'Model':
list,
'isinstance':
isinstance,
'show_methods': (bool, str, list, dict),
'len':
len,
})
def test_multi_inheritance():
env = Environment(loader=DictLoader({
'master1':
'MASTER1{% block x %}{% endblock %}',
'master2':
'MASTER2{% block x %}{% endblock %}',
'child':
'''{% if master %}{% extends master %}{% else %}{% extends
'master1' %}{% endif %}{% block x %}CHILD{% endblock %}'''
}))
tmpl = env.get_template('child')
assert tmpl.render(master='master2') == 'MASTER2CHILD'
assert tmpl.render(master='master1') == 'MASTER1CHILD'
assert tmpl.render() == 'MASTER1CHILD'
def test_autoescape_autoselect(self):
def select_autoescape(name):
if name is None or '.' not in name:
return False
return name.endswith('.html')
env = Environment(autoescape=select_autoescape,
loader=DictLoader({
'test.txt': '{{ foo }}',
'test.html': '{{ foo }}'
}))
t = env.get_template('test.txt')
t = env.get_template('test.html')
t = env.from_string('{{ foo }}')
def test_level2_required(self, env):
env = Environment(loader=DictLoader({
"master":
"{% block x required %}{% endblock %}",
"level1":
"{% extends 'master' %}{% block x %}[1]{% endblock %}",
"level2":
"{% extends 'master' %}{% block x %}[2]{% endblock %}",
}))
rv1 = env.get_template("level1").render()
rv2 = env.get_template("level2").render()
assert rv1 == "[1]"
assert rv2 == "[2]"
def parse_struct(filename):
with open(filename, 'r') as f:
soup = BeautifulSoup(f, 'lxml')
struct_doc = soup.find('html').find('body').find('struct')
name = struct_doc.attrs['name']
desc = struct_doc.find('brief', recursive=False).text.replace('\n', ' ')
fields = struct_doc.find_all('field', recursive=False)
env = Environment(loader=DictLoader({'struct': struct_template}))
env.filters.update({'field_info': field_info})
return env.get_template('struct').render(
name=name,
desc=desc,
fields=fields,
)
def test_multi_inheritance(self, env):
env = Environment(loader=DictLoader({
"master1":
"MASTER1{% block x %}{% endblock %}",
"master2":
"MASTER2{% block x %}{% endblock %}",
"child":
"""{% if master %}{% extends master %}{% else %}{% extends
'master1' %}{% endif %}{% block x %}CHILD{% endblock %}""",
}))
tmpl = env.get_template("child")
assert tmpl.render(master="master2") == "MASTER2CHILD"
assert tmpl.render(master="master1") == "MASTER1CHILD"
assert tmpl.render() == "MASTER1CHILD"
def test_dataclass_fields_render():
def build_color_list():
return ['red', 'green', 'blue']
@dataclass
class PaintTool:
# defaults with prop value
paint_color: str
# defaults without prop value
effect: str
# default value without prop value
default_color: str = 'red'
# default factory without prop value
color_list: List[str] = field(default_factory=build_color_list)
# default value with prop value
size: int = 10
# default factory with prop value
properties: List[str] = field(default_factory=list)
template: str = 'paint_tool.html'
env = ComponentEnvironment([PaintTool])
env.loader = DictLoader({
'painter.html':
'<html><body>'
'{% PaintTool paint_color = "green", size = 15, properties = ["soft", "tapered"] %}'
'</body></html>',
'paint_tool.html':
'<ul>'
'<li>{{ component.paint_color }}</li>'
'<li>{{ component.effect }}</li>'
'<li>{{ component.default_color }}</li>'
'<li>colors: {{ component.color_list|join(", ") }}</li>'
'<li>{{ component.size }}</li>'
'<li>properties: {{ component.properties|join(", ") }}</li>'
'</ul>',
})
template = env.get_template('painter.html')
assert template.render() == '<html><body>' \
'<ul>' \
'<li>green</li>' \
'<li></li>' \
'<li>red</li>' \
'<li>colors: red, green, blue</li>' \
'<li>15</li>' \
'<li>properties: soft, tapered</li>' \
'</ul>' \
'</body></html>'
def test_render_template_i18n(app, test_request_context):
loader = DictLoader({
"tmpl.txt": "default ({{ locale }})",
"tmpl.en.txt": "en locale ({{ locale }})",
"tmpl.fr.txt": "fr locale ({{ locale }})",
})
app_loader = app.jinja_loader
app.jinja_loader = loader
render = i18n.render_template_i18n
try:
assert render("tmpl.txt", locale="fr") == "fr locale (fr)"
assert render("tmpl.txt", locale="en") == "en locale (en)"
assert render("tmpl.txt", locale="de") == "default (de)"
finally:
app.jinja_loader = app_loader
def test_render_template_i18n(self):
loader = DictLoader({
'tmpl.txt': 'default ({{ locale }})',
'tmpl.en.txt': 'en locale ({{ locale }})',
'tmpl.fr.txt': 'fr locale ({{ locale }})',
})
app_loader = self.app.jinja_loader
self.app.jinja_loader = loader
render = i18n.render_template_i18n
try:
assert render('tmpl.txt', locale='fr') == 'fr locale (fr)'
assert render('tmpl.txt', locale='en') == 'en locale (en)'
assert render('tmpl.txt', locale='de') == 'default (de)'
finally:
self.app.jinja_loader = app_loader
def test_super():
env = Environment(loader=DictLoader({
'a':
'{% block intro %}INTRO{% endblock %}|'
'BEFORE|{% block data %}INNER{% endblock %}|AFTER',
'b':
'{% extends "a" %}{% block data %}({{ '
'super() }}){% endblock %}',
'c':
'{% extends "b" %}{% block intro %}--{{ '
'super() }}--{% endblock %}\n{% block data '
'%}[{{ super() }}]{% endblock %}'
}))
tmpl = env.get_template('c')
assert tmpl.render() == '--INTRO--|BEFORE|[(INNER)]|AFTER'
def __init__(self, template):
"""
:param template: (string | dict) - The directory or dict map of templates
- as string: A directory
- as dict: {'index.html': 'source here'}
"""
loader = None
if template:
if isinstance(template, dict):
loader = DictLoader(template)
elif os.path.isdir(template):
loader = FileSystemLoader(template)
if loader:
self.env = Environment(loader=loader)
def test_super(self, env):
env = Environment(loader=DictLoader({
"a":
"{% block intro %}INTRO{% endblock %}|"
"BEFORE|{% block data %}INNER{% endblock %}|AFTER",
"b":
'{% extends "a" %}{% block data %}({{ '
"super() }}){% endblock %}",
"c":
'{% extends "b" %}{% block intro %}--{{ '
"super() }}--{% endblock %}\n{% block data "
"%}[{{ super() }}]{% endblock %}",
}))
tmpl = env.get_template("c")
assert tmpl.render() == "--INTRO--|BEFORE|[(INNER)]|AFTER"
def render_template(template_value, template_variables=None):
"""Render a Jinja2 template.
:param str template_value: Jinja2 template string
:param dict template_variables: variables to include in template.
:returns str: rendered template
"""
template_environment = Environment(
loader=DictLoader({
FAKE_TEMPLATE_NAME: template_value,
}))
jinja_template = template_environment.get_template(FAKE_TEMPLATE_NAME)
return jinja_template.render(template_variables or {})
def test_include(self):
where_clause = """where project_id = {{request.project_id}}"""
source = """
select * from dummy {% include 'where_clause.sql' %}
"""
loader = DictLoader({"where_clause.sql": where_clause})
env = Environment(loader=loader)
j = JinjaSql(env)
query, bind_params = j.prepare_query(source, _DATA)
expected_query = "select * from dummy where project_id = %s"
self.assertEquals(query.strip(), expected_query.strip())
self.assertEquals(len(bind_params), 1)
self.assertEquals(list(bind_params)[0], 123)
print jinjs.compile()
ctx.eval(jinjs.compile())
print ctx.eval('Jinjs(Jinjs.templates["b"], {})')
"""
from jinja2.testsuite.inheritance import env
from jinja2 import DictLoader
loader = env.loader
loader = DictLoader(
{
"master": """
{% for i in [1, 2, 3, 4] %}
Hello, {{ i }}!
{% endfor %}
""",
"a": """\
{% macro say_hello(name) %}Hello {{ name }}!{% endmacro %}
{{ say_hello('Peter') }}""",
}
)
env1 = jinja2.Environment(loader=loader, trim_blocks=True)
env2 = Environment(loader=loader, trim_blocks=True)
name = "a"
tmpl = loader.get_source(env, name)[0]
print "===============TEMPLATE==============="
print tmpl
