def test_standard_template_is_valid_jinja2_format(): """ Validate that the standard LaTeX template is well-formed as far as Jinja2 is concerned. """ env = Environment() template_string = pkg_resources.resource_string( 'pyresume', 'templates/standard.tex').decode() env.parse(template_string)
def test_jinja_templates(): templates = [] for root, dirnames, filenames in os.walk('.'): for filename in fnmatch.filter(filenames, '*.j2'): templates.append(os.path.join(root, filename)) jinja_env = JEnvironment() for path in templates: with open(path) as template: jinja_env.parse(template.read(), filename=path)
def edit_welcome_email(): """Edit welcome email template""" company = Company.query.first() form = WelcomeEmailTemplateForm() default_template = open( Path(current_app.root_path + "/emails/welcome.jinja2.html")).read() custom_template = EmailTemplate.query.first() new_custom_template = None if request.method == "POST": new_custom_template = form.template.data if custom_template is None: # First time creating custom template custom_template = EmailTemplate() database.session.add(custom_template) if form.validate_on_submit( ) and form.use_custom_welcome_email.data is True: new_custom_template = form.template.data # Validate template syntax env = Environment() try: env.parse(new_custom_template) # Store the validated template custom_template.custom_welcome_email_template = new_custom_template custom_template.use_custom_welcome_email = True flash("Email template has been saved.") flash("Using custom template for welcome email") except jinja2.exceptions.TemplateSyntaxError as e: form.template.errors.append(e) else: custom_template.use_custom_welcome_email = False if request.method == "POST": flash("Using default template for welcome email") database.session.commit() return render_template( "admin/email/edit_customer_sign_up_email.html", form=form, default_template=default_template, custom_template=custom_template.custom_welcome_email_template, new_custom_template=new_custom_template, use_custom_welcome_email=custom_template.use_custom_welcome_email, company=company, )
def fill_template(param_list): """Here we setup the core template engine, we will need to declare any filters we add inside this module, see the 'mine_salt' example below.""" env = Environment(loader=FileSystemLoader(('nginx-templates/', 'mysql-templates/', 'temp/', 'misc-templates/'))) env.filters['mine_salt'] = mine_salt try: template_source = env.loader.get_source(env, param_list[1])[0] except: raise NameError('Template Name invalid, please check recipe') template = env.get_template(param_list[1]) parsed_content = env.parse(template_source) tags = meta.find_undeclared_variables(parsed_content) tags_input = {} for tag in tags: if tag in values_used: tags_input[tag] = values_used[tag] else : print 'Please enter value for ' + tag temp = raw_input() if temp.count(' ') : value_list = temp.split(' ') tags_input[tag] = value_list values_used[tag] = value_list else : tags_input[tag] = [temp] values_used[tag] = [temp] print(template.render(tags_input))
def convert(): dummy_values = [ "Lorem", "Ipsum", "Amet", "Elit", "Expositum", "Dissimile", "Superiori", "Laboro", "Torquate", "sunt", ] tpl = Template(request.form["template"]) values = {} if bool(int(request.form["dummyvalues"])): # List variables (introspection) env = Environment() vars_to_fill = meta.find_undeclared_variables(env.parse(request.form["template"])) for v in vars_to_fill: values[v] = choice(dummy_values) else: values = json.loads(request.form["values"]) rendered_tpl = tpl.render(values) if bool(int(request.form["showwhitespaces"])): # Replace whitespaces with a visible character (will be grayed with javascript) rendered_tpl = rendered_tpl.replace(" ", u"•") return rendered_tpl.replace("\n", "<br />")
def render(filename, obj): """Render a template, maybe mixing in extra variables""" template_path = abspath(filename) fs_loader = FileSystemLoader(os.path.dirname(template_path)) env = Environment(loader=fs_loader, autoescape=True) env.filters['b64encode'] = portable_b64encode env.filters['b64decode'] = portable_b64decode template_src = env.loader.get_source(env, os.path.basename(template_path)) parsed_content = env.parse(template_src) template_vars = meta.find_undeclared_variables(parsed_content) if template_vars: missing_vars = [] default_vars = grok_default_vars(parsed_content) for var in template_vars: if var not in default_vars and var not in obj: missing_vars.append(var) if missing_vars: e_msg = "Missing required variables %s" % ','.join(missing_vars) raise aomi.exceptions.AomiData(e_msg) template_obj = env.get_template(os.path.basename(template_path)) output = template_obj.render(**obj) return output
def run(self): self.output = {} self.roots = [] self.htmlFiles = [] # get all html files and paths in application for root, dirs, files in os.walk(self.path): for file in files: if file.endswith(".html"): self.roots.append(root) self.htmlFiles.append(file) for i in range(len(self.htmlFiles)): jinjaEnv = Environment(autoescape=False, loader=FileSystemLoader(self.roots[i]), trim_blocks=False) jinjaEnv.filters['is_subset'] = self.is_subset jinjaEnv.filters['perm_check'] = self.perm_check temp_source = jinjaEnv.loader.get_source(jinjaEnv, self.htmlFiles[i]) self.parsed_content = jinjaEnv.parse(temp_source[0]) analyzerH = _TemplateWalker() analyzerH.visit(self.parsed_content) if analyzerH.instances: pathAppend = "" rootDiv = self.roots[i].split(sep='\\') if current_app.template_folder in rootDiv: templateIndex = rootDiv.index(current_app.template_folder) if templateIndex < len(rootDiv)-1: for j in range(templateIndex+1, len(rootDiv)): pathAppend += rootDiv[j] + '/' self.output[pathAppend+self.htmlFiles[i]] = analyzerH.instances
def generate_edges(resources): """ The connecting line between two resource is called an edge. Edges are directed from one vertex (resource) to another, the graph is called a directed graph. This function is used to construct the graph. Args: resources (list): resources list """ for resource in resources: # convert to raw string raw = json.dumps(resource) env = Environment(loader=FileSystemLoader('templates')) vertex = resource['name'] # direct dependency neighbors = [] # jinja function find_undeclared_variables found not resolved vars for neighbour in meta.find_undeclared_variables(env.parse(raw)): if not neighbour in EDGES_IGNORES and neighbour != vertex\ and not neighbour in neighbors: neighbors.append(neighbour) for neighbour in neighbors: yield (vertex, neighbour,) # isolated node if len(neighbors) == 0: yield (vertex, vertex,)
def get_var_templates(template): env = Environment() ast = env.parse(template.content) exceptions = ("vidly_tokenize", "edgecast_tokenize", "akamai_tokenize", "popcorn_url", "event", "poster_url") undeclared_variables = [x for x in meta.find_undeclared_variables(ast) if x not in exceptions] return ["%s=" % v for v in undeclared_variables]
def convert(): dummy_values = [ 'Lorem', 'Ipsum', 'Amet', 'Elit', 'Expositum', 'Dissimile', 'Superiori', 'Laboro', 'Torquate', 'sunt', ] tpl = app.jinja_env.from_string(request.form['template']) values = {} if bool(int(request.form['dummyvalues'])): # List variables (introspection) env = Environment() vars_to_fill = meta.find_undeclared_variables(env.parse(request.form['template'])) for v in vars_to_fill: values[v] = choice(dummy_values) else: if request.form['optiontype'] == 'yaml': values = json.loads(json.dumps(yaml.load(request.form['values']))) else: values = json.loads(request.form['values']) rendered_tpl = tpl.render(values) if bool(int(request.form['showwhitespaces'])): # Replace whitespaces with a visible character (will be grayed with javascript) rendered_tpl = rendered_tpl.replace(' ', u'•') return rendered_tpl.replace('\n', '<br />')
def analyze(template_path: str, values: dict, engine: Environment) -> Tuple[Set[str], Set[str], Set[str], bool]: template_source = engine.loader.get_source(engine, template_path)[0] abstract_syntax_tree = engine.parse(template_source) has_secrets = any( getattr(call.node, "name", None) == "get_secret" for call in abstract_syntax_tree.find_all(nodes.Call)) required_variables = get_variables(abstract_syntax_tree, engine) defined_variables = set(values.keys()) LOGGER.debug("defined variables: %s", defined_variables) LOGGER.debug("found required variables in template %s: %s", template_path, required_variables) undefined_variables = required_variables.difference(defined_variables) unused_variables = defined_variables.difference(required_variables) invalid_variables = { var for var in required_variables if var in PROHIBITED_VARIABLE_NAMES } return ( undefined_variables - invalid_variables), unused_variables, invalid_variables, has_secrets
def get_template_variables(config, upload_path): with open(upload_path + "/test_template.txt", 'w') as f: f.write(config) env = Environment() parsed_config = env.parse(config) result = list(meta.find_undeclared_variables(parsed_config)) return result
def _validate_dependencies(renderable_params, context): ''' Validates dependencies between the parameters. e.g. { 'a': '{{b}}', 'b': '{{a}}' } In this example 'a' requires 'b' for template rendering and vice-versa. There is no way for these templates to be rendered and will be flagged with an ActionRunnerException. ''' env = Environment(undefined=StrictUndefined) dependencies = {} for k, v in six.iteritems(renderable_params): template_ast = env.parse(v) dependencies[k] = meta.find_undeclared_variables(template_ast) for k, v in six.iteritems(dependencies): if not _check_availability(k, v, renderable_params, context): msg = 'Dependecy unsatisfied - %s: %s.' % (k, v) raise actionrunner.ActionRunnerException(msg) dep_chain = [] dep_chain.append(k) if not _check_cyclic(dep_chain, dependencies): msg = 'Cyclic dependecy found - %s.' % dep_chain raise actionrunner.ActionRunnerException(msg)
class TemplateManager(object): """ template manager for all files in a path """ def __init__(self, template_path): """ Args: template_path: string or list of strings of directory containing templates """ self._environment = Environment(loader=FileSystemLoader(template_path), undefined=StrictUndefined) def render(self, template_name, params=None): """ render a template """ template = self._environment.get_template(template_name) try: return template.render(**(params or {})) except UndefinedError as e: if e.message.endswith('is undefined'): raise ValueError('missing "%s" param' % e.message.split("'")[1]) raise ValueError('template param error: ' + e.message) def params(self, template_name): """ This requires parsing the template so it should only be used in exceptional cases Returns: set of params used by this template """ source = self._environment.loader.get_source(self._environment, template_name) parsed = self._environment.parse(source) return meta.find_undeclared_variables(parsed)
def _render_template_comment(self, toks, kwargs): env = Environment() ast = env.parse(toks[0]) for param_name in jinja2.meta.find_undeclared_variables(ast): self.used_params.append(param_name) template = jinja2.Template(toks[0]) return template.render(**kwargs).strip('\n')
def _build_view(self, view_name): """ build a new View definition """ if view_name in self.catalog: return self.catalog[view_name] view_dict = self._catalog_dict[view_name] kvargs = {'view_name': view_name} # if there are field groups, then get that now. if 'groups' in view_dict: kvargs['groups'] = view_dict['groups'] # if there are eval, then get that now. if 'eval' in view_dict: kvargs['eval'] = {} for key, exp in view_dict['eval'].items(): env = Environment() kvargs['eval'][key] = env.parse(exp) # if this view extends another ... if 'extends' in view_dict: base_cls = self.catalog.get(view_dict['extends']) # @@@ should check for base_cls is None! kvargs['extends'] = base_cls fields = _FIELDS() fg_list = [name for name in view_dict if name.startswith('fields')] for fg_name in fg_list: self._add_view_fields(view_dict, fg_name, fields) cls = _VIEW(fields.end, **kvargs) self.catalog[view_name] = cls return cls
def jinja(self, node): from jinja2 import Environment, meta self.name # This is a mistery, but it makes the framework # find the task generator by name. self.source = self.to_nodes(getattr(self, 'source')) env = Environment() parsed_content = env.parse(self.source[0].read()) variables = meta.find_undeclared_variables(parsed_content) args = {v: getattr(self, v) for v in variables} if isinstance(self.target, str): self.target = self.target.split() if not isinstance(self.target, list): self.target = [self.target] if isinstance(self.target[0], str): tmp = self.path.find_or_declare(self.target[0]) else: tmp = self.target[0] tmp.mkdir() self.target = [tmp] tsk = self.create_task('jinja_generate', node, tmp) tsk.args = args try: self.generative_task.append(tsk) except AttributeError: self.generative_task = [tsk] return tsk
class JinjaFilter(Filter): def __init__(self, **kwargs): self.env = Environment(keep_trailing_newline=True, **kwargs) self.addfilter("brace", self.brace) def addfilter(self, name, fn): self.env.filters[name] = fn def brace(self, vals): if isinstance(vals, (tuple, list)): vals = [self.brace(x) for x in vals] return "{" + ",".join(vals) + "}" return str(vals) def render(self, s: str, vals: dict) -> str: tmpl = self.env.from_string(s) return tmpl.render(**vals) def var_names(self, s: str) -> List[str]: res = set() for b in self.env.parse(source=s).body: res.update([ x.name for x in filter( lambda f: f.__class__.__name__ == "Name", b.nodes) ]) return res
def parsed(): env = Environment(loader=None) p = env.parse('<h1><p>{{ state.count + 1 }}</p></h1>') output = p.body[0] nodes = output.nodes for node in nodes: print(node)
def _build_cmdview(self, view_name): """ build a new View definition """ if view_name in self.catalog: return self.catalog[view_name] view_dict = self._catalog_dict[view_name] kvargs = {'view_name': view_name} if 'columns' in view_dict: kvargs['columns'] = view_dict['columns'] elif 'title' in view_dict: kvargs['title'] = view_dict['title'] if 'regex' in view_dict: kvargs['regex'] = view_dict['regex'] if 'exists' in view_dict: kvargs['exists'] = view_dict['exists'] if 'filters' in view_dict: kvargs['filters'] = view_dict['filters'] if 'eval' in view_dict: kvargs['eval'] = {} for key, exp in view_dict['eval'].items(): env = Environment() kvargs['eval'][key] = env.parse(exp) fields = _FIELDS() fg_list = [name for name in view_dict if name.startswith('fields')] for fg_name in fg_list: self._add_cmd_view_fields(view_dict, fg_name, fields) cls = _CMDVIEW(fields.end, **kvargs) self.catalog[view_name] = cls return cls
def _build_cmdview(self, view_name): """ build a new View definition """ if view_name in self.catalog: return self.catalog[view_name] view_dict = self._catalog_dict[view_name] kvargs = {"view_name": view_name} if "columns" in view_dict: kvargs["columns"] = view_dict["columns"] elif "title" in view_dict: kvargs["title"] = view_dict["title"] if "regex" in view_dict: kvargs["regex"] = view_dict["regex"] if "exists" in view_dict: kvargs["exists"] = view_dict["exists"] if "filters" in view_dict: kvargs["filters"] = view_dict["filters"] if "eval" in view_dict: kvargs["eval"] = {} for key, exp in view_dict["eval"].items(): env = Environment() kvargs["eval"][key] = env.parse(exp) fields = _FIELDS() fg_list = [name for name in view_dict if name.startswith("fields")] for fg_name in fg_list: self._add_cmd_view_fields(view_dict, fg_name, fields) cls = _CMDVIEW(fields.end, **kvargs) self.catalog[view_name] = cls return cls
def createMadlib(cls): template = input("Type your story with double curly braces around each variable name (e.g. {{Name}} is going to {{country}}.)") env = Environment() ast = env.parse(template) variables = list(meta.find_undeclared_variables(ast)) print(variables) print() originalStory = {} for var in variables: value = input("What is the value of {{" + var + "}} in your original story?") originalStory[var] = value print(originalStory) print() prompts = {} for var in variables: prompt = input("What is the description of {{" + var + "}}?") prompts[var] = prompt print(prompts) print() madlib = {"template": template, "originalStory": originalStory, "prompts": prompts, "stories": {} } madlibName = input("What do you want to name this madlib?") filename = './madlibs/' + madlibName + ".json" with open(filename, 'w') as f: json.dump(madlib, f, indent=4) print("madlib saved successfully")
def get_template_variables(filename): path = os.path.join(current_app.root_path, "templates") env = Environment(loader=FileSystemLoader(path)) template_source = env.loader.get_source(env, filename)[0] parsed_content = env.parse(template_source) return meta.find_undeclared_variables(parsed_content)
def extract_variable(file): # Load Base Template File templateloader = FileSystemLoader(searchpath="./Base_Template_Files") env = Environment(loader=templateloader, autoescape=False) jinja_filters_func = dir(_jinja_custom_filters) # Register custom filters into Jinja2 Environment for func in jinja_filters_func: if 'jinj_' in func: func_ref = getattr(_jinja_custom_filters, func) filter_name = func.split('_')[1] env.filters[filter_name] = func_ref try: template = env.get_template(file) except TemplateNotFound: print("\033[91m", "Template File", file, "not found in Base_Template_Files directory", "\033[0m") traceback.print_exc() sys.exit(2) # Fetch all variables declared in template file template_source = env.loader.get_source(env, file) parsed_content = env.parse(template_source) template_vars = meta.find_undeclared_variables(parsed_content) print("\n", "\u001b[36;1m", str(len(template_vars)), "Variables found in template:", file, "\u001b[0m", "\n") for var in template_vars: print("\u001b[36;1m", '---------------------------------------------', "\u001b[0m") print('\033[93m', var, '\033[0m') print("\n") return template
def get_inherited_template(config, ast): if config.LOADER: loader = config.LOADER else: loader = PackageLoader(config.PACKAGE_NAME, config.TEMPLATE_DIR) env = Environment(loader=loader) return env.parse(env.loader.get_source(env, ast.template.value)[0])
def extract_variables(filename): """Extract text from template file and get jinja variables""" extracted = textract.process(filename) env = Environment(loader=BaseLoader()) content = env.parse(extracted) variables = meta.find_undeclared_variables(content) return variables
def __init__(self, source:str, environment:Environment) -> None: self.source = source parsed = environment.parse(source) self.variables = meta.find_undeclared_variables(parsed) self.template = environment.from_string(source)
def __GetIncludeFilesCandidateMessage(self, categolies: list, env: jinja2.Environment, template: jinja2.Template): with pathlib.Path(template.filename).open() as f: source = f.read() includes = TemplateIncludeFiles(self.__cmdfile.TemplateDir, env).Get(source) print('****************************************') print('テンプレート変数が不足しているか誤りがあります。') print('たとえば以下のように入力してください。\n') tpl_var_names = sorted(meta.find_undeclared_variables( env.parse(source)), key=str.lower) print('$ do', ' '.join(categolies), self.__GetExampleCommand(tpl_var_names, includes) + '\n') print('テンプレート変数は以下のコマンドで指定します。') print(' '.join([self.__tpl_var_prefix + v for v in tpl_var_names]) + '\n') if 0 < len(includes): print('include用テンプレ引数とその値の候補は以下のとおり。') for i in includes: print(self.__tpl_var_prefix + i[0], i[1]) print('\n対象テンプレートは以下です。') print(template.filename) print('****************************************')
class ParserTestCase(TestCase): def setUp(self): self.env = Environment() def test_question(self): ast = self.env.parse(TEMPLATE) p = TaskParser(ast) tasks = p.get_tasks() self.assertEqual(len(tasks), 2) multiple_choice = tasks['hello'] question = tasks['world'] self.assertEqual(multiple_choice.identifier, 'hello') self.assertEqual(multiple_choice.task_type, 'multiple_choice') choices = multiple_choice.choices self.assertEqual(choices['cookies'].name, 'cookies') self.assertEqual(choices['cookies'].correct, True) self.assertEqual(choices['nocookies'].name, 'nocookies') self.assertEqual(choices['nocookies'].correct, False) self.assertEqual(choices['morecookies'].name, 'morecookies') self.assertEqual(choices['morecookies'].correct, True) self.assertEqual(question.identifier, 'world') self.assertEqual(question.task_type, 'question') self.assertEqual(question.answers, ['42']) self.assertEqual(question.strip, False) self.assertEqual(question.case_sensitive, False)
def parse_template(template): """ Parses the abstract syntax tree of a template and returns a set of all context variables in the template. """ env = Environment() ast = env.parse(template) return meta.find_undeclared_variables(ast)
def get_var_templates(template): env = Environment() ast = env.parse(template.content) exceptions = ('vidly_tokenize', 'edgecast_tokenize', 'popcorn_url') undeclared_variables = [x for x in meta.find_undeclared_variables(ast) if x not in exceptions] return ["%s=" % v for v in undeclared_variables]
def get_template_vars(self, ignorevars=[]): env = Environment(loader=FileSystemLoader(self.templatepath), undefined=StrictUndefined) tplsrc = env.loader.get_source(env, self.templatename)[0] ast = env.parse(tplsrc) tplvars = meta.find_undeclared_variables(ast) # TODO Option for returing data unordered? return sorted([e for e in tplvars if not e in ignorevars])
def template_env_autofill(request): """JSON response containing undefined variables in the requested template. Provides template for filling in environment.""" template_id = request.GET['template'] template = Template.objects.get(id=template_id) env = Environment() ast = env.parse(template.content) undeclared_variables = list(meta.find_undeclared_variables(ast)) var_templates = ["%s=" % v for v in undeclared_variables] return {'variables': '\n'.join(var_templates)}
def extract_variables(self): env = Environment(loader=FileSystemLoader(self.template_dir)) variables = set() templates_to_visit = list(self.template_files()) while templates_to_visit: template = templates_to_visit.pop(0) template_source = env.loader.get_source(env, template)[0] ast = env.parse(template_source) templates_to_visit.extend( list(jinja2.meta.find_referenced_templates(ast))) variables.update(jinja2.meta.find_undeclared_variables(ast)) return variables
def convert(): jinja2_env = Environment() # Load custom filters custom_filters = get_custom_filters() app.logger.debug('Add the following customer filters to Jinja environment: %s' % ', '.join(custom_filters.keys())) jinja2_env.filters.update(custom_filters) # Load the template try: jinja2_tpl = jinja2_env.from_string(request.form['template']) except (exceptions.TemplateSyntaxError, exceptions.TemplateError) as e: return "Syntax error in jinja2 template: {0}".format(e) dummy_values = [ 'Lorem', 'Ipsum', 'Amet', 'Elit', 'Expositum', 'Dissimile', 'Superiori', 'Laboro', 'Torquate', 'sunt', ] values = {} if bool(int(request.form['dummyvalues'])): # List template variables (introspection) vars_to_fill = meta.find_undeclared_variables(jinja2_env.parse(request.form['template'])) for v in vars_to_fill: values[v] = choice(dummy_values) else: # Check JSON for errors if request.form['input_type'] == "json": try: values = json.loads(request.form['values']) except ValueError as e: return "Value error in JSON: {0}".format(e) # Check YAML for errors elif request.form['input_type'] == "yaml": try: values = yaml.load(request.form['values']) except (ValueError, yaml.parser.ParserError, TypeError) as e: return "Value error in YAML: {0}".format(e) else: return "Undefined input_type: {0}".format(request.form['input_type']) # If ve have empty var array or other errors we need to catch it and show try: rendered_jinja2_tpl = jinja2_tpl.render(values) except (ValueError, TypeError) as e: return "Error in your values input filed: {0}".format(e) if bool(int(request.form['showwhitespaces'])): # Replace whitespaces with a visible character (will be grayed with javascript) rendered_jinja2_tpl = rendered_jinja2_tpl.replace(' ', u'•') return rendered_jinja2_tpl.replace('\n', '<br />')
def get_all_variables_from_jinja_template(self, relative_template_path): # Example template path: "faculty_bios/templates/faculty-bio-form.html" PATH = os.path.dirname(os.path.abspath(__file__)) # get the path of current file TEMPLATE_ENVIRONMENT = Environment( autoescape=False, loader=FileSystemLoader(os.path.join(PATH)), trim_blocks=False ) template_source = TEMPLATE_ENVIRONMENT.loader.get_source(TEMPLATE_ENVIRONMENT, relative_template_path)[0] parsed_content = TEMPLATE_ENVIRONMENT.parse(template_source) variables = meta.find_undeclared_variables(parsed_content) keywords_to_ignore = set(['csrf_token', 'url_for']) return variables.difference(keywords_to_ignore)
def template_env_autofill(request): """JSON response containing undefined variables in the requested template. Provides template for filling in environment.""" template_id = request.GET['template'] template = Template.objects.get(id=template_id) env = Environment() ast = env.parse(template.content) exceptions = ('vidly_tokenize', 'edgecast_tokenize') undeclared_variables = [x for x in meta.find_undeclared_variables(ast) if x not in exceptions] var_templates = ["%s=" % v for v in undeclared_variables] return {'variables': '\n'.join(var_templates)}
def render(sense, action): env = Environment(loader=FileSystemLoader('/src/templates/sense')) template_source = env.loader.get_source(env, sense+'.py')[0] parsed_content = env.parse(template_source) vars = meta.find_undeclared_variables(parsed_content) args = {} for var in vars: if "NOTIFICATIONS_" + var.upper() in os.environ: args[var] = os.environ["NOTIFICATIONS_" + var.upper()] else: print "Could not find NOTIFICATIONS_"+var.upper()+" in environment variables" exit() template = env.get_template(sense+'.py') render = template.render(**args) with open('/src/binpy/sense.py', 'w+') as fh: fh.write(render) env = Environment(loader=FileSystemLoader('/src/templates/action')) template_source = env.loader.get_source(env, action+'.py')[0] parsed_content = env.parse(template_source) vars = meta.find_undeclared_variables(parsed_content) args = {} for var in vars: if "NOTIFICATIONS_" + var.upper() in os.environ: args[var] = os.environ["NOTIFICATIONS_" + var.upper()] else: print "Could not find NOTIFICATIONS_"+var.upper()+" in environment variables" exit() template = env.get_template(action+'.py') render = template.render(**args) with open('/src/binpy/action.py', 'w+') as fh: fh.write(render)
def get_render_func(string): func = None env = Environment() ast = env.parse(string) variables = meta.find_undeclared_variables(ast) if 'temperature' in variables: func = render_weather if 'location' in variables: func = render_location if 'faceemotion' in variables: func = render_face_emotion if 'objectdetected' in variables: func = render_object_detected return func
def main(argv): # Fetch options template_dir = '' template_file = '' output_file = '' try: opts, args = getopt.getopt(argv,"hd:f:o:",["template_dir=", "template_file=", "output_file="]) except getopt.GetoptError: print 'Example usage:' + '\n' + 'tokenisation.py -d TEMPLATE_DIR -f TEMPLATE_FILE -o OUTPUT_FILE' sys.exit(2) for opt, arg in opts: if opt == '-h': print 'Example usage:' + '\n' + 'tokenisation.py -d TEMPLATE_DIR -f TEMPLATE_FILE -o OUTPUT_FILE' sys.exit() elif opt in ("-d", "--template_dir"): template_dir = arg elif opt in ("-f", "--template_file"): template_file = arg elif opt in ("-o", "--output_file"): output_file = arg # Load templates file env = Environment(loader=FileSystemLoader(template_dir)) template = env.get_template(template_file) # Fetch and print all variables in tempalte file print 'Fetch and print all variables in template file' fetched_vars = [] template_source = env.loader.get_source(env, template_file)[0] parsed_content = env.parse(template_source) fetched_vars = meta.find_undeclared_variables(parsed_content) print 'Fetched variables:', fetched_vars # Add environment variables to a dict env_vars_dict = {} for env_var in fetched_vars: env_key = env_var env_value = os.environ[env_var] env_vars_dict[env_key] = env_value # Tokenise output_from_parsed_template = template.render(env_vars_dict) print 'Tokenisation complete' # Save file with open(output_file, "wb") as tokenised_file: tokenised_file.write(output_from_parsed_template)
def get_template_vars(self, ignorevars=[], sort=True, maxnestlevels=100): """Return a list of all variables found in the template Arguments: ignorevars -- a list of variables that are removed from the output sort -- True (default) or False if returned list should be sorted maxnestlevels -- a positve integer which defines how deep you can nest templates with includes """ tplvars = [] templates = [] templatesseen = [] nestlevels = 0 env = Environment(loader=FileSystemLoader(self.templatepath), undefined=StrictUndefined) templates.append(self.templatename) templatesseen.append(self.templatename) while len(templates) > 0: tpl = templates.pop() nested = False tplsrc = env.loader.get_source(env, tpl)[0] ast = env.parse(tplsrc) for template in meta.find_referenced_templates(ast): if template in templatesseen: raise Exception("Template loop detected: \"{}\" references \"{}\" which was seen earlier".format(tpl, template)) else: templates.append(template) templatesseen.append(template) nested = True for e in meta.find_undeclared_variables(ast): if not e in ignorevars and not e in tplvars: tplvars.append(e) if nested and nestlevels >= maxnestlevels: raise Exception("Maximum template nesting depth of {} reached in template {}".format(maxnestlevels, template)) else: nestlevels += 1 if sort: return sorted(tplvars) else: return tplvars
def gen_from_template(template, directory, defaults_path, no_prompt): """Generate the new file from a template.""" loader = PackageLoader("templar") template = osp.split(template)[-1] if template not in loader.list_templates(): loader = FileSystemLoader(directory) if template not in loader.list_templates(): raise RuntimeError("Template {} not found!".format(template)) env = Environment(loader=loader) output = env.get_template(template) defaults = load_defaults(defaults_path) try: defaults = defaults[template] except KeyError: defaults = defaults["DEFAULT"] parsed = env.parse(env.loader.get_source(env, template)[0]) variables = meta.find_undeclared_variables(parsed) kwargs = {} if no_prompt: for var in defaults: if var in defaults: default = defaults[var] else: default = "" kwargs[var] = default else: for var in variables: if var in defaults: default = defaults[var] prompt = var + " [{}]: ".format(default) else: prompt = var + ": " default = None resp = input(prompt).strip() if resp == "" and default is not None: resp = default kwargs[var] = resp result = output.render(**kwargs) print(result) return result
def convert(): dummy_values = [ 'Lorem', 'Ipsum', 'Amet', 'Elit', 'Expositum', 'Dissimile', 'Superiori', 'Laboro', 'Torquate', 'sunt', ] # Check if template have no errors try: tpl = Template(request.form['template']) except (exceptions.TemplateSyntaxError, exceptions.TemplateError) as e: return "Syntax error in jinja2 template: {0}".format(e) values = {} if bool(int(request.form['dummyvalues'])): # List variables (introspection) env = Environment() vars_to_fill = meta.find_undeclared_variables(env.parse(request.form['template'])) for v in vars_to_fill: values[v] = choice(dummy_values) else: # Check JSON for errors if request.form['input_type'] == "json": try: values = json.loads(request.form['values']) except ValueError as e: return "Value error in JSON: {0}".format(e) # Check YAML for errors elif request.form['input_type'] == "yaml": try: values = yaml.load(request.form['values']) except (ValueError, yaml.parser.ParserError, TypeError) as e: return "Value error in YAML: {0}".format(e) else: return "Undefined input_type: {0}".format(request.form['input_type']) # If ve have empty var array or other errors we need to catch it and show try: rendered_tpl = tpl.render(values) except (ValueError, TypeError) as e: return "Error in your values input filed: {0}".format(e) if bool(int(request.form['showwhitespaces'])): # Replace whitespaces with a visible character (will be grayed with javascript) rendered_tpl = rendered_tpl.replace(' ', u'•') return rendered_tpl.replace('\n', '<br />')
def playbook(): if 'logged_in' not in session or session['logged_in']!= True: return redirect(url_for('index')) playbook= request.args['playbook'] with open('playbooks/%s' % playbook, 'r') as f: playscript= f.read() from hosts import get_hosts hosts=get_hosts() from jinja2 import Environment, PackageLoader, meta env= Environment(loader= PackageLoader('playbooks','')) template_source= env.loader.get_source(env, playbook)[0] parsed_content= env.parse(template_source) extra_vars= meta.find_undeclared_variables(parsed_content) return render_template('playbook.html', playbook= playbook, playscript= playscript, hosts=hosts, extra_vars= extra_vars)
def find_referenced_templates(template, search_path): """ Returns a list of files which can be either {% imported %}, {% extended %} or {% included %} within a template. """ from jinja2 import Environment, meta env = Environment() ast = env.parse(template.read()) referenced_templates = list(meta.find_referenced_templates(ast)) def realpath(tpl): for path in search_path: t = os.path.realpath(os.path.join(path, tpl)) if os.path.isfile(t): return t return None return [realpath(t) for t in referenced_templates if t is not None]
def choose_template_from_url(self, url): env = Environment() ast = env.parse('{% include "dist/styles/guitartuner-core.css" %}') print list(meta.find_referenced_templates(ast)) print os.path.dirname(__file__) deeplink_class = '' if (url != '/'): deeplink_class = 'app-deeplink' return { 'path': 'dist/index.html', 'data': { 'deeplink_class': deeplink_class } }
def get_variables(themesroot, themename, tplname): ignore = [ 'AUTHOR', 'SITENAME', 'DISQUS_SITENAME', 'DEFAULT_LANG', 'DEFAULT_PAGINATION', 'FEED_ALL_ATOM', 'FEED_ALL_RSS', 'FEED_DOMAIN', ] tpldir = "%s/%s/templates" % (themesroot, themename) env = Environment(loader=FileSystemLoader(tpldir)) template_source = env.loader.get_source(env, tplname)[0] parsed_content = env.parse(template_source) variables = [] undeclared = meta.find_undeclared_variables(parsed_content) for item in undeclared: if item not in ignore: variables.append(item) return sorted(variables)
def _render(cls, text, context): try: env = Environment(undefined=StrictUndefined) ast = env.parse(text) unexpected = meta.find_undeclared_variables(ast) - context.keys() if unexpected: logbook.warning("Unexpected variables in template: {}. Context: {}, Template: {}", ", ".join(unexpected), context, text) raise errors.MessageTemplateError(_("Unexpected variables in template: {}"), ", ".join(unexpected)) template = Template(text, undefined=StrictUndefined) rendered = template.render(context) return rendered except TemplateSyntaxError as e: logbook.exception("Render template error: {}. Context: {}, template: {}", e.message, context, text) raise errors.MessageTemplateError(_("Template syntax error: {} at line {}.\nText: {}\nContext: {}"), e.message, e.lineno, text, context) except TemplateError as e: logbook.exception("Render template error: {}. Context: {}, template: {}, ", e, context, text) raise errors.MessageTemplateError(_("Error while rendering template: %s") % e.message)
def __init__(self, filename): """ Init object from filename. filenamebase *emonitor/modules/* path: [module]/templates/[filename] :param filename: print.[layout].html """ self.module = filename.split('.')[0] self.filename = '.'.join(filename.split('.')[1:]) self.parameters = [] env = Environment(loader=PackageLoader('emonitor.modules.{}'.format(self.module), 'templates')) if not current_app: from emonitor import app env.filters.update(app.jinja_env.filters) else: env.filters.update(current_app.jinja_env.filters) parsed_content = env.parse(env.loader.get_source(env, self.filename)[0]) parameters = meta.find_undeclared_variables(parsed_content) for p in filter(lambda x: x.startswith('param_'), parameters): self.parameters.append(LayoutParameter(p))
def __init__(self, options): self.options = options self.template = None self.keys = None self.filter = None template_loader = FileSystemLoader(searchpath="/") template_env = Environment(loader=template_loader) if not self.options.format: template_source = \ '[{{ timestamp }}] {{ fields.level }} {{ message }}' else: template_file = path.abspath(self.options.format) template_source = template_env.loader. \ get_source(template_env, template_file)[0] self.keys = meta.find_undeclared_variables( template_env.parse(template_source)) self.template = Template(template_source) if self.options.filter: self.filter = self.options.filter.replace('@', '').split('=')
class Jinja2Template(Template): """ The Jinja2 Template implementation """ def __init__(self, sitepath): super(Jinja2Template, self).__init__(sitepath) def configure(self, site, engine=None): """ Uses the site object to initialize the jinja environment. """ self.site = site self.engine = engine self.preprocessor = (engine.preprocessor if hasattr(engine, 'preprocessor') else None) self.loader = HydeLoader(self.sitepath, site, self.preprocessor) default_extensions = [ IncludeText, Spaceless, Asciidoc, Markdown, restructuredText, Syntax, Reference, Refer, YamlVar, 'jinja2.ext.do', 'jinja2.ext.loopcontrols', 'jinja2.ext.with_' ] defaults = { 'line_statement_prefix': '$$$', 'trim_blocks': True, } settings = dict() settings.update(defaults) settings['extensions'] = list() settings['extensions'].extend(default_extensions) conf = {} try: conf = attrgetter('config.jinja2')(site).to_dict() except AttributeError: pass settings.update( dict([(key, conf[key]) for key in defaults if key in conf])) extensions = conf.get('extensions', []) if isinstance(extensions, list): settings['extensions'].extend(extensions) else: settings['extensions'].append(extensions) self.env = Environment( loader=self.loader, undefined=SilentUndefined, line_statement_prefix=settings['line_statement_prefix'], trim_blocks=True, bytecode_cache=FileSystemBytecodeCache(), extensions=settings['extensions']) self.env.globals['media_url'] = media_url self.env.globals['content_url'] = content_url self.env.globals['full_url'] = full_url self.env.globals['engine'] = engine self.env.globals['deps'] = {} self.env.filters['urlencode'] = urlencode self.env.filters['urldecode'] = urldecode self.env.filters['asciidoc'] = asciidoc self.env.filters['markdown'] = markdown self.env.filters['restructuredtext'] = restructuredtext self.env.filters['syntax'] = syntax self.env.filters['date_format'] = date_format self.env.filters['xmldatetime'] = xmldatetime self.env.filters['islice'] = islice self.env.filters['top'] = top config = {} if hasattr(site, 'config'): config = site.config self.env.extend(config=config) try: from typogrify.templatetags import jinja2_filters except ImportError: jinja2_filters = False if jinja2_filters: jinja2_filters.register(self.env) def clear_caches(self): """ Clear all caches to prepare for regeneration """ if self.env.bytecode_cache: self.env.bytecode_cache.clear() def get_dependencies(self, path): """ Finds dependencies hierarchically based on the included files. """ text = self.env.loader.get_source(self.env, path)[0] from jinja2.meta import find_referenced_templates try: ast = self.env.parse(text) except: logger.error("Error parsing[%s]" % path) raise tpls = find_referenced_templates(ast) deps = list(self.env.globals['deps'].get('path', [])) for dep in tpls: deps.append(dep) if dep: deps.extend(self.get_dependencies(dep)) return list(set(deps)) @property def exception_class(self): """ The exception to throw. Used by plugins. """ return TemplateError @property def patterns(self): """ The pattern for matching selected template statements. """ return { "block_open": '\s*\{\%\s*block\s*([^\s]+)\s*\%\}', "block_close": '\s*\{\%\s*endblock\s*([^\s]*)\s*\%\}', "include": '\s*\{\%\s*include\s*(?:\'|\")(.+?\.[^.]*)(?:\'|\")\s*\%\}', "extends": '\s*\{\%\s*extends\s*(?:\'|\")(.+?\.[^.]*)(?:\'|\")\s*\%\}' } def get_include_statement(self, path_to_include): """ Returns an include statement for the current template, given the path to include. """ return '{%% include \'%s\' %%}' % path_to_include def get_extends_statement(self, path_to_extend): """ Returns an extends statement for the current template, given the path to extend. """ return '{%% extends \'%s\' %%}' % path_to_extend def get_open_tag(self, tag, params): """ Returns an open tag statement. """ return '{%% %s %s %%}' % (tag, params) def get_close_tag(self, tag, params): """ Returns an open tag statement. """ return '{%% end%s %%}' % tag def get_content_url_statement(self, url): """ Returns the content url statement. """ return '{{ content_url(\'%s\') }}' % url def get_media_url_statement(self, url): """ Returns the media url statement. """ return '{{ media_url(\'%s\') }}' % url def get_full_url_statement(self, url): """ Returns the full url statement. """ return '{{ full_url(\'%s\') }}' % url def render_resource(self, resource, context): """ Renders the given resource using the context """ try: template = self.env.get_template(resource.relative_path) out = template.render(context) except: out = "" logger.debug(self.env.loader.get_source( self.env, resource.relative_path)) raise return out def render(self, text, context): """ Renders the given text using the context """ template = self.env.from_string(text) return template.render(context)
def get_inputs(content): env = Environment(trim_blocks=True, lstrip_blocks=True) jinja_globals = env.globals.keys() ast = env.parse(content) return meta.find_undeclared_variables(ast) - set(jinja_globals)