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)
