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 _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)
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)
