def render_html(config, template_dir_override=None):
env = Environment(loader=PackageLoader('adr_viewer', 'templates')
if template_dir_override is None else
FileSystemLoader(template_dir_override),
autoescape=select_autoescape(['html', 'xml']))
template = env.get_template('index.html')
return template.render(config=config)
def render_template(self, data, template_name, filters=None):
"""Render data using a jinja2 template"""
env = Environment(loader=FileSystemLoader(''))
if filters is not None:
for key, value in filters.iteritems():
env.filters[key] = value
template = env.get_template(template_name)
return template.render(feed=data).encode('utf-8')
def main():
app = web.Application()
aiohttp_jinja2.setup(app, loader=FileSystemLoader(''))
app.router.add_static('/static', 'static')
app.router.add_get('/', index)
app.router.add_get('/start', start)
app.router.add_get('/restart', restart)
app.router.add_get('/stop', stop)
app.router.add_get('/switch', switch)
web.run_app(app)
def make_html_file(stack):
root = stack[-1]
stack.reverse()
j2_env = Environment(loader=FileSystemLoader('templates'),
trim_blocks=True)
with open("%s.html" % root.id, "wb") as fh:
fh.write(j2_env.get_template('default.html'). \
render(title="Category %s" % root.id,
stack=stack,
name=root.name,).encode('utf-8'))
def jinja_loader(self):
if self.template_folder is not None:
loaders = [
FileSystemLoader(
path.join(self.root_path, self.template_folder))
]
else:
loaders = []
return ChoiceLoader(loaders)
def __init__(self, loader, shared_loader_obj=None, variables=None):
variables = {} if variables is None else variables
self._loader = loader
self._filters = None
self._tests = None
self._available_variables = variables
self._cached_result = {}
if loader:
self._basedir = loader.get_basedir()
else:
self._basedir = './'
if shared_loader_obj:
self._filter_loader = getattr(shared_loader_obj, 'filter_loader')
self._test_loader = getattr(shared_loader_obj, 'test_loader')
self._lookup_loader = getattr(shared_loader_obj, 'lookup_loader')
else:
self._filter_loader = filter_loader
self._test_loader = test_loader
self._lookup_loader = lookup_loader
# flags to determine whether certain failures during templating
# should result in fatal errors being raised
self._fail_on_lookup_errors = True
self._fail_on_filter_errors = True
self._fail_on_undefined_errors = C.DEFAULT_UNDEFINED_VAR_BEHAVIOR
environment_class = AnsibleNativeEnvironment if USE_JINJA2_NATIVE else AnsibleEnvironment
self.environment = environment_class(
trim_blocks=True,
undefined=AnsibleUndefined,
extensions=self._get_extensions(),
finalize=self._finalize,
loader=FileSystemLoader(self._basedir),
)
# jinja2 global is inconsistent across versions, this normalizes them
self.environment.globals['dict'] = dict
# Custom globals
self.environment.globals['lookup'] = self._lookup
self.environment.globals['query'] = self.environment.globals['q'] = self._query_lookup
self.environment.globals['now'] = self._now_datetime
self.environment.globals['finalize'] = self._finalize
# the current rendering context under which the templar class is working
self.cur_context = None
# FIXME these regular expressions should be re-compiled each time variable_start_string and variable_end_string are changed
self.SINGLE_VAR = re.compile(r"^%s\s*(\w*)\s*%s$" % (self.environment.variable_start_string, self.environment.variable_end_string))
self._no_type_regex = re.compile(r'.*?\|\s*(?:%s)(?:\([^\|]*\))?\s*\)?\s*(?:%s)' %
('|'.join(C.STRING_TYPE_FILTERS), self.environment.variable_end_string))
def __init__(self,
documentation,
version,
google_maps_links=False,
experimental=False):
super(Documentation, self).__init__()
loader = FileSystemLoader(
os.path.join(os.path.dirname(os.path.abspath(__file__)),
'templates'))
self.google_maps_links = google_maps_links
self.env = Environment(loader=loader, extensions=(with_, ))
self.experimental = experimental
self.parented = {}
self.documentation = documentation
self.version = version
self.classes = {}
self.classes_members = {}
self.references = set()
self.typedefs = {}
self.enums = {}
self.functions = {}
self.tree = ReferenceTree()
for doc_element in self.documentation:
if doc_element['kind'] == 'class':
class_name = doc_element['longname']
self.classes[class_name] = doc_element
self.classes_members[class_name] = []
self.references.add(class_name)
self.tree.push(class_name)
elif doc_element['kind'] == 'typedef':
type_name = doc_element['longname']
self.references.add(doc_element['longname'])
self.typedefs[type_name] = doc_element
elif doc_element['kind'] == 'member' and doc_element.get(
'isEnum', False):
enum_name = doc_element['longname']
self.references.add(doc_element['longname'])
self.enums[enum_name] = doc_element
elif doc_element['kind'] == 'function' and doc_element[
'scope'] == 'static':
if doc_element['longname'] != 'module.exports':
self.functions[doc_element['longname']] = doc_element
self.tree.push(doc_element['longname'])
for doc_element in documentation:
if 'memberof' in doc_element:
memberof = doc_element['memberof']
if memberof in self.classes_members.keys():
self.classes_members[memberof].append(doc_element)
if memberof in self.parented:
self.parented[memberof].append(doc_element)
else:
self.parented[memberof] = [doc_element]
def run(self, results):
"""Writes report.
@param results: Cuckoo results dict.
@raise CuckooReportError: if fails to write report.
"""
if not HAVE_JINJA2:
raise CuckooReportError(
"Failed to generate HTML report: Jinja2 Python library is not installed"
)
shots_path = os.path.join(self.analysis_path, "shots")
if os.path.exists(shots_path):
shots = []
counter = 1
for shot_name in os.listdir(shots_path):
if not shot_name.endswith(".jpg"):
continue
shot_path = os.path.join(shots_path, shot_name)
if os.path.getsize(shot_path) == 0:
continue
shot = {}
shot["id"] = os.path.splitext(File(shot_path).get_name())[0]
shot["data"] = base64.b64encode(open(shot_path, "rb").read())
shots.append(shot)
counter += 1
shots.sort(key=lambda shot: shot["id"])
results["screenshots"] = shots
else:
results["screenshots"] = []
results["apt"] = random.choice(HAX0RS)
env = Environment(autoescape=True)
env.loader = FileSystemLoader(os.path.join(CUCKOO_ROOT, "data",
"html"))
try:
tpl = env.get_template("report.html")
html = tpl.render({"results": results})
except Exception as e:
raise CuckooReportError("Failed to generate HTML report: %s" % e)
try:
report = open(os.path.join(self.reports_path, "report.html"), "w")
report.write(html)
report.close()
except (TypeError, IOError) as e:
raise CuckooReportError("Failed to write HTML report: %s" % e)
return True
def index():
def inner():
for x in range(10):
time.sleep(0.5)
t = sys.stdout.write(str(x))
t = sys.stdout.flush()
yield t
env = Environment(loader=FileSystemLoader('templates'))
tmpl = env.get_template('result.html')
return flask.Response(tmpl.generate(result=inner()))
def __init__(self, debug=False, audience='vendor'):
self.polkit_path = "/usr/share/polkit-1/"
self.polkit_path_actions = self.polkit_path + "actions"
self.polkit_path_rules = self.polkit_path + "rules.d"
self.polkit_path_pkla = '/var/lib/polkit-1/localauthority/'
self.tpl_env = Environment(
loader=FileSystemLoader('/usr/share/pkexec-debhelper/skel'),
lstrip_blocks=True,
trim_blocks=True)
self.debug = debug
self.audience = audience
def test_env_args(set_default_standard):
loader = FileSystemLoader("~")
tpl = Liquid(
"{$ a $}",
variable_start_string="{$",
variable_end_string="$}",
x=1,
loader=loader,
)
assert tpl.render(a=1) == "1"
assert tpl.env.x == 1
def __init__(self):
self.core=n4d.server.core.Core.get_core()
# Vars
self.LDAP_SECRET1 = '/etc/lliurex-cap-secrets/ldap-master/ldap'
self.LDAP_SECRET2 = '/etc/lliurex-secrets/passgen/ldap.secret'
self.log_path = '/var/log/n4d/samba'
self.tpl_env = Environment(loader=FileSystemLoader('/usr/share/n4d/templates/samba'))
self.available_acl_path = '/usr/share/n4d-ldap/available_acl/samba/'
self.enable_acl_path = '/var/lib/n4d-ldap/enable_acl/'
def generateHTML(self,output_path="",web_path=""):
from jinja2 import Environment, FileSystemLoader
env = Environment(loader=FileSystemLoader(os.path.dirname(__file__)))
template = env.get_template('talkingscore.html')
return template.render({'settings' : self.settings,
'basic_information': self.get_basic_information(),
'preamble': self.get_preamble(),
'full_score': os.path.join(web_path, os.path.basename(self.score.generate_midi_for_part_range(output_path=output_path))),
'music_segments': self.get_music_segments(output_path,web_path)
})
def main(fname):
env = Environment(loader=FileSystemLoader('./templates', encoding='utf-8'))
with open(fname, 'r') as ifp:
data = load(ifp, Loader=Loader)
global_vars = data['global_vars']
for row in data['services']:
tmpl = env.get_template(row['template']['src'])
with open(f'./available/{row["template"]["dest"]}', 'w') as ofp:
print(f'Generate: {row["template"]["dest"]}')
ofp.write(tmpl.render({**row['vars'], **global_vars}) + '\n')
def compile_jinja2_latex(template_name, context):
ENV_ARGS['loader'] = FileSystemLoader(TEMPLATE_LATEX_DIR)
env = Environment(**ENV_ARGS)
env.filters.update({
'e': LatexMarkup.escape,
'str': str,
'get_item': get_item_env,
'remove_http': remove_http_env,
'substr': substr_env,
})
tpl = env.get_template(template_name)
return tpl.render(**context)
def __init__(self):
self._args_parser = ArgumentParser(
description="This script generates an nginx vhost file for the" +
" current fantastico project.")
root_folder = os.path.abspath(
instantiator.get_class_abslocation(BasicSettings) + "../")
tpl_loader = FileSystemLoader(searchpath=root_folder)
self._tpl_env = Environment(loader=tpl_loader)
self._build_args_parser()
def index():
def inner():
zones = glob.glob('data/*.zone')
for country in zones:
base = os.path.basename(country)
name = base.split('.')[0]
openme = open(country, 'r')
lines = openme.read().splitlines()
yield '{ "hc-key": "%s", "code": %s },' % (name, lines)
env = Environment(loader=FileSystemLoader('templates'))
tmpl = env.get_template('index.html')
return flask.Response(tmpl.generate(result=inner()))
def run(self, results):
"""Writes report.
@param results: Cuckoo results dict.
@raise CuckooReportError: if fails to write report.
"""
if not HAVE_JINJA2:
raise CuckooReportError("Failed to generate HTML report: " "Jinja2 Python library is not installed")
shots_path = os.path.join(self.analysis_path, "shots")
if os.path.exists(shots_path):
shots = []
counter = 1
for shot_name in os.listdir(shots_path):
if not shot_name.endswith(".jpg"):
continue
shot_path = os.path.join(shots_path, shot_name)
if os.path.getsize(shot_path) == 0:
continue
shot = {}
shot["id"] = os.path.splitext(File(shot_path).get_name())[0]
shot["data"] = base64.b64encode(open(shot_path, "rb").read()).decode("utf-8")
shots.append(shot)
counter += 1
shots.sort(key=lambda shot: shot["id"])
results["shots"] = shots
else:
results["shots"] = []
env = Environment(autoescape=True)
env.globals['malware_config'] = malware_config
env.loader = FileSystemLoader(os.path.join(CUCKOO_ROOT, "data", "html"))
try:
tpl = env.get_template("report.html")
html = tpl.render({"results": results, "summary_report": False})
except UndefinedError as e:
raise CuckooReportError("Failed to generate summary HTML report: {} ".format(e))
except TemplateNotFound as e:
raise CuckooReportError("Failed to generate summary HTML report: {} {} ".format(e, e.name))
except (TemplateSyntaxError, TemplateAssertionError) as e:
raise CuckooReportError("Failed to generate summary HTML report: {} on {}, line {} ".format(e, e.name, e.lineno))
try:
with codecs.open(os.path.join(self.reports_path, "report.html"), "w", encoding="utf-8") as report:
report.write(html)
except (TypeError, IOError) as e:
raise CuckooReportError("Failed to write HTML report: %s" % e)
return True
def index():
def inner():
for x in range(5):
time.sleep(1)
yield '%s<br/>\n' % x
yield 'hello \n'
yield 'hello \n'
yield from ex_script.atest()
env = Environment(loader=FileSystemLoader('templates'))
tmpl = env.get_template('result.html')
return flask.Response(tmpl.generate(result=inner()))
def __init__(self, loader, shared_loader_obj=None, variables=None):
variables = {} if variables is None else variables
self._loader = loader
self._filters = None
self._tests = None
self._available_variables = variables
self._cached_result = {}
if loader:
self._basedir = loader.get_basedir()
else:
self._basedir = './'
if shared_loader_obj:
self._filter_loader = getattr(shared_loader_obj, 'filter_loader')
self._test_loader = getattr(shared_loader_obj, 'test_loader')
self._lookup_loader = getattr(shared_loader_obj, 'lookup_loader')
else:
self._filter_loader = filter_loader
self._test_loader = test_loader
self._lookup_loader = lookup_loader
# flags to determine whether certain failures during templating
# should result in fatal errors being raised
self._fail_on_lookup_errors = True
self._fail_on_filter_errors = True
self._fail_on_undefined_errors = C.DEFAULT_UNDEFINED_VAR_BEHAVIOR
self.environment = AnsibleEnvironment(
trim_blocks=True,
undefined=StrictUndefined,
extensions=self._get_extensions(),
finalize=self._finalize,
loader=FileSystemLoader(self._basedir),
)
# the current rendering context under which the templar class is working
self.cur_context = None
self.SINGLE_VAR = re.compile(r"^%s\s*(\w*)\s*%s$" %
(self.environment.variable_start_string,
self.environment.variable_end_string))
self._clean_regex = re.compile(r'(?:%s|%s|%s|%s)' %
(self.environment.variable_start_string,
self.environment.block_start_string,
self.environment.block_end_string,
self.environment.variable_end_string))
self._no_type_regex = re.compile(
r'.*?\|\s*(?:%s)(?:\([^\|]*\))?\s*\)?\s*(?:%s)' % ('|'.join(
C.STRING_TYPE_FILTERS), self.environment.variable_end_string))
def make_template_functions(template_dirpath):
"""Creates a template rendering function which uses a fixed template path"""
jinja_env = Environment(current_app, loader=FileSystemLoader(template_dirpath), extensions=[PyJadeExtension])
def render_template(template, **kwargs):
template = jinja_env.get_template(template)
return template.render(**kwargs)
def render_macro(template, macro_name, **kwargs):
macro = getattr(jinja_env.get_template(template).module, macro_name)
return macro(**kwargs)
return render_template, render_macro
def jinja2_renderer(impact_report, component):
"""Versatile text renderer using Jinja2 Template.
Render using Jinja2 template.
:param impact_report: ImpactReport contains data about the report that is
going to be generated.
:type impact_report: safe.report.impact_report.ImpactReport
:param component: Contains the component metadata and context for
rendering the output.
:type component:
safe.report.report_metadata.QgisComposerComponentsMetadata
:return: whatever type of output the component should be
.. versionadded:: 4.0
"""
context = component.context
main_template_folder = impact_report.metadata.template_folder
loader = FileSystemLoader(
os.path.abspath(main_template_folder))
extensions = [
'jinja2.ext.i18n',
'jinja2.ext.with_',
'jinja2.ext.loopcontrols',
'jinja2.ext.do',
]
env = Environment(
loader=loader,
extensions=extensions)
template = env.get_template(component.template)
rendered = template.render(context)
if component.output_format == 'string':
return rendered
elif component.output_format == 'file':
if impact_report.output_folder is None:
impact_report.output_folder = mkdtemp(dir=temp_dir())
output_path = impact_report.component_absolute_output_path(
component.key)
# make sure directory is created
dirname = os.path.dirname(output_path)
if not os.path.exists(dirname):
os.makedirs(dirname)
with io.open(output_path, mode='w', encoding='utf-8') as output_file:
output_file.write(rendered)
return output_path
def render():
global basic_info
global pkg_info
p = basic_info['work_dir'] + "\\..\\..\\" + "Report"
print p
env = Environment(loader=FileSystemLoader(p))
tmpl = env.get_template('M.html')
out = tmpl.render(seq=[3, 2, 4, 5, 3, 2, 0, 2, 1], pkg=pkg_info)
#f = open(p+"\\"+"out.html","w")
f = codecs.open(p + "\\" + "out.html", 'wb', 'utf-8')
f.write(out)
f.close
def get_roadmin_dic():
global c
env = Environment(loader=FileSystemLoader('/usr/share/n4d/templates/samba'))
template=env.get_template("ro-admin-user")
vars=c.get_variable_list("","VariablesManager",["LDAP_BASE_DN"])
vars["PASSWORD"]=generate_ssha_password().strip("\n")
str_template=template.render(vars).encode("utf-8")
exec("ro_dic="+str_template)
return ro_dic
def _gen_jinja_env(self):
"""
获取jinja环境参数
:return:
"""
jinja_env = Environment(loader=FileSystemLoader(
self.settings['template_path']),
auto_reload=True,
autoescape=False)
jinja_env.filters['lt_gt'] = lambda s: s.replace('<', '<').replace(
'>', '>')
jinja_env.globals['settings'] = self.settings
return jinja_env
def __init__(self,
directory='.',
config_file=None,
template=None,
template_file='Dockerfile.j2',
variables={},
tags=[]):
data = {}
self.config_file = config_file
self.directory = directory
try:
with open(os.path.join(directory, config_file), 'r') as stream:
try:
data = yaml.load(stream)
except yaml.YAMLError as e:
print(e)
except (AttributeError, TypeError):
# no config file name provided
pass
except IOError:
# no config file present
pass
jinja = Environment(loader=FileSystemLoader(directory),
undefined=StrictUndefined)
config = Utils.merge_dict(
{
'variables': variables,
'template_file': template_file,
'tags': []
}, data)
config['tags'] = [
Utils.merge_dict(tag, {'only_primary': False})
for tag in config['tags']
]
self.template_file = config['template_file']
self.tags = {}
for tag in tags + config['tags']:
self.tags[tag['template']] = TagCandidate(**tag)
self.variables = config['variables']
try:
self.template = jinja.get_template(config['template_file'])
except TemplateNotFound:
self.template = template
def __init__(self, loader, shared_loader_obj=None, variables=dict()):
self._loader = loader
self._filters = None
self._tests = None
self._available_variables = variables
self._cached_result = {}
if loader:
self._basedir = loader.get_basedir()
else:
self._basedir = './'
if shared_loader_obj:
self._filter_loader = getattr(shared_loader_obj, 'filter_loader')
self._test_loader = getattr(shared_loader_obj, 'test_loader')
self._lookup_loader = getattr(shared_loader_obj, 'lookup_loader')
else:
self._filter_loader = filter_loader
self._test_loader = test_loader
self._lookup_loader = lookup_loader
# flags to determine whether certain failures during templating
# should result in fatal errors being raised
self._fail_on_lookup_errors = True
self._fail_on_filter_errors = True
self._fail_on_undefined_errors = C.DEFAULT_UNDEFINED_VAR_BEHAVIOR
self.environment = Environment(
trim_blocks=True,
undefined=StrictUndefined,
extensions=self._get_extensions(),
finalize=self._finalize,
loader=FileSystemLoader(self._basedir),
)
self.environment.template_class = AnsibleJ2Template
self.SINGLE_VAR = re.compile(r"^%s\s*(\w*)\s*%s$" %
(self.environment.variable_start_string,
self.environment.variable_end_string))
self.block_start = self.environment.block_start_string
self.block_end = self.environment.block_end_string
self.variable_start = self.environment.variable_start_string
self.variable_end = self.environment.variable_end_string
self._clean_regex = re.compile(
r'(?:%s[%s%s]|[%s%s]%s)' %
(self.variable_start[0], self.variable_start[1],
self.block_start[1], self.block_end[0], self.variable_end[0],
self.variable_end[1]))
def themes(self):
themes = {}
if self.path.exists():
for child in self.path.iterdir():
if not child.is_dir():
continue
if self._filter and not self._filter(child):
continue
yield Theme(jinja_loader=FileSystemLoader(str(child)),
theme_loader=self,
name=child.name)
return themes
def get_jinja_config(self):
hierarchy = OrderedDict((
("eurogamer_net",
FileSystemLoader(self.get_template_dir("eurogamer_net"))),
("eurogamer",
FileSystemLoader(self.get_template_dir("eurogamer"))),
("core", FileSystemLoader(self.get_template_dir("core"))),
))
loader = HierarchyLoader(hierarchy)
params = {
"APP_DIRS": True,
"OPTIONS": {
'match_extension':
None,
'context_processors': [
'gn_django.template.context_processors.settings',
],
'loader':
loader,
},
"NAME": "djangojinja",
"DIRS": [],
}
return params
def jinja_env(self) -> SandboxedEnvironment:
"""Return a pre-configured Jinja environment.
Respects template settings.
"""
paths = [str(self.template.local_abspath)]
loader = FileSystemLoader(paths)
# We want to minimize the risk of hidden malware in the templates
# so we use the SandboxedEnvironment instead of the regular one.
# Of course we still have the post-copy tasks to worry about, but at least
# they are more visible to the final user.
env = SandboxedEnvironment(loader=loader, **self.template.envops)
default_filters = {"to_nice_yaml": to_nice_yaml}
env.filters.update(default_filters)
return env