def _print_results(accept_results_after, submission):
config = _load_config(submission)
results = prepare_results_from_location(submission, only_published=False)
results_matlab = prepare_results_from_location(submission, only_published=False, results_directory='results-old-matlab')
data = {
'results': results,
'results_matlab': results_matlab,
'submission': submission,
'config': config,
}
md = markdown.Markdown()
env = Environment()
env.filters['markdown'] = lambda text: Markup(md.convert(text))
def format_encoded_datetime(datetime_str, format_str):
try:
datetime_obj = datetime.strptime(datetime_str, '%Y-%m-%dT%H:%M:%S.%f')
except ValueError:
datetime_obj = datetime.strptime(datetime_str, '%Y-%m-%dT%H:%M:%S')
return datetime_obj.strftime(format_str)
env.filters['datetime'] = format_encoded_datetime
env.trim_blocks = True
env.lstrip_blocks = True
template = env.from_string(open('templates/results_mail.jinja2').read())
results_mail = template.render(**data)
print(results_mail)
def __init__(self, project_path, definition, file_name):
template_path = os.path.normpath(
os.path.join(os.path.dirname(__file__), '..', 'templates'))
file_loader = FileSystemLoader(template_path)
env = Environment(loader=file_loader)
env.trim_blocks = True
env.lstrip_blocks = True
env.rstrip_blocks = True
template_name = str(
self.__class__.__name__).split('.')[-1].split(' ')[0]
template_name = template_name.replace('generator',
'template') + '.jinja2'
template = env.get_template(template_name)
self.definition = definition
self.project_path = project_path
rel_path_to_dir = self._generate_relative_path()
abs_path_to_dir = os.path.join(self.project_path, rel_path_to_dir)
self.abs_path_to_file = os.path.join(abs_path_to_dir, file_name)
if not os.path.exists(abs_path_to_dir):
os.makedirs(abs_path_to_dir)
render_data = self._generate_render_data(abs_path_to_dir)
msg = self._render(template, render_data)
self._generate(self.abs_path_to_file, msg)
def init_env():
global env, tpls
env = Environment(loader=FileSystemLoader('theme/%s/layout/' %
config['theme']))
env.trim_blocks = True
env.lstrip_blocks = True
env.globals.update(
**{
'config': config,
't_config': t_config,
'data': {
'posts': posts,
'pages': pages,
'tags': tags,
'categories': categories,
'index': index,
'tags_index': tags_index,
'categories_index': categories_index
},
'last_build_time': last_build_time
})
env.filters['markdown'] = mistune.Markdown()
env.filters['markdown_math'] = md_math.parse
env.filters['encrypt'] = encrypt
for i in t_setting['layout']:
tpls[i] = env.get_template(t_setting['layout'][i])
def generate_temporary_playbook(roles=None,
become=True,
gather_facts=False,
reboot=False):
JINJA_FILE = 'administration/temporary.yml.j2'
jinja_args = {
"become":
query_yes_no(userlog.warn("Become?")),
"gather_facts":
query_yes_no(userlog.warn("Gather Facts?"), default="no"),
"reboot":
query_yes_no(userlog.error("Reboot after the execution?"),
default="no")
}
if not roles:
roles = select_roles()
env = Environment(
loader=FileSystemLoader(os.path.dirname(os.path.realpath(__file__))))
env.trim_blocks = True
env.lstrip_blocks = True
temporary_playbook = env.get_template(JINJA_FILE).render(
roles=roles,
become=jinja_args["become"],
gather_facts=jinja_args["gather_facts"],
reboot=jinja_args["reboot"])
with open('administration/temporary.yml', 'w') as f:
f.write(temporary_playbook)
def get_j2_environment(module='neslter.metadata.eml',
dir='templates',
autoescape='xml'):
j2_env = Environment(loader=PackageLoader(module, dir),
autoescape=select_autoescape([autoescape]))
j2_env.trim_blocks = True
return j2_env
def __init__(self, project_path, file_name):
template_path = os.path.normpath(os.path.join(os.path.dirname(__file__), '..', 'templates'))
file_loader = FileSystemLoader(template_path)
env = Environment(loader=file_loader)
env.trim_blocks = True
env.lstrip_blocks = True
env.rstrip_blocks = True
template_name = str(self.__class__.__name__).split('.')[-1].split(' ')[0]
template_name = template_name.replace('generator', 'template') + '.jinja2'
if not os.path.exists(os.path.join(template_path, template_name)):
raise Exception(f"couldn't find the template : {template_name}")
template = env.get_template(template_name)
project_name = os.path.basename(project_path)
rel_path_to_dir = self._generate_relative_path()
abs_path_to_dir = os.path.join(project_path, rel_path_to_dir)
abs_path_to_file = os.path.join(abs_path_to_dir, file_name)
msg = template.render(project_name=project_name)
if not os.path.exists(abs_path_to_dir):
os.makedirs(abs_path_to_dir)
with open(abs_path_to_file, 'w', encoding='utf-8') as f:
f.write(msg)
def __init__(self, prog_name, owner, datasource):
self.datasource = datasource
self.last_index = 0
template_path = os.path.normpath(os.path.join(os.path.dirname(__file__), '..', 'templates'))
file_loader = FileSystemLoader(template_path)
env = Environment(loader=file_loader)
env.trim_blocks = True
env.lstrip_blocks = True
env.rstrip_blocks = True
env.globals.update(idgen=self.indexgen)
template_name = str(self.__class__.__name__).split('.')[-1].split(' ')[0]
template_name = 'testprogram_template.jinja2'
if not os.path.exists(os.path.join(template_path, template_name)):
raise Exception(f"couldn't find the template : {template_name}")
template = env.get_template(template_name)
file_name = f"{prog_name}.py"
rel_path_to_dir = self._generate_relative_path()
abs_path_to_dir = os.path.join(datasource.project_directory, rel_path_to_dir)
abs_path_to_file = os.path.join(abs_path_to_dir, file_name)
if not os.path.exists(abs_path_to_dir):
os.makedirs(abs_path_to_dir)
if os.path.exists(abs_path_to_file):
os.remove(abs_path_to_file)
test_list = self.build_test_entry_list(datasource, owner, prog_name)
output = template.render(test_list=test_list)
with open(abs_path_to_file, 'w', encoding='utf-8') as fd:
fd.write(output)
def show_cli_output(template_file, response, continuation=False, **kwargs):
# Create the jinja2 environment.
# Notice the use of trim_blocks, which greatly helps control whitespace.
template_path = os.getenv("RENDERER_TEMPLATE_PATH")
#template_path = os.path.abspath(os.path.join(THIS_DIR, "../render-templates"))
j2_env = Environment(
loader=FileSystemLoader(template_path),
extensions=['jinja2.ext.do', 'jinja2.ext.loopcontrols'])
j2_env.trim_blocks = True
j2_env.lstrip_blocks = True
j2_env.rstrip_blocks = True
def datetimeformat(time):
return datetime.datetime.fromtimestamp(
int(time)).strftime('%Y-%m-%d %H:%M:%S')
j2_env.globals.update(datetimeformat=datetimeformat)
full_cmd = os.getenv('USER_COMMAND', None)
if full_cmd is not None:
pipestr().write(full_cmd.split())
if response is not None:
t_str = (j2_env.get_template(template_file).render(
json_output=response, **kwargs))
return write(t_str, continuation=continuation)
def write_template(run, template_file, logo_file):
template_file = path.abspath(path.realpath(template_file))
template_dir = path.dirname(template_file)
# spawn environment and create output directory
env = Environment(loader=FileSystemLoader(template_dir))
# change delimiters since LaTeX may use "{{", "{%", or "{#"
env.block_start_string = "((*"
env.block_end_string = "*))"
env.variable_start_string = "((("
env.variable_end_string = ")))"
env.comment_start_string = "((="
env.comment_end_string = "=))"
# trim all block-related whitespaces
env.trim_blocks = True
env.lstrip_blocks = True
# put in out filter functions
env.filters["nice_int"] = nice_int
env.filters["nice_flt"] = nice_flt
env.filters["float2nice_pct"] = float2nice_pct
env.filters["basename"] = path.basename
# write tex template for pdflatex
jinja_template = env.get_template(path.basename(template_file))
run.logo = logo_file
render_vars = {
"run": run,
}
rendered = jinja_template.render(**render_vars)
print(rendered, file=sys.stdout)
def create_environment(lang, namespace):
env = Environment(loader=PackageLoader(lang.value, '.'),
extensions=['jinja2.ext.do', 'jinja2.ext.loopcontrols'])
env.trim_blocks = True
env.lstrip_blocks = True
env.keep_trailing_newline = False
env.filters["capital"] = capital
env.globals["to_upper_snake_case"] = to_upper_snake_case
env.globals["fixed_params"] = fixed_params
env.globals["var_size_params"] = var_size_params
env.globals['new_params'] = new_params
env.globals['filter_new_params'] = filter_new_params
env.globals["is_var_sized_list"] = is_var_sized_list
env.globals[
"is_var_sized_list_contains_nullable"] = is_var_sized_list_contains_nullable
env.globals["is_var_sized_entry_list"] = is_var_sized_entry_list
env.globals["is_var_sized_map"] = is_var_sized_map
env.globals["item_type"] = item_type
env.globals["key_type"] = key_type
env.globals["value_type"] = value_type
env.globals["lang_types_encode"] = language_specific_funcs[
'lang_types_encode'][lang]
env.globals["lang_types_decode"] = language_specific_funcs[
'lang_types_decode'][lang]
env.globals["lang_name"] = language_specific_funcs['lang_name'][lang]
env.globals["namespace"] = namespace
env.globals["param_name"] = language_specific_funcs['param_name'][lang]
env.globals["escape_keyword"] = language_specific_funcs['escape_keyword'][
lang]
env.globals["get_size"] = get_size
env.globals["is_trivial"] = is_trivial
env.globals['get_import_path_holders'] = language_specific_funcs[
'get_import_path_holders'][lang]
return env
def get_enable_conf(self, vm_config, vm_val):
env = Environment(loader=BaseLoader).from_string(vm_config)
env.trim_blocks = True
env.lstrip_blocks = True
env.rstrip_blocks = True
ret_config = env.render(val=vm_val)
return ret_config
def save_to_satellite(icinga_host):
def my_finalize(thing):
return thing if thing is not None else ''
def create_list(var,temp_list):
temp_list.append(str(var).encode("utf-8"))
return json.dumps(temp_list)
jinja_env = Environment(loader = FileSystemLoader([IcingaConfigure.TEMPLATE_PATH]),trim_blocks=True,lstrip_blocks=True,finalize=my_finalize)
jinja_env.trim_blocks=True
jinja_env.lstrip_blocks=True
jinja_env.filters['getList'] = create_list
icinga_template = jinja_env.get_template(IcingaConfigure.ICINGA_HOST_TEMPLATE)
rendered_template = icinga_template.render(icinga_host=icinga_host)
path = os.path.join(IcingaConfigure.SAVE_PATH, icinga_host['satellite_name'])
try:
if not os.path.exists(path):
os.makedirs(path)
file_name = os.path.join(path,icinga_host['host_name']+".conf")
conf_file = open(file_name,'w')
conf_file.write(rendered_template)
conf_file.close()
return os.path.exists(file_name),file_name
except OSError as exception:
if exception.errno != errno.EEXIST:
logger.error("No configuration file can be generated at:"+str(path))
raise Exception(exception.message())
def get_template_parser():
file_loader = FileSystemLoader(template_dict.get('template_dir'))
env = Environment(loader=file_loader)
env.trim_blocks = True
env.lstrip_blocks = True
env.rstrip_blocks = True
return env
def get_template(template_path):
file_loader = FileSystemLoader('static/template')
env = Environment(loader=file_loader)
env.trim_blocks = True
env.lstrip_blocks = True
env.rstrip_blocks = True
return env.get_template(template_path)
def write(self, py_path):
from jinja2 import Environment, FileSystemLoader
if not os.path.exists(py_path):
os.makedirs(py_path)
file_loader = FileSystemLoader(
os.path.join(os.path.dirname(__file__), "templates"))
env = Environment(loader=file_loader)
env.trim_blocks = True
env.lstrip_blocks = True
env.rstrip_blocks = True
with open(os.path.join(py_path, "ThostFtdcUserApiDataType.pxd"),
"w+",
encoding="utf-8") as f:
template = env.get_template("ThostFtdcUserApiDataType.pxd.jinja")
f.write(template.render(types=self._types.values()))
with open(os.path.join(py_path, "ThostFtdcUserApiStruct.pxd"),
"w+",
encoding="utf-8") as f:
template = env.get_template("ThostFtdcUserApiStruct.pxd.jinja")
f.write(template.render(structs=self._structs.values()))
with open(os.path.join(py_path, "structs.py"), "w+",
encoding="utf-8") as f:
template = env.get_template("structs.py.jinja")
f.write(
template.render(char_array_lengths=sorted(set(
t.array_len for t in self._types.values() if t.array_len),
key=int),
structs=self._structs.values()))
with open(os.path.join(py_path, "structs.pyi"), "w+",
encoding="utf-8") as f:
template = env.get_template("structs.pyi.jinja")
f.write(template.render(structs=self._structs.values()))
with open(os.path.join(py_path, "consts.py"), "w+",
encoding="utf-8") as f:
template = env.get_template("consts.py.jinja")
f.write(
template.render(enum_types=[
t for t in self._types.values() if t.enum_values
]))
with open(os.path.join(py_path, "ThostFtdcTraderApi.pxd"),
"w+",
encoding="utf-8") as f:
template = env.get_template("ThostFtdcTraderApi.pxd.jinja")
f.write(template.render(methods=self._api_methods))
with open(os.path.join(py_path, "TraderApi.pyx"),
"w+",
encoding="utf-8") as f:
template = env.get_template("TraderApi.pyx.jinja")
f.write(
template.render(api_methods=self._api_methods,
spi_methods=self._spi_methods))
def object_from_labfile(data, code_type, lang):
"""
로그 쓰기용 객체 출력.
Args:
data (dict): 랩 파일 데이터
lang (str): 언어 코드
output (str): 저장할 코드 파일 경로
"""
assert code_type in ('cs', 'py')
model = build_model(data, lang)
tmpl_dir = os.path.join(LOGLAB_HOME, "template")
loader = FileSystemLoader(tmpl_dir)
env = Environment(loader=loader)
env.trim_blocks = True
env.lstrip_blocks = True
env.filters['required'] = _object_required_filter
env.filters['optional'] = _object_optional_filter
tmpl = env.get_template(f"tmpl_obj.{code_type}.jinja")
_type = _type_cs if code_type == 'cs' else _type_py
domain = data['domain']
events = model['events']
warn = get_object_warn(lang)
kwargs = dict(domain=domain, events=events, warn=warn)
return tmpl.render(type=_type, **kwargs)
def get_template(self, *, text='', html=None, context=None):
context = context or {}
file_path, file_name = text.rsplit('/', 1)
env = Environment(loader=FileSystemLoader(file_path))
env.trim_blocks = True
text_template = env.get_template(file_name)
text = text_template.render(**context)
self.message.attach(MIMEText(text, "plain"))
if html:
file_path, file_name = html.rsplit('/', 1)
env = Environment(loader=FileSystemLoader(file_path))
env.trim_blocks = True
html_template = env.get_template(file_name)
html = html_template.render(**context)
self.message.attach(MIMEText(html, "html"))
def generate_temporary_playbook(roles=None, become=True, gather_facts=False, reboot=False, interactive=False):
jinja_file = 'administration/temporary.yml.j2'
if interactive:
jinja_args = {
"become": query_yes_no(userlog.warn("Become?")),
"gather_facts": query_yes_no(userlog.warn("Gather Facts?"), default="no"),
"reboot": query_yes_no(userlog.error("Reboot after the execution?"), default="no")
}
else:
jinja_args = {
'become': become,
'gather_facts': gather_facts,
'reboot': reboot
}
if not roles:
roles = select_roles()
env = Environment(loader=FileSystemLoader(os.path.dirname(os.path.realpath(__file__))))
env.trim_blocks = True
env.lstrip_blocks = True
temporary_playbook = env.get_template(jinja_file).render(roles=roles,
become=jinja_args["become"],
gather_facts=jinja_args["gather_facts"],
reboot=jinja_args["reboot"])
with open('administration/temporary.yml', 'w') as f:
f.write(temporary_playbook)
def jinja_unresolved(template, typ):
""" Check a jinja template for any unresolved vars
"""
_ = typ
env = Environment()
env.trim_blocks = True
unresolved = meta.find_undeclared_variables(env.parse(template))
return unresolved
def get_environment():
env = Environment(
loader=PackageLoader("myppa", os.path.join("data", "templates")))
env.trim_blocks = True
env.lstrip_blocks = True
env.filters["format_deb_depends"] = format_deb_depends
env.filters["htmlsafe"] = htmlsafe
return env
def render(template, *envs):
environment = Environment(loader=PackageLoader("jcppy", os.path.join("data", "templates")))
environment.trim_blocks = True
environment.lstrip_blocks = True
env = {}
for e in envs:
env.update(e)
return environment.get_template(template).render(env)
def create_jinja_environment(self):
'''create an initialize an environment to use for templating'''
file_loader = FileSystemLoader(self.TEMPLATE_PATH)
env = Environment(loader=file_loader, undefined=StrictUndefined)
env.globals.update(clean_number=float2int)
env.trim_blocks = True
env.lstrip_blocks = True
env.keep_trailing_newline = True
return env
def setup_jinja_env(jinja_env: jinja2.Environment) -> None:
jinja_env.lstrip_blocks = True
jinja_env.trim_blocks = True
jinja_env.globals["deployment_id"] = datetime.now().isoformat()
jinja_env.filters["markdown"] = render_markdown
jinja_env.filters["tojson"] = lambda obj: json.dumps(
obj, default=json_default
)
jinja_env.globals.update(percent=percent)
def loadJinjaEnv(self):
env = Environment(
#loader=PackageLoader('hsJinja',self.template_folder),
loader=FileSystemLoader(searchpath=self.template_folder),
extensions=["jinja2.ext.do",
blog_commentsExtension,
blog_social_sharingExtension,
blog_subscribeExtension,
booleanExtension,
choiceExtension,
colorExtension,
ctaExtension,
email_simple_subscriptionExtension,
email_subscriptionsExtension,
email_subscriptions_confirmationExtension,
formExtension,
galleryExtension,
global_partialExtension,
headerExtension,
iconExtension,
image_srcExtension,
imageExtension,
language_switcherExtension,
linked_imageExtension,
logoExtension,
menuExtension,
moduleExtension,
page_footerExtension,
password_promptExtension,
post_filterExtension,
post_listingExtension,
raw_htmlExtension,
related_blog_postsExtension,
require_cssExtension,
require_headExtension,
require_jsExtension,
rich_textExtension,
rss_listingExtension,
section_headerExtension,
simple_menuExtension,
social_sharingExtension,
spaceExtension,
textExtension,
textareaExtension,
video_playerExtension,
widget_containerExtension
],
autoescape=select_autoescape(["html","xml"]),
auto_reload=True,
cache_size=0 #disable cache so it rebuilds when watching for changes
)
env.trim_blocks = True
env.lstrip_blocks = True
env.strip_trailing_newlines = True
print(self.template_folder)
return env
def make_template(content):
file_loader = FileSystemLoader('templates')
env = Environment(loader=file_loader)
env.trim_blocks = True
env.lstrip_blocks = True
env.rstrip_blocks = True
template = env.get_template('about.html')
output = template.render(content=content)
#print(output)
return output
def render(context):
fn = os.path.join(os.path.dirname(__file__), 'templates')
loader = FileSystemLoader(searchpath=fn)
env = Environment(loader=loader)
env.trim_blocks = True
env.lstrip_blocks = True
t = env.get_template('sequence.htt')
return t.render(context)
def expand_template(self, template_name, template_vars = {}):
base_path = os.path.dirname(__file__)
tmpl_path = os.path.abspath(os.path.join(base_path, 'templates'))
env = Environment(loader=FileSystemLoader(tmpl_path))
env.trim_blocks = True
env.lstrip_blocks = True
tmpl = env.get_template(template_name)
return tmpl.render(template_vars)
def expand_template(self, template_name, template_vars={}):
base_path = os.path.dirname(__file__)
tmpl_path = os.path.abspath(os.path.join(base_path, 'templates'))
env = Environment(loader=FileSystemLoader(tmpl_path))
env.trim_blocks = True
env.lstrip_blocks = True
tmpl = env.get_template(template_name)
return tmpl.render(template_vars)
def install_templates(root_dir, args):
from jinja2 import Environment, FileSystemLoader, Template
t.tic()
for td_ in spec.templates_dirs:
git_url, git_branch, path_to_dir, _ = self.explode_pp_node(td_)
if 'subdir' in td_:
path_to_dir = os.path.join(path_to_dir, td_.subdir)
file_loader = FileSystemLoader(path_to_dir)
env = Environment(loader=file_loader)
env.trim_blocks = True
env.lstrip_blocks = True
env.rstrip_blocks = True
print(path_to_dir)
os.chdir(path_to_dir)
for dirpath, dirnames, filenames in os.walk('.'):
if '.git' in dirpath:
continue
for dir_ in dirnames:
out_dir = os.path.join(root_dir, dirpath, dir_)
print(out_dir)
mkdir_p(out_dir)
# if not os.path.exists(out_dir):
# os.mkdir(out_dir)
for filename in filenames:
fname_ = os.path.join(dirpath, filename)
if '_add_newdocs.py' in fname_:
wtf = 1
out_fname_ = os.path.join(root_dir, dirpath, filename)
out_fname_ = Template(out_fname_).render(self.tvars)
plain = False
try:
m = fucking_magic(fname_)
if 'text' in m:
plain = True
except Exception:
pass
if plain:
template = env.get_template(fname_)
output = template.render(self.tvars)
with open(out_fname_, 'w',
encoding='utf-8') as lf_:
lf_.write(output)
else:
shutil.copy2(fname_, out_fname_)
shutil.copymode(fname_, out_fname_)
print("Install templates takes")
t.toc()
pass
def populate_email_template(template_name, template_feeder):
file_loader = FileSystemLoader('templates')
env = Environment(loader=file_loader)
env.trim_blocks = True
env.lstrip_blocks = True
env.rstrip_blocks = True
template = env.get_template(template_name)
output = template.render(inquiry=template_feeder)
# print(output)
return output
def generate_stack_template(input_file, output_file, routers, nets, net_mgmt, vm_conf, srv):
file_loader = FileSystemLoader(f"{src_dir}/templates")
env = Environment(loader=file_loader)
env.trim_blocks = True
env.lstrip_blocks = True
env.rstrip_blocks = True
# env.filters['ipaddr'] = self.ipaddr
template = env.get_template(input_file)
output = template.render(routers=routers, nets=nets, srv=srv, net_mgmt=net_mgmt, vm=vm_conf, avail_zone=cmd_args.zone)
with open(output_file, mode="w") as file_:
file_.write(output)
def _jinjaenv():
env = Environment(
loader=PackageLoader("quetz", "templates"),
autoescape=select_autoescape(["html", "xml"]),
)
env.trim_blocks = True
env.lstrip_blocks = True
env.filters["iec_bytes"] = _iec_bytes
env.filters["strftime"] = _strftime
env.filters["opt_href"] = _opt_href
return env
def generate_jinja(self, tmp_name_file, out_file):
file_loader = FileSystemLoader('evenglibv2')
env = Environment(loader=file_loader)
env.trim_blocks = True
env.lstrip_blocks = True
env.rstrip_blocks = True
env.filters['ipaddr'] = self.ipaddr
template = env.get_template(tmp_name_file)
output = template.render(unl_param=self.__lab_param, eve_ng_ip_host=self.__eveng_conn_param['ip'])
with open(out_file, mode='w') as file_:
file_.write(output)
def hosts_to_text(self):
env = Environment(
loader=PackageLoader("vespa", "templates"),
autoescape=select_autoescape(
disabled_extensions=("txt",), default_for_string=True, default=True,
),
)
env.trim_blocks = True
env.lstrip_blocks = True
schema_template = env.get_template("hosts.xml")
return schema_template.render()
def get_tex_tpl(path):
texenv = Environment(loader=FileSystemLoader(os.getcwd()))
texenv.block_start_string = '((*'
texenv.block_end_string = '*))'
texenv.variable_start_string = '((('
texenv.variable_end_string = ')))'
texenv.comment_start_string = '((='
texenv.comment_end_string = '=))'
texenv.trim_blocks = True
texenv.lstrip_blocks = True
return texenv.get_template(path)
def _load(self, query):
try:
if self.context.get('queries'):
query_config = self.context['queries']
if query_config.get(query) and query_config[query].get('path'):
with open(query_config[query]['path']) as t:
return Template(t.read())
# otherwise, load from known paths
lookup_paths = 'queries'
loader = FileSystemLoader(lookup_paths, encoding='utf-8')
env = Environment(loader=loader)
env.trim_blocks = True
env.lstrip_blocks = True
return env.get_template(query)
except:
raise RuntimeError('Unable to load query template for {}.'
.format(query))
def __init__(self, queries_config, queries_paths):
queries = Environment(loader=FileSystemLoader(
queries_paths, encoding='utf-8'))
queries.trim_blocks = True
queries.lstrip_blocks = True
self.queries = queries
def render_pages(target=None, for_pdf=False):
"""Parse and render all pages in target, writing files to out_path."""
target = get_target(target)
pages = get_pages(target)
categories = get_categories(pages)
env = Environment(loader=FileSystemLoader(config["template_path"]))
env.lstrip_blocks = True
env.trim_blocks = True
if for_pdf:
logging.info("reading pdf template...")
default_template = env.get_template(config["pdf_template"])
else:
logging.info("reading default template...")
default_template = env.get_template(config["default_template"])
pp_env = Environment(loader=FileSystemLoader(config["content_path"]))
#Example: if we want to add custom functions to the md files
#pp_env.globals['foo'] = lambda x: "FOO %s"%x
for currentpage in pages:
if "md" in currentpage:
# Read and parse the markdown
try:
md_content = get_markdown_for_page(currentpage["md"],
pp_env=pp_env,
target=target)
except Exception as e:
print("Skipping page", currentpage["name"],
"due to error fetching contents:", e)
continue
html_content = parse_markdown(md_content, target, pages)
else:
html_content = ""
if "template" in currentpage:
# Use a template other than the default one
template = env.get_template(currentpage["template"])
out_html = template.render(currentpage=currentpage,
categories=categories,
pages=pages,
content=html_content)
else:
out_html = default_template.render(currentpage=currentpage,
categories=categories,
pages=pages,
content=html_content)
if for_pdf:
out_path = config["temporary_files_path"]
else:
out_path = config["out_path"]
fileout = os.path.join(out_path, currentpage["html"])
if not os.path.isdir(out_path):
logging.info("creating build folder %s" % out_path)
os.makedirs(out_path)
with open(fileout, "w") as f:
logging.info("writing to file: %s..." % fileout)
f.write(out_html)
import sys
import json
import argparse
from jinja2 import Environment, FileSystemLoader
parser = argparse.ArgumentParser('Create an wireshark dissector based on PTP data and a template')
parser.add_argument('-p','--ptp_description_folder')
parser.add_argument('-t','--template_file')
parser.add_argument('-d','--destination_file')
args = parser.parse_args()
template_folder, template_name = os.path.split(args.template_file)
template_env = Environment(loader=FileSystemLoader(template_folder))
template_env.lstrip_blocks = True
template_env.trim_blocks = True
json_path = os.path.join(args.ptp_description_folder, 'mtp_description.json')
with open(json_path, 'r') as fp:
description = json.load(fp)
# vendor support: Transform individual vendor json files
description['extensions'] = {}
vendor_definitions = [name for name in os.listdir(args.ptp_description_folder) if 'ptp_' in name and '.json' in name]
for vendor_definition in vendor_definitions:
json_path = os.path.join(args.ptp_description_folder, vendor_definition)
with open(json_path, 'r') as fp:
vendor_description = json.load(fp)
vendor = vendor_definition.replace('ptp_', '').replace('.json','')
description['extensions'][vendor] = vendor_description
def init_jinja():
global env
loader = FileSystemLoader(conf["blog"]["templates"])
env = Environment(loader=loader)
env.trim_blocks = True
import os
import json
from jinja2 import Environment, FileSystemLoader
PATH = os.path.dirname(os.path.abspath(__file__))
TEMPLATE_ENVIRONMENT = Environment(
autoescape=False,
loader=FileSystemLoader(os.path.join(PATH, 'templates')),
trim_blocks=False)
TEMPLATE_ENVIRONMENT.trim_blocks = True
TEMPLATE_ENVIRONMENT.lstrip_blocks = True
def render_template(template_filename, data):
return TEMPLATE_ENVIRONMENT.get_template(template_filename).render(data=data)
def create_csharp_code(context):
fname = "out/MQL.cs"
with open(fname, 'w') as f:
code = render_template('csharp.template', context)
f.write(code)
fname = "out/MQLCommand.cs"
with open(fname, 'w') as f:
code = render_template('command_enum.template', context)
f.write(code)
fname = "out/MQLRESTResource.cs"
with open(fname, 'w') as f:
code = render_template('csharp-rest.template', context)
f.write(code)
def setup_html_env():
env = Environment(loader=FileSystemLoader(config["template_path"]))
env.lstrip_blocks = True
env.trim_blocks = True
return env
def gen_android(model, output_folder, overwrite_manifest=True, eclipse_gen=True):
"""
Generate the android application with the applang parser that contains the model.
:param parser: The parser which was used to parse the applang language
:param debug(bool): Debug mode
:param output_folder(str): Folder to output the generated app
:return:
"""
print
print_log("~~~~Generating the ANDROID application~~~~")
print
config = model.config
android_specs = config.android_specs
print_log("App name: {}".format(config.app_name))
print_log("Namespace: {}".format(config.namespace))
print_log("Full Qname: {}".format(config.qname))
print_log("Min version: {}".format(android_specs.min_version))
print_log("Target version: {}".format(android_specs.target_version))
if android_specs.sdk_path is None:
print_log("WARNING: The Android SDK Path is not set! "
"This will cause problems if the libraries haven't been copied yet!")
if android_specs.sdk_path is not None and not os.path.exists(android_specs.sdk_path):
raise GeneratorException("The SDK in the specified path '{}' does not exist!"
.format(android_specs.sdk_path))
#Checking if the output folder exists. If it doesn't, creates it.
android_gen_folder = os.path.join(output_folder, "android", '')
if not os.path.exists(android_gen_folder):
print_log("Folder for storing generated android applications does not exist. It will be created: {}"
.format(os.path.abspath(android_gen_folder)))
os.makedirs(android_gen_folder)
output_app_folder = os.path.join(android_gen_folder, config.namespace.replace('.', os.path.sep), config.app_name, '')
if not os.path.exists(output_app_folder):
print_log("Folder for storing the generated android application does not exist. It will be created: {}"
.format(os.path.abspath(android_gen_folder)))
os.makedirs(output_app_folder)
print_log('App folder: {}'.format(os.path.abspath(android_gen_folder)))
print
#Checking if the V7 appcompat library exists.
#If it doesn't, copies it from the Android SDK.
output_appcompat_folder = os.path.join(android_gen_folder, 'appcompat', '')
if os.path.exists(output_appcompat_folder):
print_log("Appcompat library exists in {}. No need to copy it from the android SDK."
.format(os.path.abspath(output_appcompat_folder)))
else:
print_log("Appcompat does not exist in the generated folder. Copying in from the android SDK to {}"
.format(os.path.abspath(output_appcompat_folder)))
copy_tree(src=android_specs.sdk_path + PATH_APPCOMPAT_V7, dst=output_appcompat_folder)
#Framework copying
frameworks_folder = os.path.join(package_directory, "frameworks", "")
print
print_log("Copying the app framework to the output folder: {}".format(os.path.abspath(output_app_folder)))
copy_tree(src=os.path.join(frameworks_folder, "android"),
dst=android_gen_folder)
print_log("Finished copying the app framework.")
print
#File generation
environment = Environment(loader=FileSystemLoader(
os.path.join(package_directory, 'templates', 'android')))
environment.filters['cameltounder'] = camel_to_under
environment.trim_blocks = True
environment.lstrip_blocks = True
environment.globals['xml_gen_comment'] = XML_GEN_COMMENT
environment.globals['java_gen_comment'] = JAVA_GEN_COMMENT
environment.globals['xml_gen_once_comment'] = XML_GEN_ONCE_COMMENT
environment.globals['java_gen_once_comment'] = JAVA_GEN_ONCE_COMMENT
if eclipse_gen or \
query_yes_no("Do you want to generate "
"(and possibly overwrite) the eclipse files (.project and .classpath)?"):
print_log("Generating the eclipse files")
copy_file(src=os.path.join(frameworks_folder, 'eclipse_files', '.classpath'), dst=output_app_folder)
generate_from_template(environment, "dot.project.tmpl", output_app_folder, ".project",
config=config)
print_log("Finished generating the eclipse files")
# AndroidManifest.xml generation
generate_overwrite_backup_from_template(environment, "AndroidManifest.tmpl", output_app_folder,
"AndroidManifest.xml",
overwrite_manifest, config=config, android_specs=android_specs,
entities=model.entities,
has_image=[attr for entity in model.entities for attr in entity.attributes
if attr.primitive_type and attr.primitive_type == 'image'])
# project.properties generation
generate_from_template(environment, "project.properties.tmpl", output_app_folder, "project.properties",
android_specs=android_specs, namespace_dot_count=config.namespace.count('.'))
# res/values folder creation
output_gen_values_folder = os.path.join(output_app_folder, 'res', 'values', '')
if not os.path.exists(output_gen_values_folder):
os.makedirs(output_gen_values_folder)
# libs folder creation
output_gen_libs_folder = os.path.join(output_app_folder, 'libs', '')
if not os.path.exists(output_gen_libs_folder):
os.makedirs(output_gen_libs_folder)
# assets folder creation
output_gen_assets_folder = os.path.join(output_app_folder, 'assets', '')
if not os.path.exists(output_gen_assets_folder):
os.makedirs(output_gen_assets_folder)
# gen_string_entities.xml generation
generate_from_template(environment, "gen_strings_entities.xml.tmpl", output_gen_values_folder,
"gen_strings_entities.xml",
app_label=config.app_label, entities=model.entities)
# gen_arrays.xml generation
generate_from_template(environment, "gen_arrays.xml.tmpl", output_gen_values_folder,
"gen_arrays.xml",
config=config, entities=[entity for entity in model.entities if entity.operations.listall])
output_src_folder = os.path.dirname(os.path.join(output_app_folder, 'src', config.qname.replace(".", os.path.sep), ''))
if not os.path.exists(output_src_folder):
os.makedirs(output_src_folder)
# src gen folder creation
output_src_gen_folder = os.path.join(output_app_folder, 'src-gen', config.qname.replace(".", os.path.sep), '')
if not os.path.exists(output_src_gen_folder):
os.makedirs(output_src_gen_folder)
# databases folder creation
output_src_gen_databases_folder = os.path.join(output_src_gen_folder, 'databases', '')
if not os.path.exists(output_src_gen_databases_folder):
os.makedirs(output_src_gen_databases_folder)
# content_providers folder creation
output_src_gen_content_providers_folder = os.path.join(output_src_gen_folder, 'content_providers', '')
if not os.path.exists(output_src_gen_content_providers_folder):
os.makedirs(output_src_gen_content_providers_folder)
# adapters folder creation
output_src_gen_adapters_folder = os.path.join(output_src_gen_folder, 'adapters', '')
if not os.path.exists(output_src_gen_adapters_folder):
os.makedirs(output_src_gen_adapters_folder)
# fragments folder creation
output_src_gen_fragments_folder = os.path.join(output_src_gen_folder, 'fragments', '')
if not os.path.exists(output_src_gen_fragments_folder):
os.makedirs(output_src_gen_fragments_folder)
# res/layout folder creation
output_gen_layout_folder = os.path.join(output_app_folder, 'res', 'layout', '')
if not os.path.exists(output_gen_layout_folder):
os.makedirs(output_gen_layout_folder)
# DatabaseOpenHelper.java
generate_from_template(environment, "DatabaseOpenHelper.java.tmpl", output_src_gen_databases_folder,
"DatabaseOpenHelper.java",
config=config, entities=model.entities)
for entity in model.entities:
# Used for import statements in the code.
ref_entity_names = {attr.reference_type.name for attr in entity.attributes if attr.reference_type}
# User for view_from_container
view_container_attrs = [(entity_container, attr) for entity_container in model.entities for attr in entity_container.attributes
if attr.reference_type and attr.reference_type.name == entity.name and attr.view_from_container]
view_container_ref_entity_names = {x[0].name for x in view_container_attrs}
# {{Entity}}Table.java
generate_from_template(environment, "EntityTable.java.tmpl", output_src_gen_databases_folder,
"{}Table.java".format(entity.name),
config=config, entity=entity, TYPE_TEXT_IN_DB=TYPE_TEXT_IN_DB,
TYPE_INT_IN_DB=TYPE_INT_IN_DB, TYPE_REAL_IN_DB=TYPE_REAL_IN_DB)
#{{Entity}}ContentProvider.java
generate_from_template(environment, "EntityContentProvider.java.tmpl", output_src_gen_content_providers_folder,
"{}ContentProvider.java".format(entity.name),
config=config, entity=entity, ref_entity_names=ref_entity_names)
#{{Entity}}ListFragment.java
generate_from_template(environment, "EntityListFragment.java.tmpl", output_src_gen_fragments_folder,
"{}ListFragment.java".format(entity.name),
config=config, entity=entity, ref_entity_names=ref_entity_names)
#{{Entity}}DetailsFragment.java
generate_from_template(environment, "EntityDetailsFragment.java.tmpl", output_src_gen_fragments_folder,
"{}DetailsFragment.java".format(entity.name),
config=config, entity=entity, ref_entity_names=ref_entity_names,
view_container_attrs=view_container_attrs,
view_container_ref_entity_names=view_container_ref_entity_names)
#{{Entity}}Adapters.java
generate_from_template(environment, "EntityAdapter.java.tmpl", output_src_gen_adapters_folder,
"{}Adapter.java".format(entity.name),
config=config, entity=entity, ref_entity_names=ref_entity_names)
#{{Entity}}NewFragment.java
generate_from_template(environment, "EntityNewFragment.java.tmpl", output_src_gen_fragments_folder,
"{}NewFragment.java".format(entity.name),
config=config, entity=entity, ref_entity_names=ref_entity_names)
#{{Entity}}EditFragment.java
generate_from_template(environment, "EntityEditFragment.java.tmpl", output_src_gen_fragments_folder,
"{}EditFragment.java".format(entity.name),
config=config, entity=entity, ref_entity_names=ref_entity_names)
generate_from_template(environment, "gen_list_item_entity.xml.tmpl", output_gen_layout_folder,
"gen_list_item_{}.xml".format(camel_to_under(entity.name)),
entity=entity)
generate_from_template(environment, "gen_fragment_entity_details.xml.tmpl", output_gen_layout_folder,
"gen_fragment_{}_details.xml".format(camel_to_under(entity.name)),
entity=entity, view_container_attrs=view_container_attrs)
generate_from_template(environment, "gen_fragment_entity_new.xml.tmpl", output_gen_layout_folder,
"gen_fragment_{}_new.xml".format(camel_to_under(entity.name)),
entity=entity)
generate_from_template(environment, "gen_fragment_entity_edit.xml.tmpl", output_gen_layout_folder,
"gen_fragment_{}_edit.xml".format(camel_to_under(entity.name)),
entity=entity)
# Generating impl classes ONCE
output_src_impl_databases_folder = os.path.join(output_src_folder, 'impl', 'databases', '')
if not os.path.exists(output_src_impl_databases_folder):
os.makedirs(output_src_impl_databases_folder)
output_src_impl_fragments_folder = os.path.join(output_src_folder, 'impl', 'fragments', '')
if not os.path.exists(output_src_impl_fragments_folder):
os.makedirs(output_src_impl_fragments_folder)
# DatabaseOpenHelperImpl.java generate
generate_once_from_template(environment, "DatabaseOpenHelperImpl.java.tmpl", output_src_impl_databases_folder,
"DatabaseOpenHelperImpl.java",
config=config)
for entity in model.entities:
generate_once_from_template(environment, "EntityListFragmentImpl.java.tmpl", output_src_impl_fragments_folder,
"{}ListFragmentImpl.java".format(entity.name),
config=config, entity=entity)
generate_once_from_template(environment, "EntityNewFragmentImpl.java.tmpl", output_src_impl_fragments_folder,
"{}NewFragmentImpl.java".format(entity.name),
config=config, entity=entity)
generate_once_from_template(environment, "EntityEditFragmentImpl.java.tmpl", output_src_impl_fragments_folder,
"{}EditFragmentImpl.java".format(entity.name),
config=config, entity=entity)
generate_once_from_template(environment, "EntityDetailsFragmentImpl.java.tmpl", output_src_impl_fragments_folder,
"{}DetailsFragmentImpl.java".format(entity.name),
config=config, entity=entity)
print
print_log("Finished generating the ANDROID application in {}".format(os.path.abspath(android_gen_folder)))
print
def render_pages(precompiled):
print("reading page manifest...")
with open(PAGE_MANIFEST_FILE) as f:
pages = json.load(f)
print("done")
env = Environment(loader=FileSystemLoader(os.path.curdir))
env.lstrip_blocks = True
env.trim_blocks = True
for currentpage in pages:
if "md" in currentpage:
# Documentation file
print("reading template file...")
# with open(DOC_TEMPLATE_FILE) as f:
# template_text = f.read()
# doc_template = Template(template_text)
doc_template = env.get_template(DOC_TEMPLATE_FILE)
print("done")
if precompiled:
filein = os.path.join(CONTENT_PATH, currentpage["md"])
args = ['pandoc', filein, '-F', BUTTONIZE_FILTER, '-t', 'html']
print("compiling: running ", " ".join(args),"...")
pandoc_html = subprocess.check_output(args, universal_newlines=True)
print("done")
print("rendering page",currentpage,"...")
out_html = doc_template.render(currentpage=currentpage, pages=pages,
content=pandoc_html, precompiled=precompiled)
print("done")
else:
print("compiling skipped")
print("rendering page",currentpage,"...")
out_html = doc_template.render(currentpage=currentpage, pages=pages,
content="", precompiled=precompiled)
print("done")
else:
# Not a documentation page
print("reading template file...")
# with open(currentpage["template"]) as f:
# template_text = f.read()
# template = Template(template_text)
template = env.get_template(currentpage["template"])
print("done")
print("rendering page",currentpage,"...")
out_html = template.render(currentpage=currentpage, pages=pages)
print("done")
fileout = os.path.join(BUILD_PATH, currentpage["html"])
if (not os.path.isdir(BUILD_PATH)):
print("creating build folder",BUILD_PATH)
os.makedirs(BUILD_PATH)
with open(fileout, "w") as f:
print("writing to file:",fileout,"...")
f.write(out_html)
print("done")
#!/usr/bin/python
# -*- coding: <encoding name> -*-
import os;
from jinja2 import Environment, PackageLoader
filedict = {'apiaction': 'Action.java', 'entity': '.java', 'mapper': 'Mapper.java', 'service': 'Service.java',
'xml': '.xml'}
env = Environment(loader=PackageLoader('result'))
workPath = os.path.dirname(os.path.realpath(__file__))
env.trim_blocks = True
def genCode(jsonStr, dirname, fileName):
template = env.get_template(dirname + '.j2')
content = template.render(jsonStr)
moduleName = jsonStr['module'];
name = jsonStr['name'];
modulePath = workPath + '\\result\\output\\' + moduleName + '\\'
childPath = modulePath + dirname
filePath = childPath + '\\' + name + fileName
if (not os.path.exists(childPath)):
os.makedirs(childPath)
fo = open(filePath, 'w', encoding='utf8')
fo.write(content.encode().decode('utf-8'))
fo.close()
def pre(jsonStr):
for key, value in filedict.items():
