def jinja_choice_loader(loader): return jinja2.ChoiceLoader([ loader, jinja2.DictLoader({ 'snippets/per_lab/lab_env/lab.test-kickstart.invalid': ''' cat << EOF > /etc/profile.d/rh-env.sh export LAB_CONTROLLER=lab.test-kickstart.invalid export DUMPSERVER=netdump.test-kickstart.invalid export NFSSERVERS="RHEL3,rhel3-nfs.test-kickstart.invalid:/export/home RHEL4,rhel4-nfs.test-kickstart.invalid:/export/home RHEL5,rhel5-nfs.test-kickstart.invalid:/export/home RHEL6,rhel6-nfs.test-kickstart.invalid:/export/home NETAPP, SOLARIS," export LOOKASIDE=http://download.test-kickstart.invalid/lookaside/ export BUILDURL=http://download.test-kickstart.invalid EOF cat << EOF > /etc/profile.d/rh-env.csh setenv LAB_CONTROLLER lab.test-kickstart.invalid setenv DUMPSERVER netdump.test-kickstart.invalid setenv NFSSERVERS "RHEL3,rhel3-nfs.test-kickstart.invalid:/export/home RHEL4,rhel4-nfs.test-kickstart.invalid:/export/home RHEL5,rhel5-nfs.test-kickstart.invalid:/export/home RHEL6,rhel6-nfs.test-kickstart.invalid:/export/home NETAPP, SOLARIS," setenv LOOKASIDE http://download.test-kickstart.invalid/lookaside/ setenv BUILDURL http://download.test-kickstart.invalid EOF ''', 'snippets/per_system/packages/bz728410-system-with-packages': 'special-weird-driver-package\n', }) ])
def test_context_processors(test_client, loop): @aiohttp_jinja2.template('tmpl.jinja2') @asyncio.coroutine def func(request): return {'bar': 2} app = web.Application(loop=loop, middlewares=[ aiohttp_jinja2.context_processors_middleware]) aiohttp_jinja2.setup(app, loader=jinja2.DictLoader( {'tmpl.jinja2': 'foo: {{ foo }}, bar: {{ bar }}, path: {{ request.path }}'})) app['aiohttp_jinja2_context_processors'] = ( aiohttp_jinja2.request_processor, asyncio.coroutine( lambda request: {'foo': 1, 'bar': 'should be overwriten'}), ) app.router.add_get('/', func) client = yield from test_client(app) resp = yield from client.get('/') assert 200 == resp.status txt = yield from resp.text() assert 'foo: 1, bar: 2, path: /' == txt
def test_context_processors(create_server, loop): @aiohttp_jinja2.template('tmpl.jinja2') @asyncio.coroutine def func(request): return {'bar': 2} app, url = yield from create_server( middlewares=[aiohttp_jinja2.context_processors_middleware]) aiohttp_jinja2.setup( app, loader=jinja2.DictLoader({ 'tmpl.jinja2': 'foo: {{ foo }}, bar: {{ bar }}, path: {{ request.path }}' })) app['aiohttp_jinja2_context_processors'] = ( aiohttp_jinja2.request_processor, asyncio.coroutine(lambda request: { 'foo': 1, 'bar': 'should be overwriten' }), ) app.router.add_route('GET', '/', func) resp = yield from aiohttp.request('GET', url, loop=loop) assert 200 == resp.status txt = yield from resp.text() assert 'foo: 1, bar: 2, path: /' == txt
def render_from_dict(cls: Type, rename_all: Optional[str] = None, custom: Optional[DeserializeFunc] = None) -> str: template = """ def {{func}}(data, reuse_instances = {{serde_scope.reuse_instances_default}}): if reuse_instances is Ellipsis: reuse_instances = {{serde_scope.reuse_instances_default}} {# List up all classes used by this class. #} {% for name in serde_scope.types.keys() %} {{name}} = serde_scope.types['{{name}}'] {% endfor %} if data is None: return None return cls( {% for f in fields %} {{f|arg(loop.index-1)|rvalue}}, {% endfor %} ) """ renderer = Renderer(FROM_DICT, custom) env = jinja2.Environment(loader=jinja2.DictLoader({'dict': template})) env.filters.update({'rvalue': renderer.render}) env.filters.update( {'arg': functools.partial(to_arg, rename_all=rename_all)}) return env.get_template('dict').render(func=FROM_DICT, serde_scope=getattr( cls, SERDE_SCOPE), fields=defields(cls))
def test_conditional_render(self): # given loader = jinja2.DictLoader({ "a1": "{% skip_file_when a %}X", "a2": "{% skip_file_unless a %}OK", "b1": "{% skip_file_when b %}OK", "b2": "{% skip_file_unless b %}X", "c1": "{% skip_file_when c %}OK", "c2": "{% skip_file_unless c %}X", }) # when tt.render_templates(self.tmp_dir, loader, { 'a': True, 'b': False, 'c': False, }) # then for expected_file in [ "a2", "b1", "c1", ]: self.assertEqual(self.readfile(expected_file), "OK") for should_not_exist in [ "a1", "b2", "c2", ]: self.assertFalse((Path(self.tmp_dir) / should_not_exist).exists())
def __init__( self, default_templates=None, custom_templates=None, templates_directory=None, config=None, toc=None, footnotes=None, ): self.default_templates = default_templates or {} self.custom_templates = custom_templates or {} self.templates_directory = templates_directory self.config = copy.deepcopy(config) if config else {} self.toc = toc or nodes.TocNode() self.footnotes = footnotes or nodes.FootnotesNode() self.default_templates.update(self.custom_templates) # This is the fallback environment for templates self.default_templates_env = jinja2.Environment( loader=jinja2.DictLoader(self.default_templates), **self._environment_options, ) # This is the first choice for templates if self.templates_directory: self.main_templates_env = jinja2.Environment( loader=jinja2.FileSystemLoader( searchpath=self.templates_directory), **self._environment_options, ) else: self.main_templates_env = self.default_templates_env
def render_union_func(cls: Type, union_args: List[Type]) -> str: template = """ def {{func}}(obj, reuse_instances, convert_sets): {% for name in serde_scope.types.keys() %} {{name}} = serde_scope.types['{{name}}'] {% endfor %} union_args = serde_scope.union_se_args['{{func}}'] {% for t in union_args %} if is_instance(obj, union_args[{{loop.index0}}]): return {{t|arg|rvalue()}} {% endfor %} raise SerdeError("Can not serialize " + repr(obj) + " of type " + typename(type(obj)) + " for {{union_name}}") """ union_name = f"Union[{', '.join([typename(a) for a in union_args])}]" renderer = Renderer(TO_DICT) env = jinja2.Environment(loader=jinja2.DictLoader({'dict': template})) env.filters.update({'arg': lambda x: SeField(x, "obj")}) env.filters.update({'rvalue': renderer.render}) return env.get_template('dict').render( func=union_func_name(UNION_SE_PREFIX, union_args), serde_scope=getattr(cls, SERDE_SCOPE), union_args=union_args, union_name=union_name, )
def parse(self, md_file): """ Parse a md file into a post object """ # compile the templates when we parse the first post. This is needed # to ensure that plugins get a chance to modify the templates before # we compile them. if not self.jinja2: self.jinja2 = jinja2.Environment(loader=jinja2.DictLoader( self.templates)) parsed_post = utils.dict_to_objdict() # parsing frontmatter and getting the md parsed_post.meta, parsed_post.md = frontmatter.parse(md_file) # parsing markdown and extractring info # NOTE: this must called before every parsing self.renderer.init(self.jinja2, self.code_formatter, self.site, parsed_post.meta) parsed_post.html = self.md_parser.parse(parsed_post.md) parsed_post.text = html2text(parsed_post.html) # used by NLP parsed_post.meta.statistics = self.renderer.get_stats() parsed_post.meta.toc = self.renderer.get_json_toc() parsed_post.elements = self.renderer.get_info() return parsed_post
def render_jinja(dict_, template_str): """Render dict onto jinja template and return the string result""" name = 'jvars' j2env = jinja2.Environment(loader=jinja2.DictLoader( {name: template_str}), undefined=jinja2.StrictUndefined, extensions=["jinja2.ext.do"]) # Add some custom jinja filters j2env.filters['bool'] = TypeUtils.str_to_bool j2env.filters['yaml'] = YamlUtils.yaml_dict_to_string j2env.filters['base64encode'] = base64.b64encode # Add a "raise" keyword for raising exceptions from within jinja j2env.globals['raise'] = JinjaUtils._jinja_keyword_raise j2env.globals['gen_names'] = JinjaUtils._jinja_keyword_gen_names j2env.globals['mkpass'] = JinjaUtils.mkpass j2env.globals['keygen'] = JinjaUtils.keygen j2env.globals['self_signed_cert_gen'] = JinjaUtils.self_signed_cert_gen j2env.globals['ceph_key'] = JinjaUtils.ceph_key j2env.globals['uuid'] = JinjaUtils.uuid # Render the template rendered_template = j2env.get_template(name).render(dict_) return rendered_template + "\n"
def render_template(loader, template_name, template_vars=None, glob_helper=lambda f: [], clock=time.Clock): macros = """ {% macro collect(parts) -%} {% set comma = joiner() %} {% for part in glob(parts) %} {{ comma() }} {% include part %} {% endfor %} {%- endmacro %} """ # place helpers dict loader first to prevent users from overriding our macros. env = jinja2.Environment(loader=jinja2.ChoiceLoader( [jinja2.DictLoader({"rally.helpers": macros}), loader])) if template_vars: for k, v in template_vars.items(): env.globals[k] = v # ensure that user variables never override our internal variables env.globals["now"] = clock.now() env.globals["glob"] = glob_helper env.filters["days_ago"] = time.days_ago template = env.get_template(template_name) return template.render()
def __init__(self, execute='auto', kernel_name='', execute_arguments=[], allow_errors=False, timeout=30, codecell_lexer='none'): """Initialize the Exporter.""" self._execute = execute self._kernel_name = kernel_name self._execute_arguments = execute_arguments self._allow_errors = allow_errors self._timeout = timeout self._codecell_lexer = codecell_lexer loader = jinja2.DictLoader({'nbsphinx-rst.tpl': RST_TEMPLATE}) super(Exporter, self).__init__(template_file='nbsphinx-rst.tpl', extra_loaders=[loader], config=traitlets.config.Config({ 'HighlightMagicsPreprocessor': { 'enabled': True } }), filters={ 'convert_pandoc': convert_pandoc, 'markdown2rst': markdown2rst, 'get_empty_lines': _get_empty_lines, 'extract_toctree': _extract_toctree, 'get_output_type': _get_output_type, 'json_dumps': json.dumps, })
def __init__( self, default_templates=None, templates_directory=None, config=None, toc=None, footnotes=None, ): self.default_templates = default_templates or {} self.templates_directory = templates_directory self.config = copy.deepcopy(config) if config else {} self.toc = toc or [] self.footnotes = footnotes or [] self.default_templates_env = jinja2.Environment( loader=jinja2.DictLoader(self.default_templates), **self._environment_options, ) if self.templates_directory: self.main_templates_env = jinja2.Environment( loader=jinja2.FileSystemLoader( searchpath=self.templates_directory), **self._environment_options, ) else: self.main_templates_env = self.default_templates_env
def test_async_mode_disabled(test_client, loop): """ Test that running in blocking manner will also work. """ @aiohttp_jinja2.template('tmpl.jinja2') @asyncio.coroutine def func(request): return {'foo': 42} app = web.Application(loop=loop) template = "foo: {{foo}}" aiohttp_jinja2.setup( app, loader=jinja2.DictLoader({ 'tmpl.jinja2': template, }), enable_async=False, ) app.router.add_get('/', func) client = yield from test_client(app) resp = yield from client.get('/') assert 200 == resp.status txt = yield from resp.text() assert 'foo: 42' == txt
async def client(aiohttp_client) -> TestClient: # Tell jinja2 to load a fixture template rather than read the disk template = '<html><body><h1>{{head}}</h1>{{text}}</body></html>' app = web.Application() aiohttp_jinja2.setup(app, loader=jinja2.DictLoader({ 'example.template': template })) # Create request handler that uses fixture template when HTML is requested @negotiate('example.template') async def async_handler(_request): return {'head': 'HEAD', 'text': 'text'} # Create a non-async handler too to prove we can support either @negotiate('example.template') def sync_handler(_request): return {'head': 'HEAD', 'text': 'text'} @negotiate('example.template') def normal_handler(_request): return web.Response(text='Hello, world!') # Create real app using stub handler and return a test client for it app.router.add_route('*', '/async', async_handler) app.router.add_route('*', '/sync', sync_handler) app.router.add_route('*', '/normal', normal_handler) return await aiohttp_client(app)
async def test_render_bare_funcs_deprecated(aiohttp_client): def wrapper( func: Callable[[web.Request], Awaitable[_T]] ) -> Callable[[web.Request], Awaitable[_T]]: async def wrapped(request: web.Request) -> _T: with pytest.warns( DeprecationWarning, match="Bare functions are deprecated" ): return await func(request) return wrapped @wrapper # type: ignore[arg-type] # Deprecated functionality @aiohttp_jinja2.template("tmpl.jinja2") def func(request: web.Request) -> Dict[str, str]: return {"text": "OK"} app = web.Application() aiohttp_jinja2.setup(app, loader=jinja2.DictLoader({"tmpl.jinja2": "{{text}}"})) app.router.add_route("GET", "/", func) client = await aiohttp_client(app) resp = await client.get("/") assert 200 == resp.status txt = await resp.text() assert "OK" == txt
def test_generator_duplicate_samples(fs): config_fpath = "samples.yaml" fs.create_file( config_fpath, contents=dedent(""" # Note: the samples are duplicates. type: com.google.api.codegen.samplegen.v1p2.SampleConfigProto schema_version: 1.2.0 samples: - id: squid_sample region_tag: humboldt_tag rpc: get_squid - id: squid_sample region_tag: humboldt_tag rpc: get_squid """), ) generator = make_generator("samples=samples.yaml") generator._env.loader = jinja2.DictLoader({"sample.py.j2": ""}) api_schema = make_api( naming=naming.NewNaming(name="Mollusc", version="v6")) with pytest.raises(types.DuplicateSample): generator.get_response(api_schema=api_schema, opts=Options.build(""))
def test_url(test_client, loop): @aiohttp_jinja2.template('tmpl.jinja2') @asyncio.coroutine def index(request): return {} @asyncio.coroutine def other(request): return app = web.Application(loop=loop) aiohttp_jinja2.setup(app, loader=jinja2.DictLoader({ 'tmpl.jinja2': "{{ url('other', name='John_Doe')}}" })) app.router.add_route('GET', '/', index) app.router.add_route('GET', '/user/{name}', other, name='other') client = yield from test_client(app) resp = yield from client.get('/') assert 200 == resp.status txt = yield from resp.text() assert '/user/John_Doe' == txt
def go(): app = web.Application(loop=self.loop) aiohttp_jinja2.setup( app, loader=jinja2.DictLoader({ 'tmpl.jinja2': "<html><body><h1>{{head}}</h1>{{text}}</body></html>" })) handler = Handler() app.router.add_route('GET', '/', handler.meth) port = self.find_unused_port() srv = yield from self.loop.create_server(app.make_handler(), '127.0.0.1', port) url = "http://127.0.0.1:{}/".format(port) resp = yield from aiohttp.request('GET', url, loop=self.loop) self.assertEqual(200, resp.status) txt = yield from resp.text() self.assertEqual('<html><body><h1>HEAD</h1>text</body></html>', txt) srv.close() self.addCleanup(srv.close)
def render_to_tuple(cls: Type) -> str: template = """ def {{func}}(obj, reuse_instances = {{serde_scope.reuse_instances_default}}, convert_sets = {{serde_scope.convert_sets_default}}): if reuse_instances is Ellipsis: reuse_instances = {{serde_scope.reuse_instances_default}} if convert_sets is Ellipsis: convert_sets = {{serde_scope.convert_sets_default}} if not is_dataclass(obj): return copy.deepcopy(obj) {# List up all classes used by this class. #} {% for name in serde_scope.types.keys() %} {{name}} = serde_scope.types['{{name}}'] {% endfor %} res = [] {% for f in fields -%} {% if not f.skip|default(False) %} res.append({{f|arg|rvalue()}}) {% endif -%} {% endfor -%} return tuple(res) """ renderer = Renderer(TO_ITER) env = jinja2.Environment(loader=jinja2.DictLoader({'iter': template})) env.filters.update({'rvalue': renderer.render}) env.filters.update({'arg': to_arg}) return env.get_template('iter').render(func=TO_ITER, serde_scope=getattr( cls, SERDE_SCOPE), fields=sefields(cls))
async def test_context_processors(aiohttp_client): @aiohttp_jinja2.template('tmpl.jinja2') async def func(request): return {'bar': 2} app = web.Application(middlewares=[ aiohttp_jinja2.context_processors_middleware]) aiohttp_jinja2.setup(app, loader=jinja2.DictLoader( {'tmpl.jinja2': 'foo: {{ foo }}, bar: {{ bar }}, path: {{ request.path }}'})) async def processor(request): return {'foo': 1, 'bar': 'should be overwriten'} app['aiohttp_jinja2_context_processors'] = ( aiohttp_jinja2.request_processor, processor, ) app.router.add_get('/', func) client = await aiohttp_client(app) resp = await client.get('/') assert 200 == resp.status txt = await resp.text() assert 'foo: 1, bar: 2, path: /' == txt
async def test_render_class_view_based(test_client): app = Sanic("test_jinja2_render") # setup template = "<html><body><h1>{{Player}}</h1>{{Category}}</body></html>" jinja2_sanic.setup(app, loader=jinja2.DictLoader({"templates.jinja2": template})) class SimpleView(HTTPMethodView): @jinja2_sanic.template("templates.jinja2") async def get(self, request): return { "Player": "CR7", "Category": "Soccer", } # register routes app.add_route(SimpleView.as_view(), "/") cli = await test_client(app) resp = await cli.get('/') assert resp.status == 200 text = await resp.text() assert text == "<html><body><h1>CR7</h1>Soccer</body></html>"
async def test_context_not_tainted(aiohttp_client): global_context = {'version': 1} @aiohttp_jinja2.template('tmpl.jinja2') async def func(request): return global_context async def processor(request): return {'foo': 1} app = web.Application() aiohttp_jinja2.setup( app, loader=jinja2.DictLoader({'tmpl.jinja2': 'foo: {{ foo }}'}), context_processors=[processor]) app.router.add_get('/', func) client = await aiohttp_client(app) resp = await client.get('/') assert 200 == resp.status txt = await resp.text() assert 'foo: 1' == txt assert 'foo' not in global_context
def test_substitute_filenames(self): # given loader = jinja2.DictLoader({ "{{one}}/{{two}}.txt": "OK", "{{10 * 20}}.txt": "OK", "a/{{long_path}}/b": "OK", "filename.{{ext}}": "OK", }) # when tt.render_templates(self.tmp_dir, loader, { 'one': 1, 'two': 2, 'long_path': "x/y/z", 'ext': "xyz", }) # then for expected_file in [ "1/2.txt", "200.txt", "a/x/y/z/b", "filename.xyz", ]: self.assertEqual(self.readfile(expected_file), "OK")
def init(loop): # add aiohttp_debugtoolbar middleware to you application app = web.Application(loop=loop) # install aiohttp_debugtoolbar aiohttp_debugtoolbar.setup(app) template = """ <html> <head> <title>{{ title }}</title> </head> <body> <h1>{{ text }}</h1> <p> <a href="{{ app.router['exc_example'].url_for() }}"> Exception example</a> </p> </body> </html> """ # install jinja2 templates loader = jinja2.DictLoader({'index.html': template}) aiohttp_jinja2.setup(app, loader=loader) # init routes for index page, and page with error app.router.add_route('GET', '/', basic_handler, name='index') app.router.add_route('GET', '/exc', exception_handler, name='exc_example') handler = app.make_handler() srv = yield from loop.create_server(handler, '127.0.0.1', 9000) print("Server started at http://127.0.0.1:9000") return srv, handler
def test_context_not_tainted(test_client, loop): global_context = {'version': 1} @aiohttp_jinja2.template('tmpl.jinja2') @asyncio.coroutine def func(request): return global_context app = web.Application(loop=loop) aiohttp_jinja2.setup( app, loader=jinja2.DictLoader({'tmpl.jinja2': 'foo: {{ foo }}'}), context_processors=[asyncio.coroutine( lambda request: {'foo': 1})]) app.router.add_get('/', func) client = yield from test_client(app) resp = yield from client.get('/') assert 200 == resp.status txt = yield from resp.text() assert 'foo: 1' == txt assert 'foo' not in global_context
def _render_string(string, variables, undefined): if isinstance(string, str) and sys.version_info < (3, 0): string = unicode(string, 'utf-8') # NOQA template_name = 'template_name' loader = jinja2.DictLoader({template_name: string}) return _render(template_name, loader, variables, undefined)
async def test_request_processor(aiohttp_client): @aiohttp_jinja2.template("tmpl.jinja2") async def func(request): # pylint: disable=unused-argument return {} app = web.Application( middlewares=[aiohttp_jinja2.context_processors_middleware]) aiohttp_jinja2.setup( app, loader=jinja2.DictLoader({ "tmpl.jinja2": "request: {{ request }}, handler: {{ handler }}, " }), ) app["aiohttp_jinja2_context_processors"] = ( aiohttp_jinja2.request_processor, request_processor, ) app.router.add_get("/", func) client = await aiohttp_client(app) resp = await client.get("/") assert resp.status == 200 txt = await resp.text() assert ("request: <Request GET / >, handler: <function " "test_request_processor.<locals>.func" in txt)
def test_render_file(self, jinja_fsl_mock): path = '/path/to/template.j2' jinja_fsl_mock.return_value = jinja2.DictLoader( {'template.j2': self.template}) self.assertEqual(self.expected, utils.render_template(path, self.params)) jinja_fsl_mock.assert_called_once_with('/path/to')
def render_astuple(cls: Type, custom: Custom = None) -> str: template = """ def {{func}}(obj): if not is_dataclass(obj): return copy.deepcopy(obj) {# List up all classes used by this class. -#} {% for name in cls.__serde_scope__ -%} {{name}} = getattr(obj, '__serde_scope__')['{{name}}'] {% endfor -%} {% if cls|is_dataclass %} res = [] {% for f in cls|fields -%} {% if not f.skip|default(False) -%} res.append({{f|arg|rvalue()}}) {% endif -%} {% endfor -%} return tuple(res) {% endif %} """ renderer = Renderer(TO_ITER, custom) env = jinja2.Environment(loader=jinja2.DictLoader({'iter': template})) env.filters.update({'fields': sefields}) env.filters.update({'is_dataclass': is_dataclass}) env.filters.update({'rvalue': renderer.render}) env.filters.update({'arg': to_arg}) return env.get_template('iter').render(func=TO_ITER, cls=cls)
def render_from_dict(cls: Type, rename_all: Optional[str] = None, custom: Custom = None) -> str: template = """ def {{func}}(data): {# List up all classes used by this class. -#} {% for name in cls.__serde_scope__ -%} {{name}} = getattr(cls, '__serde_scope__')['{{name}}'] {% endfor -%} if data is None: return None fs = fields(cls) return cls( {% for f in cls|fields -%} {{f|arg(loop.index-1)|rvalue}}, {% endfor -%} ) """ renderer = Renderer(FROM_DICT, custom) env = jinja2.Environment(loader=jinja2.DictLoader({'dict': template})) env.filters.update({'rvalue': renderer.render}) env.filters.update({'fields': defields}) env.filters.update( {'arg': functools.partial(to_arg, rename_all=rename_all)}) return env.get_template('dict').render(func=FROM_DICT, cls=cls)