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 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 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 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 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 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 __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 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 __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 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 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 _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, 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 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 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 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 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 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 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 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 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 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 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 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 _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_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 generate_template(self): # src_dir = os.path.dirname(os.path.realpath(__file__)) file_loader = FileSystemLoader(self.template_dir) env = Environment(loader=file_loader) env.filters['ipaddr'] = self._ipaddr env.trim_blocks = True env.lstrip_blocks = True env.rstrip_blocks = True template = env.get_template(self.template_file) output = template.render(data=self.template_data) return output
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 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 render_jinja_template(jinja_template_file: str, context: dict) -> str: from jinja2 import Environment, FileSystemLoader template_path = pathlib.Path(jinja_template_file) env = Environment(loader=FileSystemLoader(str(template_path.parent))) env.trim_blocks = True env.lstrip_blocks = True env.rstrip_blocks = True template = env.get_template(str(template_path.name)) return template.render(**context)
def create_ansible_hosts(self, net_name): self.__logger.info("Create file ansible hosts ... ") env = Environment(loader=BaseLoader).from_string(ansible_template) env.trim_blocks = True env.lstrip_blocks = True env.rstrip_blocks = True srvs = self.get_srv_nets(net_name) self.__logger.info(f'servers: {srvs}') ans_result = env.render(srvs=self.get_srv_nets(net_name)) with open("hosts-example.yml", mode='w') as fn: fn.write(ans_result) self.__logger.info(ans_result)
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 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")
if len(tokens) > 1: ret = tokens[1] return ret def regex_replace(s, find, replace): return re.sub(find, replace, s) def resolve_import(imp): return volib.resolvers[get_tuple(imp)].import_ __cwd = os.path.dirname(os.path.abspath(__file__)) env = Environment(loader=FileSystemLoader(os.path.join(__cwd, 'templates'))) env.lstrip_blocks = True env.trim_blocks = True env.filters['pythonify'] = pythonify env.filters['alpha'] = alpha env.filters['resolve'] = resolve env.filters['resolve_import'] = resolve_import env.filters['regex_replace'] = regex_replace def write_package(package, meta, basedir): pkg_dir = os.path.join(basedir, package.name) if not os.path.exists(pkg_dir): os.makedirs(pkg_dir) with open(os.path.join(pkg_dir, '__init__.py'), 'w') as f:
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)
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
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)
import io 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','')
def setup_html_env(): env = Environment(loader=FileSystemLoader(config["template_path"])) env.lstrip_blocks = True env.trim_blocks = True return env