def environment(**options):
from django.utils.translation import ugettext
env = Environment(**options)
env.add_extension(
'project.main.middleware.pagination.AutopaginateExtension')
env.globals.update({
'static': staticfiles_storage.url,
'url': reverse,
'get_site_name': get_site_name,
'get_const_module': get_const_module,
'slugify': slugify,
'format_float': format_float,
'format_float_thousands': format_float_thousands,
'format_int_thousands': format_int_thousands,
'format_datetime': format_datetime,
'format_date': format_date,
'format_time': format_time,
'format_weekday': format_weekday,
'format_weekday_date': format_weekday_date,
'gettext': ugettext,
'urlencode': urlencode,
'ago': ago,
'format_compact_datetime': format_compact_datetime,
'get_year_today': get_year_today,
'is_deploy': lambda: project.settings.local.Deploy,
'is_debug': lambda: project.settings.local.Debug,
'channels_enabled': lambda: project.settings.local.ChannelsEnabled,
'get_timestamp_inc': get_timestamp_inc,
})
return env
class TestTemplateTag(object):
def setup(self):
# Setup the assets environment.
assets_env = AssetsEnvironment('', '')
self.foo_bundle = Bundle()
self.bar_bundle = Bundle()
assets_env.register('foo_bundle', self.foo_bundle)
assets_env.register('bar_bundle', self.bar_bundle)
# Inject a mock bundle class into the Jinja2 extension, so we
# can check on what exactly it does.
test_instance = self
class MockBundle(Bundle):
urls_to_fake = ['foo']
def __init__(self, *a, **kw):
Bundle.__init__(self, *a, **kw)
self.env = assets_env
# Kind of hacky, but gives us access to the last Bundle
# instance used by the extension.
test_instance.the_bundle = self
def urls(self, *a, **kw):
return self.urls_to_fake
self._old_bundle_class = AssetsExtension.BundleClass
AssetsExtension.BundleClass = self.BundleClass = MockBundle
# Setup the Jinja2 environment.
self.jinja_env = JinjaEnvironment()
self.jinja_env.add_extension(AssetsExtension)
self.jinja_env.assets_environment = assets_env
def teardown(self):
AssetsExtension.BundleClass = self._old_bundle_class
del self._old_bundle_class
def render_template(self, args, ctx={}):
return self.jinja_env.from_string(
'{% assets '+args+' %}{{ ASSET_URL }};{% endassets %}').render(ctx)
def test_reference_bundles(self):
self.render_template('"foo_bundle", "bar_bundle"')
assert self.the_bundle.contents == (self.foo_bundle, self.bar_bundle)
def test_reference_files(self):
self.render_template('"file1", "file2", "file3"')
assert self.the_bundle.contents == ('file1', 'file2', 'file3',)
def test_reference_mixed(self):
self.render_template('"foo_bundle", "file2", "file3"')
assert self.the_bundle.contents == (self.foo_bundle, 'file2', 'file3',)
def test_with_vars(self):
self.render_template('var1, var2', {'var1': self.foo_bundle, 'var2': 'a_file'})
assert self.the_bundle.contents == (self.foo_bundle, 'a_file',)
def test_output_urls(self):
"""Ensure the tag correcly spits out the urls the bundle returns.
"""
self.BundleClass.urls_to_fake = ['foo', 'bar']
assert self.render_template('"file1" "file2" "file3"') == 'foo;bar;'
class TestLoader(TempEnvironmentHelper):
default_files = {
'template.html':
"""
<h1>Test</h1>
{% if foo %}
{% assets "A", "B", "C", output="output.html" %}
{{ ASSET_URL }}
{% endassets %}
{% endif %}
"""
}
def setup(self):
TempEnvironmentHelper.setup(self)
self.jinja_env = JinjaEnvironment()
self.jinja_env.add_extension(AssetsExtension)
self.jinja_env.assets_environment = self.env
def test(self):
loader = Jinja2Loader(self.env, [self.tempdir], [self.jinja_env])
bundles = loader.load_bundles()
assert len(bundles) == 1
assert bundles[0].output == "output.html"
def prepare_environment(env=None):
try:
loader = PackageLoader("glycresoft_sqlalchemy.web_app", "html")
loader.list_templates()
except:
loader = FileSystemLoader(os.path.join(os.path.dirname(__file__), 'html'))
if env is None:
env = Environment(loader=loader, extensions=[FragmentCacheExtension])
else:
env.loader = loader
env.add_extension(FragmentCacheExtension)
env.fragment_cache = dict()
env.filters["n_per_row"] = n_per_row
env.filters['highlight_sequence_site'] = highlight_sequence_site
env.filters['plot_glycoforms'] = plot_glycoforms
env.filters['chromatogram'] = plot_chromatogram
env.filters['svg_plot'] = svg_plot
env.filters['png_plot'] = png_plot
env.filters['fsort'] = fsort
env.filters['glycopeptide_string'] = glycopeptide_string
env.filters['glycan_composition_string'] = glycan_composition_string
env.filters["glycopeptide_match_logo"] = glycopeptide_match_logo
env.filters["formula"] = formula
env.globals
return env
class Template():
"""Class to handle templates."""
def __init__(self, logya_inst):
"""Initialize template environment."""
self.vars = {}
self.dir_templates = logya_inst.dir_templates
self.env = Environment(loader=TemplateLoader(self.dir_templates))
# Enable break and continue in templates.
self.env.add_extension('jinja2.ext.loopcontrols')
# Enable with statement for nested variable scopes.
self.env.add_extension('jinja2.ext.with_')
# Trim whitespace around template tags if configured.
tpl_settings = logya_inst.config.get('template')
if tpl_settings and tpl_settings.get('trim_whitespace'):
self.env.lstrip_blocks = True
self.env.trim_blocks = True
# Add filesource global to allow for including the source of a file.
self.env.globals[
'filesource'] = lambda x, lines=None, raw=False: filesource(
logya_inst, x, lines=lines, raw=raw)
self.env.globals['get_doc'] = lambda x: get_doc(logya_inst, x)
def get_page(self, doc, template):
try:
page = self.env.get_template(template)
except TemplateNotFound as err:
raise TemplateNotFound('Doc: {}\n{}'.format(doc, err))
return page
def prepare_environment(env=None):
try:
loader = PackageLoader("glypy", "search/results_template")
loader.list_templates()
except:
loader = FileSystemLoader(os.path.join(os.path.dirname(__file__), 'results_template'))
if env is None:
env = Environment(loader=loader, extensions=[FragmentCacheExtension])
else:
env.loader = loader
env.add_extension(FragmentCacheExtension)
env.filters["collect_fragments"] = collect_fragments
env.filters["all_matches"] = fetch_all_matches
env.filters["strip_derivatize"] = strip_derivatize_glycoct
env.filters["scientific_notation"] = scientific_notation
env.filters["cfg_plot"] = cfg_plot
env.filters["simple_cfg_plot"] = simple_plot
env.filters["min"] = min
env.filters["max"] = max
env.filters["unique"] = unique
env.filters["limit_sigfig"] = limit_sigfig
env.filters['css_escape'] = css_escape
env.filters['greek_fragment_name'] = greek_fragment_names
env.fragment_cache = dict()
return env
def render(menu, template):
module_dir = os.path.dirname(os.path.abspath(__file__))
templates_dir = os.path.join(module_dir, 'templates')
j2_env = Environment(loader=FileSystemLoader(templates_dir),
trim_blocks=True,
undefined=StrictUndefined)
j2_env.add_extension('jinja2.ext.loopcontrols')
j2_env.filters['toDecimal'] = toDecimal
j2_env.filters['toCharge'] = toCharge
j2_env.filters['getCentralityBitmask'] = getCentralityBitmask
j2_env.filters['hasCorrelationCuts'] = hasCorrelationCuts
j2_env.filters['sortObjects'] = sortObjects
j2_env.filters['toCpp'] = toCpp
j2_env.filters['getDeltaLut'] = getDeltaLut
j2_env.filters['getPrecisionByName'] = getPrecisionByName
j2_env.filters['getEtLut'] = getEtLut
j2_env.filters['getMathLut'] = getMathLut
j2_env.filters['getMathUptLut'] = getMathUptLut
j2_env.filters['getCaloMuonConversionLut'] = getCaloMuonConversionLut
j2_env.filters['warning'] = warning
j2_env.filters['toMass'] = toMass
j2_env.filters['toDeltaR'] = toDeltaR
j2_env.filters['chkChgCor'] = chkChgCor
j2_env.filters['getPrefix'] = getPrefix
j2_env.filters['isMuon'] = isMuon
j2_env.filters['isTau'] = isTau
j2_env.filters['hasIndexCut'] = hasIndexCut
j2_env.filters['getIndexCut'] = getIndexCut
j2_env.filters['getScale'] = getScale
j2_env.filters['getLookUpTable'] = getLookUpTable
data = {"tmGrammar": tmGrammar, "tmEventSetup": tmEventSetup, "menu": menu}
return j2_env.get_template(template).render(data)
class JinjaLoader(object):
def __init__(self, root_path, **kwargs):
super(JinjaLoader, self).__init__()
auto_reload = kwargs.get('debug', True)
self.env = Environment(loader=FileSystemLoader(root_path),
extensions=['jinja2.ext.autoescape'],
trim_blocks=True,
lstrip_blocks=True,
cache_size=-1, # no clean-up
auto_reload=auto_reload)
additional_globals = {
'ord': ord,
'chr': chr,
'unichr': unichr,
}
self.env.globals.update(additional_globals)
self.env.add_extension('jinja2.ext.loopcontrols')
def load(self, name, parent_path=None):
return JinjaTemplate(self.env.get_template(name))
def reset(self):
'''Reset the cache of compiled templates, required
in debug mode.
'''
self.env.cache.clear()
def render(self, variables):
"""
Render the template using Jinja2.
"""
environment = Environment(
loader=PeeringManagerLoader(),
trim_blocks=self.jinja2_trim,
lstrip_blocks=self.jinja2_lstrip,
)
environment.add_extension(IncludeTemplateExtension)
for extension in settings.JINJA2_TEMPLATE_EXTENSIONS:
environment.add_extension(extension)
# Add custom filters to our environment
environment.filters.update(FILTER_DICT)
# Try rendering the template, return a message about syntax issues if there
# are any
try:
jinja2_template = environment.from_string(self.template)
return jinja2_template.render(variables)
except TemplateSyntaxError as e:
return f"Syntax error in template at line {e.lineno}: {e.message}"
except Exception:
return traceback.format_exc()
def environment(**options):
env = Environment(**options)
env.globals.update({
'static': staticfiles_storage.url,
'url': reverse,
})
env.add_extension('jinja2.ext.i18n')
return env
def environment(**options):
env = Environment(**options)
env.globals.update({
'url': reverse,
})
env.add_extension(ActiveUrl)
return env
def render_output(self, jinja_file, params):
env = Environment(loader=FileSystemLoader(searchpath=self.src_path),
trim_blocks=True,
lstrip_blocks=True)
env.add_extension('jinja2.ext.loopcontrols')
env.add_extension('jinja2.ext.do')
env.filters['todict'] = todict
env.filters['islist'] = is_list
jinja = env.get_template(jinja_file)
return jinja.render(params=params)
def render(template):
j2_env = Environment(loader=FileSystemLoader(THIS_DIR), trim_blocks=True)
j2_env.add_extension('jinja2.ext.loopcontrols')
association = {
"info": info,
"loop": loop,
"link": link,
}
return j2_env.get_template(template).render(association)
def _render_from_settings(self, setting_name):
setting = getattr(self._settings, setting_name)
env = Environment()
env.add_extension('jinja2.ext.autoescape')
result = setting
while True:
t = env.from_string(result)
newresult = t.render(self._template_vars())
if newresult == result:
break
result = newresult
return result
def _render_from_settings(self, setting_name):
setting = getattr(self._settings, setting_name)
env = Environment()
env.add_extension('jinja2.ext.autoescape')
result = setting
while True:
t = env.from_string(result)
newresult = t.render(self._template_vars())
if newresult == result:
break
result = newresult
return result
def test_python_tpl_with_autoescape(self):
# See: https://github.com/tlatsas/jinja2-highlight/pull/1
env = Environment(extensions=['jinja2_highlight.HighlightExtension'])
env.add_extension('jinja2.ext.autoescape')
tpl = env.from_string('''
{% autoescape true %}
{% highlight "python" %}
print("Hello world")
{% endhighlight %}
{% endautoescape %}
''')
self.assertHtmlListEqual(tpl.render().split(), self.rendered)
def test_python_tpl_with_autoescape(self):
# See: https://github.com/tlatsas/jinja2-highlight/pull/1
env = Environment(extensions=['jinja2_highlight.HighlightExtension'])
env.add_extension('jinja2.ext.autoescape')
tpl = env.from_string('''
{% autoescape true %}
{% highlight "python" %}
print("Hello world")
{% endhighlight %}
{% endautoescape %}
''')
assert tpl.render().split() == self.rendered
def write_keeper(keeper_league):
env = Environment(loader=FileSystemLoader(constants.templates_dir), trim_blocks=True)
env.add_extension('jinja2.ext.do')
keeper_template = env.get_template(constants.keeper_template)
keeper_output = keeper_template.render(teams=keeper_league.teams)
print("Writing HTML to %s" % constants.keepers_file_path)
with open(constants.keepers_file_path, 'w+') as f1:
f1.write(keeper_output)
print("Writing keeper to spreadsheet")
write_keeper_to_spreadsheet(keeper_league)
class JinjaMacroTagTestCase(unittest.TestCase):
def setUp(self):
self.env = Environment(loader=FileSystemLoader(templates_path))
self.env.add_extension(LoadMacroExtension)
self.env.add_extension(CallMacroTagExtension)
self.env.add_extension(JinjaMacroTagsExtension)
self.env.add_extension(HtmlMacroTagsExtension)
self.env.autoload_macro_tags = True
def test_register_macro_from_template(self):
self.env.macros.register_from_template("macros.html")
self.assertTrue(self.env.macros.exists("panel"))
def test_register_macro_from_file(self):
def register_file():
self.env.macros.register_file(os.path.join(templates_path, "macros.html"))
self.assertRaises(Exception, register_file)
self.env.loader = MacroLoader(self.env.loader)
register_file()
self.assertTrue(self.env.macros.exists("panel"))
def test_jinja_macro_tag(self):
self.env.macros.register_from_template("macros.html")
tpl = self.env.get_template("jinja_style.html")
self.assert_html(tpl.render())
def test_html_macro_tag(self):
self.env.macros.register_from_template("macros.html")
tpl = self.env.get_template("html_style.html")
self.assert_html(tpl.render())
def assert_html(self, html):
self.assertIn('<div class="panel-title">test panel</div>', html)
self.assertIn('<div><button type="button" class="btn btn-default">click me</button></div>', html)
self.assertIn('<button type="button" class="btn btn-primary">click me</button>', html)
def write_output(leagues_data, week, pro_data, nfl_data):
env = Environment(loader=FileSystemLoader(constants.templates_dir), trim_blocks=True)
env.add_extension('jinja2.ext.do')
start_week_template = env.get_template(constants.main_template)
start_week_output = start_week_template.render(leagues=leagues_data, current_week=week, pro_data=pro_data,
legend=constants.team_notes, nfl_data=nfl_data)
with open(constants.start_week_file_path % week, 'w+') as f1:
f1.write(start_week_output)
if constants.current_week > 1:
end_week_template = env.get_template(constants.week_end_scores_template)
end_week_output = end_week_template.render(leagues=leagues_data)
with open(constants.end_week_file_path % (week - 1), 'w+') as f1:
f1.write(end_week_output)
def environment(**options):
env = Environment(**options)
env.globals.update({
'static': staticfiles_storage.url,
'url': url,
'assets': assets,
# 'gravatar_url': get_avatar_url,
'get_current_language': get_language,
'get_available_languages': get_available_languages,
'get_language_info_list': get_language_info_list,
# 'switch': gargoyle.is_active,
# 'avatar_url': avatar_url
})
env.filters.update(
datetimeformat=babel.datetimefmt,
dateformat=babel.datefmt,
timeformat=babel.timefmt,
natural_period=natural_period,
# timedeltaformat=format_timedelta,
numberformat=babel.numberfmt,
decimalformat=babel.decimalfmt,
currencyformat=babel.currencyfmt,
percentformat=babel.percentfmt,
scientificformat=babel.scientificfmt,
append_get=do_append_get,
class_name=do_class_name,
)
env.add_extension('jinja2.ext.loopcontrols')
env.add_extension('jinja2.ext.with_')
env.add_extension('dinja2.ext.active')
# from ext.relative_templates import RelativeInclude
# env.add_extension(RelativeInclude)
# env.add_extension('jinja2_highlight.HighlightExtension')
# env.add_extension('jinja2htmlcompress.HTMLCompress')
env.add_extension('webassets.ext.jinja2.AssetsExtension')
env.assets_environment = get_env()
env.add_extension('jinja2.ext.i18n')
if settings.USE_I18N:
from django.utils import translation
env.install_gettext_translations(translation, newstyle=True)
else: # pragma: no cover
env.install_null_translations(newstyle=True)
return env
def load(template, env, kwargs):
if env:
env.add_extension(EvalExtension)
else:
try:
path = os.path.dirname(os.path.abspath(template))
template = os.path.split(os.path.abspath(template))[-1]
env = Environment(loader=FileSystemLoader(path))
env.add_extension(EvalExtension)
template = env.get_template(template).render(kwargs)
except:
env = Environment(loader=BaseLoader())
env.add_extension(EvalExtension)
template = env.from_string(template).render(kwargs)
replace = [item.strip() for item in re.findall('[ :]{{.+}}', template)]
for item in replace:
template = template.replace(item, '\'' + item + '\'')
return template
class Jinja2Engine(templates.TemplateEngine):
extension = 'jinja2'
def get_template(self, name, **kw):
self._lookup = Environment(loader=FileSystemLoader(self.directories, **kw))
self._lookup.filters.update(
#如果你想要在模板里添加filter，可以在这里添加
field_label = field_label,
field_name = field_name,
)
#增加这个扩展可以让我们在模板的循环块里使用break，continue
self._lookup.add_extension('jinja2.ext.loopcontrols')
#增加这个扩展可以让我们在模板里使用do关键字，用来进行一些python语句操作
self._lookup.add_extension('jinja2.ext.do')
return self._lookup.get_template("%s.%s" % (name, self.extension))
def render(self, template_name, **kwargs):
template = self._lookup.get_template("%s.%s" % (template_name, self.extension))
return template.render(**kwargs)
def create_report_environment():
# prepare jinja2 environment
from orun.reports.engines.chrome.filters import localize, linebreaks, groupby
from orun.reports.engines.chrome.extension import ReportExtension
from orun.reports.engines.chrome.utils import avg, total, to_list, COUNT, AVG, SUM
env = Environment()
env.autoescape = False
env.add_extension(ReportExtension)
env.finalize = localize
# env.undefined = SilentUndefined
env.filters['localize'] = localize
env.filters['linebreaks'] = linebreaks
# env.globals['static_fs'] = self.static_fs
env.filters['total'] = total
env.globals['avg'] = avg
env.globals['sum'] = sum
env.globals['count'] = len
env.globals['COUNT'] = COUNT
env.globals['SUM'] = SUM
env.globals['AVG'] = AVG
from orun.reports.data import DataSource
env.globals['create_datasource'] = lambda sql: DataSource(sql)
def environment(**options):
env = Environment(**options)
env.globals.update({
"static": staticfiles_storage.url,
"url": reverse,
"curr_year": datetime.today().year,
})
env.install_gettext_callables(gettext=gettext,
ngettext=ngettext,
newstyle=True)
env.add_extension(LanguageExtension)
env.policies["json.dumps_function"] = datetime_dumps
env.filters.update({
"datetime": datetime_filter,
"date": date_filter,
"number_format": number_format,
"excerpt_markdown": excerpt_markdown,
"markdown": markdown_filter,
})
return env
def render(filename, path, **kwargs):
"""Render template with some info variables.
>>> from jinja2_template_info import render
>>> render("test.html", "./", debug=True,
... code_variable="Variable from code")
... # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE
'<!DOCTYPE html>...</html>'
"""
info_path = files('jinja2_template_info')
if isinstance(path, (list, tuple)):
path = tuple(path) + (info_path, )
else: # str
path = (info_path, path)
env = Environment(loader=FileSystemLoader(path))
if kwargs.get("debug"):
env.add_extension(TemplateInfoExtension)
env.globals['template_info'].data = kwargs.copy()
env.globals['template_info'].template = filename
template = env.get_template(filename)
return template.render(kwargs)
class TestLoader(TempEnvironmentHelper):
default_files = {
'template.html': """
<h1>Test</h1>
{% if foo %}
{% assets "A", "B", "C", output="output.html" %}
{{ ASSET_URL }}
{% endassets %}
{% endif %}
"""
}
def setup(self):
TempEnvironmentHelper.setup(self)
self.jinja_env = JinjaEnvironment()
self.jinja_env.add_extension(AssetsExtension)
self.jinja_env.assets_environment = self.env
def test(self):
loader = Jinja2Loader(self.env, [self.tempdir], [self.jinja_env])
bundles = loader.load_bundles()
assert len(bundles) == 1
assert bundles[0].output == "output.html"
class JinjaLayoutTestCase(unittest.TestCase):
def setUp(self):
self.env = Environment(loader=FileSystemLoader(templates_path))
self.env.add_extension(LayoutExtension)
self.env.default_layout = "base.html"
def test_blocks(self):
html = self.env.get_template("blocks.html").render()
self.assertIn("title=foobar", html)
self.assertIn("content=hello world", html)
def test_mixed(self):
html = self.env.get_template("mixed.html").render()
self.assertIn("title=foobar", html)
self.assertIn("content=\n\nhello world", html)
def test_noblock(self):
html = self.env.get_template("noblock.html").render()
self.assertIn("data=\nhello world", html)
def test_disable_layout(self):
self.env.disable_layout = True
html = self.env.get_template("blocks.html").render()
self.assertEquals("hello world", html)
class JinjaLayoutTestCase(unittest.TestCase):
def setUp(self):
self.env = Environment(loader=FileSystemLoader(templates_path))
self.env.add_extension(LayoutExtension)
self.env.default_layout = "base.html"
def test_blocks(self):
html = self.env.get_template("blocks.html").render()
self.assertIn("title=foobar", html)
self.assertIn("content=hello world", html)
def test_mixed(self):
html = self.env.get_template("mixed.html").render()
self.assertIn("title=foobar", html)
self.assertIn("content=\n\nhello world", html)
def test_noblock(self):
html = self.env.get_template("noblock.html").render()
self.assertIn("data=\nhello world", html)
def test_disable_layout(self):
self.env.disable_layout = True
html = self.env.get_template("blocks.html").render()
self.assertEquals("hello world", html)
def render(self, variables):
"""
Render the template using Jinja2.
"""
subject, body = "", ""
environment = Environment(
loader=PeeringManagerLoader(),
trim_blocks=self.jinja2_trim,
lstrip_blocks=self.jinja2_lstrip,
)
environment.add_extension(IncludeTemplateExtension)
for extension in settings.JINJA2_TEMPLATE_EXTENSIONS:
environment.add_extension(extension)
# Add custom filters to our environment
environment.filters.update(FILTER_DICT)
try:
jinja2_template = environment.from_string(self.subject)
subject = jinja2_template.render(variables)
except TemplateSyntaxError as e:
subject = (
f"Syntax error in subject template at line {e.lineno}: {e.message}"
)
except Exception as e:
subject = str(e)
try:
jinja2_template = environment.from_string(self.template)
body = jinja2_template.render(variables)
except TemplateSyntaxError as e:
body = f"Syntax error in body template at line {e.lineno}: {e.message}"
except Exception:
body = traceback.format_exc()
return subject, body
class JinjaMacroTagTestCase(unittest.TestCase):
def setUp(self):
self.env = Environment(loader=FileSystemLoader(templates_path))
self.env.add_extension(LoadMacroExtension)
self.env.add_extension(CallMacroTagExtension)
self.env.add_extension(JinjaMacroTagsExtension)
self.env.add_extension(HtmlMacroTagsExtension)
self.env.autoload_macro_tags = True
def test_register_macro_from_template(self):
self.env.macros.register_from_template("macros.html")
self.assertTrue(self.env.macros.exists("panel"))
def test_register_macro_from_file(self):
def register_file():
self.env.macros.register_file(
os.path.join(templates_path, "macros.html"))
self.assertRaises(Exception, register_file)
self.env.loader = MacroLoader(self.env.loader)
register_file()
self.assertTrue(self.env.macros.exists("panel"))
def test_jinja_macro_tag(self):
self.env.macros.register_from_template("macros.html")
tpl = self.env.get_template("jinja_style.html")
self.assert_html(tpl.render())
def test_html_macro_tag(self):
self.env.macros.register_from_template("macros.html")
tpl = self.env.get_template("html_style.html")
self.assert_html(tpl.render())
def assert_html(self, html):
self.assertIn('<div class="panel-title">test panel</div>', html)
self.assertIn(
'<div><button type="button" class="btn btn-default">click me</button></div>',
html)
self.assertIn(
'<button type="button" class="btn btn-primary">click me</button>',
html)
class Template():
"""Class to handle templates."""
def __init__(self, logya_inst):
"""Initialize template environment."""
self.vars = {}
self.dir_templates = logya_inst.dir_templates
self.env = Environment(loader=TemplateLoader(self.dir_templates))
# Enable break and continue in templates.
self.env.add_extension('jinja2.ext.loopcontrols')
# Enable with statement for nested variable scopes.
self.env.add_extension('jinja2.ext.with_')
# Enable expression-statement extension that adds the do tag.
self.env.add_extension('jinja2.ext.do')
# Trim whitespace around template tags if configured.
tpl_settings = logya_inst.config.get('template')
if tpl_settings and tpl_settings.get('trim_whitespace'):
self.env.lstrip_blocks = True
self.env.trim_blocks = True
# Return an alphabetical index for a list of collection tuples.
self.env.globals[
'collection_index'] = lambda collection, non_ascii_key='_': collection_index(
collection, non_ascii_key)
# Return an alphabetical index for a list of doc objects.
self.env.globals[
'doc_index'] = lambda docs, attr='title', non_ascii_key='_': doc_index(
docs, attr, non_ascii_key)
# Include the source of a file.
self.env.globals[
'filesource'] = lambda x, lines=None, raw=False: filesource(
logya_inst, x, lines=lines, raw=raw)
# Get a document from its URL.
self.env.globals['get_doc'] = lambda x: get_doc(logya_inst, x)
# Filter docs list where the given attribute contains the given value.
self.env.filters['attr_contains'] = lambda docs, attr, val: [
doc for doc in docs if attr in doc and val in doc[attr]
]
# Create slugs for use in URLs
self.env.filters['slugify'] = slugify
class Template():
"""Class to handle templates."""
def __init__(self, logya_inst):
"""Initialize template environment."""
self.vars = {}
self.dir_templates = logya_inst.dir_templates
self.env = Environment(loader=TemplateLoader(self.dir_templates))
# Enable break and continue in templates.
self.env.add_extension('jinja2.ext.loopcontrols')
# Enable with statement for nested variable scopes.
self.env.add_extension('jinja2.ext.with_')
# Enable expression-statement extension that adds the do tag.
self.env.add_extension('jinja2.ext.do')
# Trim whitespace around template tags if configured.
tpl_settings = logya_inst.config.get('template')
if tpl_settings and tpl_settings.get('trim_whitespace'):
self.env.lstrip_blocks = True
self.env.trim_blocks = True
# Include the source of a file.
self.env.globals[
'filesource'] = lambda x, lines=None, raw=False: filesource(
logya_inst, x, lines=lines, raw=raw)
# Get a document from its URL.
self.env.globals['get_doc'] = lambda x: get_doc(logya_inst, x)
# Filter docs list where the given attribute contains the given value.
self.env.filters['attr_contains'] = lambda docs, attr, val: [
doc for doc in docs if attr in doc and val in doc[attr]
]
# Create slugs for use in URLs
self.env.filters['slugify'] = slugify
def get_page(self, doc, template):
try:
page = self.env.get_template(template)
except TemplateNotFound as err:
raise TemplateNotFound('Doc: {}\n{}'.format(doc, err))
return page
class Template():
"""Class to handle templates."""
def __init__(self, logya_inst):
"""Initialize template environment."""
self.vars = {}
self.dir_templates = logya_inst.dir_templates
self.env = Environment(loader=TemplateLoader(self.dir_templates))
# Enable break and continue in templates.
self.env.add_extension('jinja2.ext.loopcontrols')
# Enable with statement for nested variable scopes.
self.env.add_extension('jinja2.ext.with_')
# Enable expression-statement extension that adds the do tag.
self.env.add_extension('jinja2.ext.do')
# Trim whitespace around template tags if configured.
tpl_settings = logya_inst.config.get('template')
if tpl_settings and tpl_settings.get('trim_whitespace'):
self.env.lstrip_blocks = True
self.env.trim_blocks = True
# Include the source of a file.
self.env.globals['filesource'] = lambda x, lines=None, raw=False: filesource(
logya_inst, x, lines=lines, raw=raw)
# Get a document from its URL.
self.env.globals['get_doc'] = lambda x: get_doc(logya_inst, x)
# Filter docs list where the given attribute contains the given value.
self.env.filters['attr_contains'] = lambda docs, attr, val: [
doc for doc in docs if attr in doc and val in doc[attr]]
# Create slugs for use in URLs
self.env.filters['slugify'] = slugify
def get_page(self, doc, template):
try:
page = self.env.get_template(template)
except TemplateNotFound as err:
raise TemplateNotFound('Doc: {}\n{}'.format(doc, err))
return page
def environment(**options):
from django.conf import settings
from django.urls import translate_url
from django.utils import translation
env = Environment(extensions=["jinja2.ext.i18n"], **options)
env.install_gettext_translations(translation)
env.globals.update(
{
"_": gettext,
"get_messages": messages.get_messages,
"settings": settings,
"static": staticfiles_storage.url,
"url": reverse,
"get_language": translation.get_language,
"translate_url": translate_url,
}
)
from django_zero.config.settings import features
if features.is_webpack_enabled():
env.globals.update(
{
"assets": assets.get_helper(),
}
)
env.add_extension(DjangoCsrfExtension)
try:
from django_includes.jinja2 import DjangoIncludesExtension
env.add_extension(DjangoIncludesExtension)
except ImportError:
pass
env.add_extension(DjangoUrlExtension)
env.add_extension(SpacelessExtension)
return env
def test_extend_late(self):
env = Environment()
env.add_extension('jinja2.ext.autoescape')
t = env.from_string('{% autoescape true %}{{ "<test>" }}{% endautoescape %}')
"tabs": tabs,
"css_blocks": css_blocks,
"js_blocks": js_blocks
}
# Jinja settings
code_dir = os.path.dirname(os.path.abspath(__file__))
html_dir = os.path.join(code_dir, "templates")
loader = FileSystemLoader(html_dir)
env = Environment(loader=loader, autoescape=select_autoescape(['html', 'xml']))
# This add an include option that do not treat the content of the file as a jinja template
env.globals['include_static'] = include_static
# Add {% do <statement> %}
env.add_extension("jinja2.ext.do")
# Parsing fonts, audio and bestiary
params = {}
for root, dirs, filenames in os.walk(os.path.join(html_dir, "../font")):
for filename in filenames:
if filename[-4:] == ".ttf":
with open(os.path.join(root, filename), "rb") as extern_file:
params[filename.split(".")[0] + "_font"] = base64.b64encode(
extern_file.read()).decode()
for root, dirs, filenames in os.walk(os.path.join(html_dir, "../audio")):
for filename in filenames:
if filename[-4:] == ".wav":
with open(os.path.join(root, filename), "rb") as extern_file:
return decorate
def url_for(endpoint, _external=False, **values):
return local.url_adapter.build(endpoint, values, force_external=_external)
def render_template(template, **context):
return Response(jinja_env.get_template(template).render(**context),
mimetype='text/html')
def scheduler_uptime():
time_diff = datetime.utcnow() - settings.settings['process_start_time']
d = {'days': time_diff.days}
d['hours'], rem = divmod(time_diff.seconds, 3600)
d['minutes'], d['seconds'] = divmod(rem, 60)
return '{days:02d}:{hours:02d}:{minutes:02d}:{seconds:02d}'.format(**d)
jinja_env = Environment(loader=FileSystemLoader(TEMPLATE_PATH), autoescape=True)
jinja_env.add_extension('jinja2.ext.do')
jinja_env.globals['url_for'] = url_for
jinja_env.globals['local'] = local
jinja_env.globals['get_current_time'] = lambda: datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S %Z')
jinja_env.globals['scheduler_version'] = lambda: settings.settings['version']
jinja_env.globals['scheduler_uptime'] = scheduler_uptime
jinja_env.globals['mx_processing_context'] = mx_page_context
jinja_env.globals['synergy_process_context'] = context.process_context
jinja_env.filters['jsonify'] = json.dumps
else:
if tuple(map(int, np.__version__.split('.')[:2])) < (1, 8):
raise ImportError('Numpy v1.8 or later is required.')
_PY3K = PY3K = sys.version_info[0] > 2
PY2K = not PY3K
VERSION = __version__
def is_float(n):
return isinstance(n, float)
TPLPATH = "{}/templates/".format(os.path.dirname(__file__))
jinja2_ENV = Environment(loader=FileSystemLoader(TPLPATH))
jinja2_ENV.add_extension('jinja2.ext.loopcontrols')
jinja2_ENV.tests['Float'] = is_float
MODELPATH = "{}/models/".format(os.path.dirname(__file__))
data = "{}{}{}{}{}".format(
sysconfig.get_path('data'),
os.sep, 'share', os.sep, 'tappm', os.sep, 'data')
__all__ = []
from .dataset_maker import *
from .method_hmm import *
from .utils import *
from .hmm import *
def render_page(self, root, file):
input_file = os.path.join(root, file)
output_file = self.__get_page_filename(input_file)
partial = yaml.load(open(input_file, "r").read())
url_root = os.getenv("ROOT_DIRECTORY") or ""
# if main index page, add version number from VERSION.txt
if self.__is_main_index(output_file):
partial['content'] = pystache.render(
partial['content'], {"version": self.get_version()}
)
else:
partial['pageHeading'] = partial['pageTitle']
partial['pageTitle'] = (
partial['pageTitle'] +
" - Digital Marketplace frontend toolkit"
)
if "examples" in partial:
template_name, template_extension = os.path.splitext(file)
template_subfolder = root.replace(self.pages_dirname, "").strip("/")
env = Environment(
loader=FileSystemLoader(os.path.join(self.repo_root, "toolkit/templates"))
)
env.filters.update({
'markdown': markdown_filter,
})
# used in `toolkit/templates/summary-table.html` for a conditional import statement
env.globals['PAGES_BUILDER'] = True
env.add_extension('jinja2.ext.with_')
template_file = os.path.join(template_subfolder, template_name + ".html")
template = None
# not all of our examples have template files (`_lists.scss`, for example)
if os.path.isfile(os.path.join(self.repo_root, "toolkit/templates", template_file)):
template = env.get_template(template_file)
examples = []
for index, example in enumerate(partial["examples"]):
grid = partial.get('grid')
if isinstance(example, dict):
example_template = self.parameters_example(template_subfolder, template_name, example)
example_markup = template.render(example)
# set a grid if specified. Example-level grids will overwrite the one for the page
grid = example.get('grid', partial.get('grid'))
else:
example_template = example
example_markup = env.from_string(example_template).render({})
examples.append({
"markup": example_markup,
"highlighted_markup": highlight(example_markup, HtmlLexer(), HtmlFormatter(noclasses=True)),
"grid": grid
})
if template:
examples[-1].update(
{"parameters": highlight(example_template, DjangoLexer(), HtmlFormatter(noclasses=True))}
)
partial_data = {
"examples": examples,
"pageTitle": partial['pageTitle'],
"pageDescription": partial.get('pageDescription'),
"pageHeading": partial['pageHeading'],
"templateFile": template_file,
"urlRoot": url_root
}
if "grid" in partial:
partial_data['grid'] = partial['grid']
partial['content'] = self.render_include(
os.path.join(self.repo_root, "pages_builder", "includes", "content.html"),
partial_data
)
partial['head'] = self.render_include(
os.path.join(self.repo_root, "pages_builder", "includes", "head.html"),
{"url_root": url_root}
)
bodyEnd = partial['bodyEnd'] if "bodyEnd" in partial else ""
partial['bodyEnd'] = self.render_include(
os.path.join(self.repo_root, "pages_builder", "includes", "bodyEnd.html"),
{
"url_root": url_root,
"bodyEnd": bodyEnd
}
)
page_render = pystache.render(self.template_view, partial)
print "\n " + input_file
print "▸ " + output_file
open(output_file, "w+").write(page_render.encode('utf-8'))
# Memorydata
host_data['mem_data'] = data.ix[:, 20].apply(lambda x: x / 1024000).to_json(date_format='iso')
# Disk data
host_data['disk_read'] = data.ix[:, 66].apply(lambda x: x / 1024).to_json(date_format='iso')
host_data['disk_write'] = data.ix[:, 67].apply(lambda x: x / 1024).to_json(date_format='iso')
# Network Data
host_data['net_rx'] = data.ix[:, 57].to_json(date_format='iso')
host_data['net_tx'] = data.ix[:, 58].to_json(date_format='iso')
hosts.append(host_data)
env = Environment(loader=FileSystemLoader('templates'))
env.add_extension("chartkick.ext.charts")
cpu_template = env.get_template('cpu_template.html')
memory_template = env.get_template('memory_template.html')
disk_template = env.get_template('disk_template.html')
network_template = env.get_template('network_template.html')
cpu_output = cpu_template.render(
hosts=sorted(hosts, key=itemgetter('name'), reverse=True),
)
memory_output = memory_template.render(
hosts=sorted(hosts, key=itemgetter('name'), reverse=True),
)
disk_output = disk_template.render(
hosts=sorted(hosts, key=itemgetter('name'), reverse=True),
)
class Site:
def __init__(self):
self.cfg = Config()
self.url = self.cfg.url
self.title = self.cfg.title
self.author = self.cfg.author
self.loader = FileSystemLoader(ROOT_PATH)
self.env = Environment(loader=self.loader)
for ttag in templatetags:
self.env.add_extension(ttag)
self.env.add_extension(SkipBlockExtension)
for tfunc in functions:
self.env.globals[tfunc.__name__] = tfunc
for tfilter in filters:
self.env.filters[tfilter.__name__] = tfilter
self.env.globals['site'] = self
self.entries = []
self.url_lookup = {}
self.url_loopup_reverse = {}
self.dest = os.path.join(os.path.abspath(ROOT_PATH), '_build')
def exclude_path(self, path):
for exc in self.cfg.exclude:
if exc.search(path):
return True
return False
def process_path(self, path):
for rule, repl in self.cfg.rules:
match = rule.match(path)
if match:
return rule.sub(repl, path), match
return path, None
def traverse(self):
for root, _, files in os.walk(ROOT_PATH):
for f in files:
path = os.path.join(root, f)
path = os.path.relpath(path, ROOT_PATH)
if self.exclude_path(path):
continue
url, match = self.process_path(path)
print(path, '->', url)
self.add_page(path, url, match)
def add_page(self, path, url, match):
entryclass = match and Entry or StaticEntry
entry = entryclass(self, path, url)
self.entries.append(entry)
self.url_lookup[path] = entry
self.url_loopup_reverse[url] = entry
if match:
url_settings = match.groupdict()
entry.settings.update(url_settings)
return entry
@property
def posts(self):
posts = [p for p in self.entries if p.path == 'blog/index.html']
if not posts:
return None
return posts[0].children
def render_meta(self):
for entry in self.entries:
entry.patch()
for entry in self.entries:
print('Render meta', entry)
entry.render_meta()
def render(self):
self.env.cache.clear()
self.env.skip_blocks.append('meta')
for entry in self.entries:
print('Render', entry)
entry.render()
class TestTemplateTag(object):
def setup(self):
# Setup the assets environment.
assets_env = AssetsEnvironment('', '')
self.foo_bundle = Bundle()
self.bar_bundle = Bundle()
assets_env.register('foo_bundle', self.foo_bundle)
assets_env.register('bar_bundle', self.bar_bundle)
# Inject a mock bundle class into the Jinja2 extension, so we
# can check on what exactly it does.
test_instance = self
class MockBundle(Bundle):
urls_to_fake = ['foo']
def __init__(self, *a, **kw):
Bundle.__init__(self, *a, **kw)
self.env = assets_env
# Kind of hacky, but gives us access to the last Bundle
# instance used by the extension.
test_instance.the_bundle = self
def urls(self, *a, **kw):
return self.urls_to_fake
self._old_bundle_class = AssetsExtension.BundleClass
AssetsExtension.BundleClass = self.BundleClass = MockBundle
# Setup the Jinja2 environment.
self.jinja_env = JinjaEnvironment()
self.jinja_env.add_extension(AssetsExtension)
self.jinja_env.assets_environment = assets_env
def teardown(self):
AssetsExtension.BundleClass = self._old_bundle_class
del self._old_bundle_class
def render_template(self, args, ctx={}):
return self.jinja_env.from_string(
'{% assets ' + args +
' %}{{ ASSET_URL }};{% endassets %}').render(ctx)
def test_reference_bundles(self):
self.render_template('"foo_bundle", "bar_bundle"')
assert self.the_bundle.contents == (self.foo_bundle, self.bar_bundle)
def test_reference_files(self):
self.render_template('"file1", "file2", "file3"')
assert self.the_bundle.contents == (
'file1',
'file2',
'file3',
)
def test_reference_mixed(self):
self.render_template('"foo_bundle", "file2", "file3"')
assert self.the_bundle.contents == (
self.foo_bundle,
'file2',
'file3',
)
def test_with_vars(self):
self.render_template('var1, var2', {
'var1': self.foo_bundle,
'var2': 'a_file'
})
assert self.the_bundle.contents == (
self.foo_bundle,
'a_file',
)
def test_output_urls(self):
"""Ensure the tag correcly spits out the urls the bundle returns.
"""
self.BundleClass.urls_to_fake = ['foo', 'bar']
assert self.render_template('"file1" "file2" "file3"') == 'foo;bar;'
class Render(object):
"""
The core jinja2 render.
This is the bridge between your ViUR modules and your templates.
First, the default jinja2-api is exposed to your templates. See http://jinja.pocoo.org/ for
more information. Second, we'll pass data das global variables to templates depending on the
current action.
- For list() we'll pass `skellist` - a :py:class:`server.render.jinja2.default.SkelListWrapper` instance
- For view(): skel - a dictionary with values from the skeleton prepared for use inside html
- For add()/edit: a dictionary as `skel` with `values`, `structure` and `errors` as keys.
Third, a bunch of global filters (like urlencode) and functions (getEntry, ..) are available to templates.
See the ViUR Documentation for more information about functions and data available to jinja2 templates.
Its possible for modules to extend the list of filters/functions available to templates by defining
a function called `jinjaEnv`. Its called from the render when the environment is first created and
can extend/override the functionality exposed to templates.
"""
kind = "html"
listTemplate = "list"
viewTemplate = "view"
addTemplate = "add"
editTemplate = "edit"
addSuccessTemplate = "add_success"
editSuccessTemplate = "edit_success"
deleteSuccessTemplate = "delete_success"
listRepositoriesTemplate = "list_repositories"
listRootNodeContentsTemplate = "list_rootNode_contents"
addDirSuccessTemplate = "add_dir_success"
renameSuccessTemplate = "rename_success"
copySuccessTemplate = "copy_success"
reparentSuccessTemplate = "reparent_success"
setIndexSuccessTemplate = "setindex_success"
cloneSuccessTemplate = "clone_success"
__haveEnvImported_ = False
def __init__(self, parent=None, *args, **kwargs):
super(Render, self).__init__(*args, **kwargs)
if not Render.__haveEnvImported_:
# We defer loading our plugins to this point to avoid circular imports
# noinspection PyUnresolvedReferences
from . import env
Render.__haveEnvImported_ = True
self.parent = parent
def getTemplateFileName(self, template, ignoreStyle=False):
"""
Returns the filename of the template.
This function decides in which language and which style a given template is rendered.
The style is provided as get-parameters for special-case templates that differ from
their usual way.
It is advised to override this function in case that
:func:`server.render.jinja2.default.Render.getLoaders` is redefined.
:param template: The basename of the template to use.
:type template: str
:param ignoreStyle: Ignore any maybe given style hints.
:type ignoreStyle: bool
:returns: Filename of the template
:rtype: str
"""
validChars = "abcdefghijklmnopqrstuvwxyz1234567890-"
if "htmlpath" in dir(self):
htmlpath = self.htmlpath
else:
htmlpath = "html"
currReq = currentRequest.get()
if not ignoreStyle \
and "style" in currReq.kwargs \
and all([x in validChars for x in currReq.kwargs["style"].lower()]):
stylePostfix = "_" + currReq.kwargs["style"]
else:
stylePostfix = ""
lang = currentLanguage.get() # session.current.getLanguage()
fnames = [template + stylePostfix + ".html", template + ".html"]
if lang:
fnames = [
os.path.join(lang, template + stylePostfix + ".html"),
template + stylePostfix + ".html",
os.path.join(lang, template + ".html"), template + ".html"
]
for fn in fnames: # check subfolders
prefix = template.split("_")[0]
if os.path.isfile(
os.path.join(utils.projectBasePath, htmlpath, prefix, fn)):
return ("%s/%s" % (prefix, fn))
for fn in fnames: # Check the templatefolder of the application
if os.path.isfile(os.path.join(utils.projectBasePath, htmlpath,
fn)):
return fn
for fn in fnames: # Check the fallback
if os.path.isfile(
os.path.join(utils.projectBasePath, "viur", "core",
"template", fn)):
return fn
raise errors.NotFound("Template %s not found." % template)
def getLoaders(self):
"""
Return the list of Jinja2 loaders which should be used.
May be overridden to provide an alternative loader
(e.g. for fetching templates from the datastore).
"""
if "htmlpath" in dir(self):
htmlpath = self.htmlpath
else:
htmlpath = "html/"
return ChoiceLoader([
FileSystemLoader(htmlpath),
FileSystemLoader("viur/core/template/")
])
def renderBoneStructure(self, bone):
"""
Renders the structure of a bone.
This function is used by :func:`renderSkelStructure`.
can be overridden and super-called from a custom renderer.
:param bone: The bone which structure should be rendered.
:type bone: Any bone that inherits from :class:`server.bones.base.baseBone`.
:return: A dict containing the rendered attributes.
:rtype: dict
"""
# Base bone contents.
ret = {
"descr": str(bone.descr),
"type": bone.type,
"required": bone.required,
"multiple": bone.multiple,
"params": bone.params,
"visible": bone.visible,
"readOnly": bone.readOnly
}
if bone.type == "relational" or bone.type.startswith("relational."):
ret.update({
"module":
bone.module,
"format":
bone.format,
"using":
self.renderSkelStructure(bone.using()) if bone.using else None,
"relskel":
self.renderSkelStructure(bone._refSkelCache())
})
elif bone.type == "record" or bone.type.startswith("record."):
ret.update({
"format": bone.format,
"using": self.renderSkelStructure(bone.using())
})
elif bone.type == "select" or bone.type.startswith("select."):
ret.update({
"values": {k: str(v)
for (k, v) in bone.values.items()},
"multiple": bone.multiple
})
elif bone.type == "date" or bone.type.startswith("date."):
ret.update({"date": bone.date, "time": bone.time})
elif bone.type == "numeric" or bone.type.startswith("numeric."):
ret.update({
"precision": bone.precision,
"min": bone.min,
"max": bone.max
})
elif bone.type == "text" or bone.type.startswith("text."):
ret.update({
"validHtml": bone.validHtml,
"languages": bone.languages
})
elif bone.type == "str" or bone.type.startswith("str."):
ret.update({
"languages": bone.languages,
"multiple": bone.multiple
})
elif bone.type == "captcha" or bone.type.startswith("captcha."):
ret.update({
"publicKey": bone.publicKey,
})
return ret
def renderSkelStructure(self, skel):
"""
Dumps the structure of a :class:`server.db.skeleton.Skeleton`.
:param skel: Skeleton which structure will be processed.
:type skel: server.db.skeleton.Skeleton
:returns: The rendered dictionary.
:rtype: dict
"""
res = OrderedDict()
for key, bone in skel.items():
if "__" in key or not isinstance(bone, baseBone):
continue
res[key] = self.renderBoneStructure(bone)
if key in skel.errors:
res[key]["error"] = skel.errors[key]
else:
res[key]["error"] = None
return res
def renderBoneValue(self,
bone,
skel,
key,
boneValue,
isLanguageWrapped: bool = False):
"""
Renders the value of a bone.
This function is used by :func:`collectSkelData`.
It can be overridden and super-called from a custom renderer.
:param bone: The bone which value should be rendered.
:type bone: Any bone that inherits from :class:`server.bones.base.baseBone`.
:return: A dict containing the rendered attributes.
:rtype: dict
"""
if bone.languages and not isLanguageWrapped:
res = LanguageWrapper(bone.languages)
if isinstance(boneValue, dict):
for language in bone.languages:
if language in boneValue:
res[language] = self.renderBoneValue(
bone, skel, key, boneValue[language], True)
return res
elif bone.type == "select" or bone.type.startswith("select."):
skelValue = boneValue
if isinstance(skelValue, list):
return {val: bone.values.get(val, val) for val in boneValue}
elif skelValue in bone.values:
return KeyValueWrapper(skelValue, bone.values[skelValue])
return KeyValueWrapper(skelValue, str(skelValue))
elif bone.type == "relational" or bone.type.startswith("relational."):
if isinstance(boneValue, list):
tmpList = []
for k in boneValue:
if not k:
continue
if bone.using is not None and k["rel"]:
k["rel"].renderPreparation = self.renderBoneValue
usingData = k["rel"]
else:
usingData = None
k["dest"].renderPreparation = self.renderBoneValue
tmpList.append({"dest": k["dest"], "rel": usingData})
return tmpList
elif isinstance(boneValue, dict):
if bone.using is not None and boneValue["rel"]:
boneValue["rel"].renderPreparation = self.renderBoneValue
usingData = boneValue["rel"]
else:
usingData = None
boneValue["dest"].renderPreparation = self.renderBoneValue
return {"dest": boneValue["dest"], "rel": usingData}
elif bone.type == "record" or bone.type.startswith("record."):
value = boneValue
if value:
if bone.multiple:
ret = []
for entry in value:
entry.renderPreparation = self.renderBoneValue
ret.append(entry)
return ret
value.renderPreparation = self.renderBoneValue
return value
elif bone.type == "password":
return ""
elif bone.type == "key":
return db.encodeKey(boneValue) if boneValue else None
else:
return boneValue
return None
def collectSkelData(self, skel):
"""
Prepares values of one :class:`server.db.skeleton.Skeleton` or a list of skeletons for output.
:param skel: Skeleton which contents will be processed.
:type skel: server.db.skeleton.Skeleton
:returns: A dictionary or list of dictionaries.
:rtype: dict | list
.. deprecated:: 3.0.0
This method is deprecated since ViUR 3.0. Instead, attach a renderPreparation method to the skeleton
and pass the skeleton itself.
"""
# logging.error("collectSkelData %s", skel)
if isinstance(skel, list):
return [self.collectSkelData(x) for x in skel]
res = {}
for key, bone in skel.items():
val = self.renderBoneValue(bone, skel, key, skel[key])
res[key] = val
if isinstance(res[key], list):
res[key] = ListWrapper(res[key])
return res
def add(self, skel, tpl=None, params=None, *args, **kwargs):
"""
Renders a page for adding an entry.
The template must construct the HTML-form on itself; the required information
are passed via skel.structure, skel.value and skel.errors.
A jinja2-macro, which builds such kind of forms, is shipped with the server.
Any data in \*\*kwargs is passed unmodified to the template.
:param skel: Skeleton of the entry which should be created.
:type skel: server.db.skeleton.Skeleton
:param tpl: Name of a different template, which should be used instead of the default one.
:type tpl: str
:param params: Optional data that will be passed unmodified to the template
:type params: object
:return: Returns the emitted HTML response.
:rtype: str
"""
if not tpl and "addTemplate" in dir(self.parent):
tpl = self.parent.addTemplate
tpl = tpl or self.addTemplate
template = self.getEnv().get_template(self.getTemplateFileName(tpl))
skeybone = baseBone(descr="SecurityKey", readOnly=True, visible=False)
skel.skey = skeybone
skel["skey"] = securitykey.create()
if currentRequest.get().kwargs.get("nomissing") == "1":
if isinstance(skel, SkeletonInstance):
super(SkeletonInstance, skel).__setattr__("errors", [])
skel.renderPreparation = self.renderBoneValue
return template.render(skel={
"structure": self.renderSkelStructure(skel),
"errors": skel.errors,
"value": skel
},
params=params,
**kwargs)
def edit(self, skel, tpl=None, params=None, **kwargs):
"""
Renders a page for modifying an entry.
The template must construct the HTML-form on itself; the required information
are passed via skel.structure, skel.value and skel.errors.
A jinja2-macro, which builds such kind of forms, is shipped with the server.
Any data in \*\*kwargs is passed unmodified to the template.
:param skel: Skeleton of the entry which should be modified.
:type skel: server.db.skeleton.Skeleton
:param tpl: Name of a different template, which should be used instead of the default one.
:type tpl: str
:param params: Optional data that will be passed unmodified to the template
:type params: object
:return: Returns the emitted HTML response.
:rtype: str
"""
if not tpl and "editTemplate" in dir(self.parent):
tpl = self.parent.editTemplate
tpl = tpl or self.editTemplate
template = self.getEnv().get_template(self.getTemplateFileName(tpl))
skeybone = baseBone(descr="SecurityKey", readOnly=True, visible=False)
skel.skey = skeybone
skel["skey"] = securitykey.create()
if currentRequest.get().kwargs.get("nomissing") == "1":
if isinstance(skel, SkeletonInstance):
super(SkeletonInstance, skel).__setattr__("errors", [])
skel.renderPreparation = self.renderBoneValue
return template.render(skel={
"structure": self.renderSkelStructure(skel),
"errors": skel.errors,
"value": skel
},
params=params,
**kwargs)
def addSuccess(self, skel, tpl=None, params=None, *args, **kwargs):
"""
Renders a page, informing that the entry has been successfully created.
:param skel: Skeleton which contains the data of the new entity
:type skel: server.db.skeleton.Skeleton
:param tpl: Name of a different template, which should be used instead of the default one.
:type tpl: str
:param params: Optional data that will be passed unmodified to the template
:type params: object
:return: Returns the emitted HTML response.
:rtype: str
"""
if not tpl:
if "addSuccessTemplate" in dir(self.parent):
tpl = self.parent.addSuccessTemplate
else:
tpl = self.addSuccessTemplate
template = self.getEnv().get_template(self.getTemplateFileName(tpl))
if isinstance(skel, SkeletonInstance):
skel.renderPreparation = self.renderBoneValue
return template.render({"skel": skel}, params=params, **kwargs)
def editSuccess(self, skel, tpl=None, params=None, *args, **kwargs):
"""
Renders a page, informing that the entry has been successfully modified.
:param skel: Skeleton which contains the data of the modified entity
:type skel: server.db.skeleton.Skeleton
:param tpl: Name of a different template, which should be used instead of the default one.
:type tpl: str
:param params: Optional data that will be passed unmodified to the template
:type params: object
:return: Returns the emitted HTML response.
:rtype: str
"""
if not tpl:
if "editSuccessTemplate" in dir(self.parent):
tpl = self.parent.editSuccessTemplate
else:
tpl = self.editSuccessTemplate
template = self.getEnv().get_template(self.getTemplateFileName(tpl))
if isinstance(skel, SkeletonInstance):
skel.renderPreparation = self.renderBoneValue
return template.render(skel=skel, params=params, **kwargs)
def deleteSuccess(self, skel, tpl=None, params=None, *args, **kwargs):
"""
Renders a page, informing that the entry has been successfully deleted.
The provided parameters depend on the application calling this:
List and Hierarchy pass the id of the deleted entry, while Tree passes
the rootNode and path.
:param params: Optional data that will be passed unmodified to the template
:type params: object
:param tpl: Name of a different template, which should be used instead of the default one.
:type tpl: str
:return: Returns the emitted HTML response.
:rtype: str
"""
if not tpl:
if "deleteSuccessTemplate" in dir(self.parent):
tpl = self.parent.deleteSuccessTemplate
else:
tpl = self.deleteSuccessTemplate
template = self.getEnv().get_template(self.getTemplateFileName(tpl))
return template.render(params=params, **kwargs)
def list(self, skellist, tpl=None, params=None, **kwargs):
"""
Renders a list of entries.
Any data in \*\*kwargs is passed unmodified to the template.
:param skellist: List of Skeletons with entries to display.
:type skellist: server.db.skeleton.SkelList
:param tpl: Name of a different template, which should be used instead of the default one.
:param: tpl: str
:param params: Optional data that will be passed unmodified to the template
:type params: object
:return: Returns the emitted HTML response.
:rtype: str
"""
if not tpl and "listTemplate" in dir(self.parent):
tpl = self.parent.listTemplate
tpl = tpl or self.listTemplate
try:
fn = self.getTemplateFileName(tpl)
except errors.HTTPException as e: # Not found - try default fallbacks
tpl = "list"
template = self.getEnv().get_template(self.getTemplateFileName(tpl))
for skel in skellist:
skel.renderPreparation = self.renderBoneValue
return template.render(skellist=skellist, params=params,
**kwargs) # SkelListWrapper(resList, skellist)
def listRootNodes(self, repos, tpl=None, params=None, **kwargs):
"""
Renders a list of available repositories.
:param repos: List of repositories (dict with "key"=>Repo-Key and "name"=>Repo-Name)
:type repos: list
:param tpl: Name of a different template, which should be used instead of the default one.
:param: tpl: str
:param params: Optional data that will be passed unmodified to the template
:type params: object
:return: Returns the emitted HTML response.
:rtype: str
"""
if "listRepositoriesTemplate" in dir(self.parent):
tpl = tpl or self.parent.listTemplate
if not tpl:
tpl = self.listRepositoriesTemplate
try:
fn = self.getTemplateFileName(tpl)
except errors.HTTPException as e: # Not found - try default fallbacks
tpl = "list"
template = self.getEnv().get_template(self.getTemplateFileName(tpl))
return template.render(repos=repos, params=params, **kwargs)
def view(self, skel, tpl=None, params=None, **kwargs):
"""
Renders a single entry.
Any data in \*\*kwargs is passed unmodified to the template.
:param skel: Skeleton to be displayed.
:type skellist: server.db.skeleton.Skeleton
:param tpl: Name of a different template, which should be used instead of the default one.
:param: tpl: str
:param params: Optional data that will be passed unmodified to the template
:type params: object
:return: Returns the emitted HTML response.
:rtype: str
"""
if not tpl and "viewTemplate" in dir(self.parent):
tpl = self.parent.viewTemplate
tpl = tpl or self.viewTemplate
template = self.getEnv().get_template(self.getTemplateFileName(tpl))
if isinstance(skel, SkeletonInstance):
skel.renderPreparation = self.renderBoneValue
return template.render(skel=skel, params=params, **kwargs)
## Extended functionality for the Tree-Application ##
def listRootNodeContents(self,
subdirs,
entries,
tpl=None,
params=None,
**kwargs):
"""
Renders the contents of a given RootNode.
This differs from list(), as one level in the tree-application may contains two different
child-types: Entries and folders.
:param subdirs: List of (sub-)directories on the current level
:type repos: list
:param entries: List of entries of the current level
:type entries: server.db.skeleton.SkelList
:param tpl: Name of a different template, which should be used instead of the default one
:param: tpl: str
:param params: Optional data that will be passed unmodified to the template
:type params: object
:return: Returns the emitted HTML response.
:rtype: str
"""
if "listRootNodeContentsTemplate" in dir(self.parent):
tpl = tpl or self.parent.listRootNodeContentsTemplate
else:
tpl = tpl or self.listRootNodeContentsTemplate
template = self.getEnv().get_template(self.getTemplateFileName(tpl))
return template.render(
subdirs=subdirs,
entries=[self.collectSkelData(x) for x in entries],
params=params,
**kwargs)
def addDirSuccess(self,
rootNode,
path,
dirname,
params=None,
*args,
**kwargs):
"""
Renders a page, informing that the directory has been successfully created.
:param rootNode: RootNode-key in which the directory has been created
:type rootNode: str
:param path: Path in which the directory has been created
:type path: str
:param dirname: Name of the newly created directory
:type dirname: str
:param params: Optional data that will be passed unmodified to the template
:type params: object
:return: Returns the emitted HTML response.
:rtype: str
"""
tpl = self.addDirSuccessTemplate
if "addDirSuccessTemplate" in dir(self.parent):
tpl = self.parent.addDirSuccessTemplate
template = self.getEnv().get_template(self.getTemplateFileName(tpl))
return template.render(rootNode=rootNode,
path=path,
dirname=dirname,
params=params)
def renameSuccess(self,
rootNode,
path,
src,
dest,
params=None,
*args,
**kwargs):
"""
Renders a page, informing that the entry has been successfully renamed.
:param rootNode: RootNode-key in which the entry has been renamed
:type rootNode: str
:param path: Path in which the entry has been renamed
:type path: str
:param src: Old name of the entry
:type src: str
:param dest: New name of the entry
:type dest: str
:param params: Optional data that will be passed unmodified to the template
:type params: object
:return: Returns the emitted HTML response.
:rtype: str
"""
tpl = self.renameSuccessTemplate
if "renameSuccessTemplate" in dir(self.parent):
tpl = self.parent.renameSuccessTemplate
template = self.getEnv().get_template(self.getTemplateFileName(tpl))
return template.render(rootNode=rootNode,
path=path,
src=src,
dest=dest,
params=params)
def copySuccess(self,
srcrepo,
srcpath,
name,
destrepo,
destpath,
type,
deleteold,
params=None,
*args,
**kwargs):
"""
Renders a page, informing that an entry has been successfully copied/moved.
:param srcrepo: RootNode-key from which has been copied/moved
:type srcrepo: str
:param srcpath: Path from which the entry has been copied/moved
:type srcpath: str
:param name: Name of the entry which has been copied/moved
:type name: str
:param destrepo: RootNode-key to which has been copied/moved
:type destrepo: str
:param destpath: Path to which the entries has been copied/moved
:type destpath: str
:param type: "entry": Copy/Move an entry, everything else: Copy/Move an directory
:type type: str
:param deleteold: "0": Copy, "1": Move
:type deleteold: str
:param params: Optional data that will be passed unmodified to the template
:type params: object
:return: Returns the emitted HTML response.
:rtype: str
"""
tpl = self.copySuccessTemplate
if "copySuccessTemplate" in dir(self.parent):
tpl = self.parent.copySuccessTemplate
template = self.getEnv().get_template(self.getTemplateFileName(tpl))
return template.render(srcrepo=srcrepo,
srcpath=srcpath,
name=name,
destrepo=destrepo,
destpath=destpath,
type=type,
deleteold=deleteold,
params=params)
def reparentSuccess(self, obj, tpl=None, params=None, **kwargs):
"""
Renders a page informing that the item was successfully moved.
:param obj: ndb.Expando instance of the item that was moved.
:type obj: ndb.Expando
:param tpl: Name of a different template, which should be used instead of the default one
:type tpl: str
:param params: Optional data that will be passed unmodified to the template
:type params: object
"""
if not tpl:
if "reparentSuccessTemplate" in dir(self.parent):
tpl = self.parent.reparentSuccessTemplate
else:
tpl = self.reparentSuccessTemplate
template = self.getEnv().get_template(self.getTemplateFileName(tpl))
return template.render(repoObj=obj, params=params, **kwargs)
def setIndexSuccess(self, obj, tpl=None, params=None, *args, **kwargs):
"""
Renders a page informing that the items sortindex was successfully changed.
:param obj: ndb.Expando instance of the item that was changed
:type obj: ndb.Expando
:param tpl: Name of a different template, which should be used instead of the default one
:type tpl: str
:param params: Optional data that will be passed unmodified to the template
:type params: object
:return: Returns the emitted HTML response.
:rtype: str
"""
if not tpl:
if "setIndexSuccessTemplate" in dir(self.parent):
tpl = self.parent.setIndexSuccessTemplate
else:
tpl = self.setIndexSuccessTemplate
template = self.getEnv().get_template(self.getTemplateFileName(tpl))
return template.render(skel=obj, repoObj=obj, params=params, **kwargs)
def cloneSuccess(self, tpl=None, params=None, *args, **kwargs):
"""
Renders a page informing that the items sortindex was successfully changed.
:param obj: ndb.Expando instance of the item that was changed
:type obj: ndb.Expando
:param tpl: Name of a different template, which should be used instead of the default one
:type tpl: str
:param params: Optional data that will be passed unmodified to the template
:type params: object
:return: Returns the emitted HTML response.
:rtype: str
"""
if not tpl:
if "cloneSuccessTemplate" in dir(self.parent):
tpl = self.parent.cloneSuccessTemplate
else:
tpl = self.cloneSuccessTemplate
template = self.getEnv().get_template(self.getTemplateFileName(tpl))
return template.render(params=params, **kwargs)
def renderEmail(self,
dests: List[str],
file: str = None,
template: str = None,
skel: Union[None, Dict, SkeletonInstance,
List[SkeletonInstance]] = None,
**kwargs) -> Tuple[str, str]:
"""
Renders an email.
Uses the first not-empty line as subject and the remaining template as body.
:param dests: Destination recipients.
:param file: The name of a template from the deploy/emails directory.
:param template: This string is interpreted as the template contents. Alternative to load from template file.
:param skel: Skeleton or dict which data to supply to the template.
:return: Returns the rendered email subject and body.
"""
if isinstance(skel, SkeletonInstance):
skel.renderPreparation = self.renderBoneValue
elif isinstance(skel, list) and all(
[isinstance(x, SkeletonInstance) for x in skel]):
for x in skel:
x.renderPreparation = self.renderBoneValue
if file is not None:
try:
tpl = self.getEnv().from_string(
codecs.open("emails/" + file + ".email", "r",
"utf-8").read())
except Exception as err:
logging.exception(err)
tpl = self.getEnv().get_template(file + ".email")
else:
tpl = self.getEnv().from_string(template)
content = tpl.render(skel=skel, dests=dests,
**kwargs).lstrip().splitlines()
if len(content) == 1:
content.insert(0, "") # add empty subject
return content[0], os.linesep.join(content[1:]).lstrip()
def getEnv(self):
"""
Constucts the Jinja2 environment.
If an application specifies an jinja2Env function, this function
can alter the environment before its used to parse any template.
:returns: Extended Jinja2 environment.
:rtype: jinja2.Environment
"""
def mkLambda(func, s):
return lambda *args, **kwargs: func(s, *args, **kwargs)
if not "env" in dir(self):
loaders = self.getLoaders()
self.env = Environment(loader=loaders,
extensions=[
"jinja2.ext.do",
"jinja2.ext.loopcontrols",
TranslationExtension
])
self.env.trCache = {}
# Import functions.
for name, func in jinjaUtils.getGlobalFunctions().items():
self.env.globals[name] = mkLambda(func, self)
# Import filters.
for name, func in jinjaUtils.getGlobalFilters().items():
self.env.filters[name] = mkLambda(func, self)
# Import extensions.
for ext in jinjaUtils.getGlobalExtensions():
self.env.add_extension(ext)
# Import module-specific environment, if available.
if "jinjaEnv" in dir(self.parent):
self.env = self.parent.jinjaEnv(self.env)
return self.env
class TestJinjaExtension(TempdirHelper):
default_files = {
'static/buttons.css': """
/*
A classic form button.
:hover - Highlights on hover.
:disabled - Mute inactive buttons.
Styleguide 1.1
*/
.button {}
""",
'static/minibuttons.css': """
/*
A mini button.
:hover - Highlights on hover.
:disabled - Mute inactive buttons.
Styleguide 1.2
*/
.minibutton {}
""",
'templates/custom.html': "{{ section.section }}{{ section.example }}\n\n",
}
def setup(self):
super(TestJinjaExtension, self).setup()
self.jinja_env = Environment()
self.jinja_env.add_extension(StyleguideExtension)
self.jinja_env.loader = FileSystemLoader('%s/templates' % self.tempdir)
self.jinja_env.styleguide_kss_parser = Parser('%s/static' % self.tempdir)
self.jinja_env.styleguide_template_name = 'custom.html'
def render_template(self, ref, example=''):
template_string = (
"{%% styleguide %(ref)s %%}"
"%(example)s"
"{%% endstyleguide %%}"
) % dict(ref=ref, example=example)
template = self.jinja_env.from_string(template_string)
return template.render()
def test_render_section(self):
assert self.render_template('1.1') == '1.1\n'
def test_render_subsections_as_well(self):
assert self.render_template('1') == '1.1\n1.2\n'
def test_render_when_section_does_not_exist(self):
assert self.render_template('0') == ''
def test_kss_parser_caches_output(self):
assert self.render_template('1') == '1.1\n1.2\n'
self.create_files(('static/buttons.css', 'static/minibuttons.css'))
assert self.render_template('1') == '1.1\n1.2\n'
def test_dedent_example(self):
example_html = """
<button>
<i></i>
</button>
"""
expected_html = textwrap.dedent(example_html)
assert self.render_template('1.1', example_html) == '1.1%s\n' % expected_html
def _render_from_settings(self, setting_name):
setting = getattr(self._settings, setting_name)
env = Environment()
env.add_extension('jinja2.ext.autoescape')
t = env.from_string(setting)
return t.render(self._template_vars())
import os
from jinja2 import Environment, FileSystemLoader
#-------------
# Environment
#-------------
template_root = '/var/www/webapps/templates'
JLOADER = FileSystemLoader(template_root, encoding='utf-8')
JENV = Environment(block_start_string='[[',
block_end_string=']]',
variable_start_string='[-',
variable_end_string='-]',
comment_start_string='[#',
comment_end_string='#]',
loader=JLOADER,
extensions=[],
cache_size=50,
)
JENV.add_extension('jinja2.ext.i18n')
JENV.add_extension('jinja2.ext.do')
def jrender(template_name, params=None):
if params is None:
params = {}
return JENV.get_template(template_name).render(params)
def generateJavaApplication(name, changesets):
# i is the number to be transform into byte array, n is the number of bytes to use (little endian)
def bytestring(i, n):
return ["(byte)" + str(ord(b)) for b in pack("H", i)][:n]
def nodeinjava(node):
return str(node.id)
def wuobjectinjava(wuobject):
return ", ".join([str(wuobject.wunode().id), str(wuobject.port_number)])
def linkinjava(link):
return ", ".join(
bytestring(link.from_component_index, 2)
+ bytestring(link.from_property_id, 1)
+ bytestring(link.to_component_index, 2)
+ bytestring(link.to_property_id, 1)
+ bytestring(link.to_wuclass_id, 2)
)
def wuclassname(wuclass):
return wuclass.name
def wuclassvirtualclassname(wuclass):
return "Virtual" + Convert.to_java(wuclass.name) + "WuObject"
def wuclassid(wuclass):
return str(wuclass.id)
def wuclassgenclassname(wuclass):
return "GENERATEDVirtual" + Convert.to_java(wuclass.name) + "WuObject"
def propertyconstname(property):
print "propertyconstname"
return (
"PROPERTY_"
+ Convert.to_constant(property.wuobject().wuclass().wuclassdef().name)
+ "_"
+ Convert.to_constant(property.wupropertydef().name)
)
# doesn't really matter to check since basic types are being take care of in application.java
def propertyconstantvalue(property):
wutype = WuTypeDef.where(name=property.datatype)
if wutype:
return (
wutype[0].type.upper()
+ "_"
+ Convert.to_constant(property.datatype)
+ "_"
+ Convert.to_constant(property.value)
)
else:
return "ENUM" + "_" + Convert.to_constant(property.datatype) + "_" + Convert.to_constant(property.value)
def generateProperties(wuobject_properties, component_properties):
properties = wuobject_properties
for property in properties:
if property.wupropertydef().name in component_properties:
property.value = component_properties[property.wupropertydef().name]
return properties
# Generate the Java code
print "[generator] generating", os.path.join(JAVA_OUTPUT_DIR, "WKDeploy.java")
jinja2_env = Environment(loader=FileSystemLoader([os.path.join(os.path.dirname(__file__), "jinja_templates")]))
jinja2_env.filters["nodeinjava"] = nodeinjava
jinja2_env.filters["wuclassname"] = wuclassname
jinja2_env.filters["wuclassvirtualclassname"] = wuclassvirtualclassname
jinja2_env.filters["wuclassid"] = wuclassid
jinja2_env.filters["wuclassgenclassname"] = wuclassgenclassname
jinja2_env.filters["propertyconstname"] = propertyconstname
jinja2_env.filters["propertyconstantvalue"] = propertyconstantvalue
jinja2_env.filters["generateProperties"] = generateProperties
jinja2_env.add_extension("jinja2.ext.do")
output = open(os.path.join(JAVA_OUTPUT_DIR, "WKDeploy.java"), "w")
output.write(jinja2_env.get_template("application2.java").render(name=name, changesets=changesets))
output.close()
class Renderer(object):
"""Renders a template."""
def __init__(self, path=None, loader=None, filters=None):
"""Constructs a new Renderer object.
Either path or loader has to be specified.
Keyword arguments:
path -- list or str which represents template locations
loader -- a jinja2 template loader instance (default: None)
filters -- dict containing filters (default: {})
"""
if (path is None and loader is None
or path is not None and loader is not None):
raise ValueError('Either specify path oder loader')
if path is not None:
loader = FileSystemLoader(path)
self._env = Environment(loader=loader)
self._env.add_extension('jinja2.ext.do')
self._add_filters(filters)
def _add_filters(self, filters):
"""Adds new filters to the jinja2 environment.
filters is a dict of filters.
"""
self._env.filters['dateformat'] = dateformat
self._env.filters.update(filters or {})
def _custom_template_names(self, template):
"""Returns a list of custom template names.
template is the name of the original template.
"""
splitted = template.rsplit('/', 1)
name = 'custom_' + splitted[-1]
ret = [name]
if len(splitted) == 2:
ret.append(splitted[0] + '/' + name)
return ret
def render_only(self, template, *args, **kwargs):
"""Renders template template.
The rendered template is returned (no data will be written
or printed).
*args and **kwargs are passed to jinja2 Template's render
method.
"""
names = self._custom_template_names(template)
names.append(template)
tmpl = self._env.select_template(names)
return tmpl.render(*args, **kwargs)
def _render(self, template, out, *args, **kwargs):
"""Renders template template.
out is a file or file-like object to which the rendered
template should be written to.
*args and **kwargs are passed to the render_only method.
"""
text = self.render_only(template, *args, **kwargs)
try:
out.write(text)
except UnicodeEncodeError:
text = text.encode('utf-8')
out.write(text)
def render(self, template, *args, **kwargs):
"""Renders template template.
Writes the rendered template to sys.stdout.
*args and **kwargs are passed to jinja2 Template's render
method.
"""
self._render(template, sys.stdout, *args, **kwargs)
def render_text(self, text, *args, **kwargs):
"""Renders text.
*args and **kwargs are passed to jinja2 Template's render
method.
"""
global TEXT_TEMPLATE
self.render(TEXT_TEMPLATE, text=text, *args, **kwargs)
def render_error(self, template, *args, **kwargs):
"""Renders template template.
Writes the rendered template to sys.stderr.
*args and **kwargs are passed to jinja2 Template's render
method.
"""
self._render(template, sys.stderr, *args, **kwargs)
def test_extend_late(self):
env = Environment()
env.add_extension('jinja2.ext.autoescape')
t = env.from_string('{% autoescape true %}{{ "<test>" }}{% endautoescape %}')
assert t.render() == '<test>'
class HTMLPage(Page, metaclass=Singleton):
"""
Base class for HTML UI pages.
Class Attributes:
_tpl (SharedData): Descriptor object that handles access to Jinja2 template environment.
Also see `Page.__doc__`
"""
_tpl = SharedData('_tpl')
_tpl_setup_ran = SharedData('_tpl_setup_running')
_top_level_tabs = SharedData('_top_level_tabs')
def __init__(self, name='HTMLPage', index=0, tpl_engine='jinja', *args, **kwargs):
"""
Attributes:
_tpl (Environment): The Jinja2 template environment.
Also see `Page.__doc__`.
Args:
name (str): A name for this widget.
"""
super().__init__(name=name, tpl_engine=tpl_engine, *args, **kwargs)
self.signals = ['go-to-next-page', '--trigger-event']
self.tabs = []
self.can_go_to_next_page = False
self.index = index
self.logger.debug('page index is %s', index)
if self._tpl is None and self._tpl_setup_ran is None:
self._tpl_setup_ran = True
self._initialize_template_engine()
if self._pages_data is None:
self.logger.debug('creating data object in _pages_data for %s..', name)
self._pages_data = DataObject()
if self._top_level_tabs is None:
self.logger.debug('Generating main navigation tabs list..')
self._generate_tabs_list()
self._initialize_page_data()
def _create_and_connect_signals(self):
"""
Creates the page's signals and connects them to their callbacks (handlers).
Signals should be appended to `self.signals` prior to calling this method.
A corresponding result signal will be created for each signal and added to the
allowed signals list automatically. Signal names will have 'do-' prepended to them.
Their corresponding result signal will have '-result' appended to it.
The name of the callback method that will be registered for each signal will be the
signal name as it appears in `self.signals` at the time of calling this method with
hyphens replaced by underscores and should end with '_cb'.
A callback is not automatically connected for signals that start with two hyphens.
Example:
>>> self.signals = ['some-action', 'some-other-action', '--private-action']
>>> self._create_and_connect_signals()
>>> self.signals
['do-some-action', 'some-action-result', 'do-other-action',
'other-action-result', 'private-action']
With the above, these callback methods will have been registered (they must exist):
'do-some-action': `self.some_action_cb`
'do-other-action': `self.other_action_cb`
"""
signals = []
for _signal in self.signals:
result_signal_name = '{}-result'.format(_signal)
signal_name = 'do-{}'.format(_signal) if not _signal.startswith('--') else _signal[2:]
signals_to_add = [
s for s in [signal_name, result_signal_name]
if s not in self._allowed_signals
]
for name in signals_to_add:
self._allowed_signals.append(name)
self._main_window.create_custom_signal(name)
signals.append(name)
if not _signal.startswith('--'):
callback_name = '{}_cb'.format(_signal.replace('-', '_'))
callback = getattr(self, callback_name)
self._main_window.connect(signal_name, callback)
self.signals = signals
def _generate_tabs_list(self):
tabs = self._pages_helper.get_page_names()
excluded = ['language', 'welcome']
self._top_level_tabs = [t for t in tabs if t not in excluded]
def _get_default_template_vars(self):
return {
'page_name': self.name,
'top_level_tabs': self._get_top_level_tabs(),
'page_index': self.index
}
def _get_initial_page_data(self):
return dict()
def _get_top_level_tabs(self):
return [(t, self.name == t) for t in self._top_level_tabs]
def _initialize_template_engine(self):
resources_path = 'cnchi://{}'.format(os.path.join(self.PAGES_DIR, 'resources'))
tpl_map = {
pdir: FileSystemLoader(os.path.join(self.PAGES_DIR, pdir)) for pdir in self._page_dirs
}
tpl_map['pages'] = FileSystemLoader(self.PAGES_DIR)
self._tpl = Environment(loader=PrefixLoader(tpl_map), lstrip_blocks=True, trim_blocks=True)
self._tpl.globals['RESOURCES_DIR'] = resources_path
self._tpl.add_extension('jinja2.ext.do')
self._tpl.add_extension('jinja2.ext.i18n')
self._tpl.install_null_translations(newstyle=True)
def _initialize_page_data(self):
if getattr(self._pages_data, self.name) is None:
from_dict = self._get_initial_page_data()
setattr(self._pages_data, self.name, DataObject(from_dict=from_dict))
def emit_js(self, name, *args):
""" See `Controller.emit_js.__doc__` """
self._controller.emit_js(name, *args)
def get_next_page_index(self):
return self._pages_helper.page_names.index(self.name) + 1
def get_previous_page_index(self):
return self._pages_helper.page_names.index(self.name) - 1
def go_to_next_page(self, obj=None, next_plus=0):
if self.name != self._controller.current_page:
return
self.store_values()
self._controller.set_current_page(self.get_next_page_index() + next_plus)
return True
def go_to_next_page_cb(self, obj=None, next_plus=0):
self.go_to_next_page(obj, next_plus)
def prepare(self):
""" This must be implemented by subclasses """
pass
def render_template(self, name=None, tpl_vars=None):
name = name if name is not None else self.template
default_tpl_vars = self._get_default_template_vars()
tpl = self._tpl.get_template(name)
if tpl_vars is not None:
tpl_vars = tpl_vars.update(default_tpl_vars)
else:
tpl_vars = default_tpl_vars
return tpl.render(tpl_vars)
def render_template_as_bytes(self, name=None, tpl_vars=None):
tpl = self.render_template(name=name, tpl_vars=tpl_vars)
return tpl.encode('UTF-8')
def store_values(self):
""" This must be implemented by subclasses """
self._pages_data.has_data = True
def generateJavaApplication(name, changesets):
# i is the number to be transform into byte array, n is the number of bytes to use (little endian)
def bytestring(i, n):
return ['(byte)' + str(ord(b)) for b in pack("H", i)][:n]
def nodeinjava(node):
return str(node.id)
def wuobjectinjava(wuobject):
return ', '.join([str(wuobject.node_id),
str(wuobject.port_number)])
def linkinjava(link):
return ', '.join(bytestring(link.from_component_index, 2)
+ bytestring(link.from_property_id, 1)
+ bytestring(link.to_component_index, 2)
+ bytestring(link.to_property_id, 1)
+ bytestring(link.to_wuclass_id, 2))
def wuclassname(wuclass):
return wuclass.name
def wuclassvirtualclassname(wuclass):
return "Virtual" + Convert.to_java(wuclass.name) + "WuObject"
def wuclassconstname(wuclass):
return "WUCLASS_" + Convert.to_constant(wuclass.name)
def wuclassgenclassname(wuclass):
return "GENERATEDVirtual" + Convert.to_java(wuclass.name) + "WuObject"
def propertyconstname(property):
print 'propertyconstname'
return "PROPERTY_" + Convert.to_constant(property.wuclass.name) + "_" + Convert.to_constant(property.name)
# doesn't really matter to check since basic types are being take care of in application.java
def propertyconstantvalue(property):
wutype = WuType.where(name=property.datatype)
if wutype:
return wutype[0].type.upper() + '_' + Convert.to_constant(property.datatype) + "_" + Convert.to_constant(property.value)
else:
return 'ENUM' + '_' + Convert.to_constant(property.datatype) + "_" + Convert.to_constant(property.value)
def generateProperties(wuclass_properties, component_properties):
properties = []
for property in wuclass_properties:
if property.value.strip() != "" and (not property.name in [x.name for x in properties]):
properties.append(property)
for property in properties:
if property.name in component_properties:
if component_properties[property.name].strip() != "":
property.value = component_properties[property.name]
return properties
# Generate the Java code
print 'generating', os.path.join(JAVA_OUTPUT_DIR, "WKDeploy.java")
jinja2_env = Environment(loader=FileSystemLoader([os.path.join(os.path.dirname(__file__), 'jinja_templates')]))
jinja2_env.filters['nodeinjava'] = nodeinjava
jinja2_env.filters['wuclassname'] = wuclassname
jinja2_env.filters['wuclassvirtualclassname'] = wuclassvirtualclassname
jinja2_env.filters['wuclassconstname'] = wuclassconstname
jinja2_env.filters['wuclassgenclassname'] = wuclassgenclassname
jinja2_env.filters['propertyconstname'] = propertyconstname
jinja2_env.filters['propertyconstantvalue'] = propertyconstantvalue
jinja2_env.filters['generateProperties'] = generateProperties
jinja2_env.add_extension('jinja2.ext.do')
output = open(os.path.join(JAVA_OUTPUT_DIR, "WKDeploy.java"), 'w')
output.write(jinja2_env.get_template('application2.java').render(name=name, changesets=changesets))
output.close()
class Kit(object):
"""Magic wrapper for jinja environment
"""
def __init__(self, search_path, loader=FileSystemLoader,
auto_reload=False, cache_size=50, extensions=(),
filters={}, globals={}):
"""Construct wrapper
"""
self.search_path = search_path
self.env = Environment(loader=loader(self.search_path),
auto_reload=auto_reload,
cache_size=cache_size,
extensions=extensions)
self.filters = filters
self.globals = globals
def filter(self, name=None):
def wrapper(func):
return self.add_filter(func, name)
return wrapper
def tglobal(self, name=None):
def wrapper(func):
return self.add_global(func, name)
return wrapper
def add_filter(self, func, name=None):
"""Add filter to environment
:param func:
:param name:
"""
self.env.filters.update({name or func.func_name: func})
return func
def add_global(self, func, name=None):
"""Add global function to context
:param func:
:param name:
"""
self.env.globals.update({name or func.func_name: func})
return func
def load_filters(self, paths=None):
"""Load filter to environment
"""
result = {}
paths = paths or self.filters
for m in paths:
f = __import__(m, fromlist=['filters'])
result.update(f.filters)
return result
def load_globals(self, paths=None, key='globals'):
"""Load global function to environment
"""
result = {}
paths = paths or self.globals
for m in paths:
f = __import__(m, fromlist=[key])
result.update(f.globals)
for name, func in f.globals.iteritems():
self.add_global(func, name)
return result
def load_extensions(self, extensions):
"""Load extensions
"""
for extension in extensions:
if isinstance(extension, basestring):
extension = import_string(extension)
self.add_extension(extension)
def add_extension(self, ext):
"""Load extension to environment
:param ext: extension object
"""
self.env.add_extension(ext)
def get_template(self, template_name, global_functions={}):
"""Get template
"""
return self.env.get_template(template_name, globals=global_functions)
def select_template(self, templates):
"""Search templates
"""
if isinstance(templates, (list, tuple)):
for template in templates:
try:
return self.get_template(template,
global_functions=globals())
except TemplateNotFound:
continue
elif isinstance(templates, (str, unicode, Template)):
return self.get_template(templates, globals())
raise TemplateNotFound
def render_to_string(self, template_name, context=None,
processors=None, processor_arg=None):
"""Render template into string
:param template_name:
:param context:
:param processors:
:param proccessor_arg:
"""
created_context = self.get_context(context=context, processors=processors,
processor_arg=processor_arg)
return self.select_template(template_name).render(created_context)
def get_standard_processors(self):
return ()
def get_context(self, context=None, processors=None, processor_arg=None):
context = dict(context or {})
context['processor_arg'] = processor_arg
standard_processors = self.get_standard_processors()
for processor in chain(standard_processors, processors or ()):
try:
context.update(processor(processor_arg))
except Exception, e:
print(e)
return context
def generateJavaApplication(name, changesets):
# i is the number to be transform into byte array, n is the number of bytes to use (little endian)
def bytestring(i, n):
return ['(byte)' + str(ord(b)) for b in pack("H", i)][:n]
def nodeinjava(node):
return str(node.id)
def wuobjectinjava(wuobject):
return ', '.join(
[str(wuobject.wunode().id),
str(wuobject.port_number)])
def linkinjava(link):
return ', '.join(
bytestring(link.from_component_index, 2) +
bytestring(link.from_property_id, 1) +
bytestring(link.to_component_index, 2) +
bytestring(link.to_property_id, 1) +
bytestring(link.to_wuclass_id, 2))
def wuclassname(wuclass):
return wuclass.name
def wuclassvirtualclassname(wuclass):
return "Virtual" + Convert.to_java(wuclass.name) + "WuObject"
def wuclassid(wuclass):
return str(wuclass.id)
def wuclassgenclassname(wuclass):
return "GENERATEDVirtual" + Convert.to_java(
wuclass.name) + "WuObject"
def propertyconstname(property):
print 'propertyconstname'
return "PROPERTY_" + Convert.to_constant(
property.wuobject.wuclassdef.name) + "_" + Convert.to_constant(
property.name)
# doesn't really matter to check since basic types are being take care of in application.java
def propertyconstantvalue(property):
wutype = WuTypeDef.where(name=property.wutype)
if wutype:
return wutype[0].type.upper() + '_' + Convert.to_constant(
property.wutype) + "_" + Convert.to_constant(
property.value)
else:
return 'ENUM' + '_' + Convert.to_constant(
property.wutype) + "_" + Convert.to_constant(
property.value)
def generateProperties(wuobject_properties, component_properties):
properties = wuobject_properties
for property in properties:
if property.name in component_properties:
property.value = component_properties[property.name]
return properties
# Generate the Java code
print '[generator] generating', os.path.join(JAVA_OUTPUT_DIR,
"WKDeploy.java")
jinja2_env = Environment(loader=FileSystemLoader(
[os.path.join(os.path.dirname(__file__), 'jinja_templates')]))
jinja2_env.filters['nodeinjava'] = nodeinjava
jinja2_env.filters['wuclassname'] = wuclassname
jinja2_env.filters['wuclassvirtualclassname'] = wuclassvirtualclassname
jinja2_env.filters['wuclassid'] = wuclassid
jinja2_env.filters['wuclassgenclassname'] = wuclassgenclassname
jinja2_env.filters['propertyconstname'] = propertyconstname
jinja2_env.filters['propertyconstantvalue'] = propertyconstantvalue
jinja2_env.filters['generateProperties'] = generateProperties
jinja2_env.add_extension('jinja2.ext.do')
output = open(os.path.join(JAVA_OUTPUT_DIR, "WKDeploy.java"), 'w')
output.write(
jinja2_env.get_template('application2.java').render(
name=name, changesets=changesets))
output.close()
def test_extend_late(self):
env = Environment()
env.add_extension("jinja2.ext.autoescape")
t = env.from_string(
'{% autoescape true %}{{ "<test>" }}{% endautoescape %}')
assert t.render() == "<test>"
class Renderer(object):
"""Renders a template."""
def __init__(self, path=None, loader=None, filters=None):
"""Constructs a new Renderer object.
Either path or loader has to be specified.
Keyword arguments:
path -- list or str which represents template locations
loader -- a jinja2 template loader instance (default: None)
filters -- dict containing filters (default: {})
"""
if (path is None and loader is None
or path is not None and loader is not None):
raise ValueError('Either specify path oder loader')
if path is not None:
loader = FileSystemLoader(path)
self._env = Environment(loader=loader)
self._env.add_extension('jinja2.ext.do')
self._add_filters(filters)
def _add_filters(self, filters):
"""Adds new filters to the jinja2 environment.
filters is a dict of filters.
"""
self._env.filters['dateformat'] = dateformat
self._env.filters.update(filters or {})
def _custom_template_names(self, template):
"""Returns a list of custom template names.
template is the name of the original template.
"""
splitted = template.rsplit('/', 1)
name = 'custom_' + splitted[-1]
ret = [name]
if len(splitted) == 2:
ret.append(splitted[0] + '/' + name)
return ret
def render_only(self, template, *args, **kwargs):
"""Renders template template.
The rendered template is returned (no data will be written
or printed).
*args and **kwargs are passed to jinja2 Template's render
method.
"""
names = self._custom_template_names(template)
names.append(template)
tmpl = self._env.select_template(names)
return tmpl.render(*args, **kwargs)
def _render(self, template, out, *args, **kwargs):
"""Renders template template.
out is a file or file-like object to which the rendered
template should be written to.
*args and **kwargs are passed to the render_only method.
"""
text = self.render_only(template, *args, **kwargs)
try:
out.write(text)
except UnicodeEncodeError:
text = text.encode('utf-8')
out.write(text)
def render(self, template, *args, **kwargs):
"""Renders template template.
Writes the rendered template to sys.stdout.
*args and **kwargs are passed to jinja2 Template's render
method.
"""
self._render(template, sys.stdout, *args, **kwargs)
def render_text(self, text, *args, **kwargs):
"""Renders text.
*args and **kwargs are passed to jinja2 Template's render
method.
"""
global TEXT_TEMPLATE
self.render(TEXT_TEMPLATE, text=text, *args, **kwargs)
def render_error(self, template, *args, **kwargs):
"""Renders template template.
Writes the rendered template to sys.stderr.
*args and **kwargs are passed to jinja2 Template's render
method.
"""
self._render(template, sys.stderr, *args, **kwargs)
