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