def get_hbs(self, source, obj):
compiler = Compiler()
base_template = compiler.compile(
u'<!DOCTYPE html><html lang="es">{{> head}}<body><div>{{> nav}}<div>{{> content}}</div></div>{{> footer}}</body></html>'
)
head = compiler.compile(
get_template("_head_organizations.html").render(obj))
footer = compiler.compile(get_template("_footer.html").render({}))
content_template = compiler.compile(source)
nav = compiler.compile(get_template("_navbar.html").render(obj))
def _proposal_card_renderer(proposal, *args, **kwargs):
context = copy.copy(obj)
request = context['view'].request
context['proposal'] = proposal.get('this')
return get_template(
"popular_proposal/popular_proposal_card.html").render(
context, request)
everything = base_template(
obj,
partials={
"content": content_template,
"head": head,
"nav": nav,
"footer": footer
},
helpers={"proposal_card_renderer": _proposal_card_renderer})
return everything
def generate_page(data):
compiler = Compiler()
source = u"{{>header}}{{#list programs}}{{fileName}}{{lineCount}}{{/list}}"
template = compiler.compile(source)
def _list(this, options, items):
result = [u"<ul>"]
for thing in items:
result.append(u"<li>")
result.append(u'Source File:<a href="' + thing["fileName"] + '">' + thing["fileName"] + "</a>")
result.append(u" - " + str(thing["lineCount"]) + " lines without comments or blank lines")
result.append(u"</li>")
result.append(u"</ul>")
return result
helpers = {"list": _list}
# Add partials
header = compiler.compile(u"<h1>Programs</h1>")
partials = {"header": header}
output = template(data, helpers=helpers, partials=partials)
open("index.html", "wb").write(output)
def compile_template(template_dict, template_name):
"""Compile template."""
compiler = Compiler()
partials = {
name: compiler.compile(template)
for name, template in template_dict.items() if name != template_name
}
compiled = compiler.compile(template_dict[template_name])
return compiled, partials
def render(source, context, helpers=None, partials=None, knownHelpers=None, knownHelpersOnly=False):
compiler = Compiler()
template = compiler.compile(source)
# For real use, partials is a dict of compiled templates; but for testing
# we compile just-in-time.
if not partials:
real_partials = None
else:
real_partials = dict((key, compiler.compile(value)) for key, value in list(partials.items()))
return str_class(template(context, helpers=helpers, partials=real_partials))
def render_from_file(template_file, variables):
"""Render from template string with interpolated variables."""
compiler = Compiler()
partials = {
f.stem: compiler.compile(f.read_text())
for f in template_file.parent.glob("*.hbs")
}
source = template_file.read_text()
template = compiler.compile(source, path=str(template_file.parent))
return template(variables, partials=partials)
def render_content(self, data, content):
bars = Compiler()
content = bars.compile(self._clean_content(content))
# need to render partials
partials = {}
for key, val in self._raw_partials.items():
partials[key] = bars.compile(self._clean_content(val))
return content(data, helpers=self._meta.helpers, partials=partials)
def render_content(self, data, content):
bars = Compiler()
content = bars.compile(self._clean_content(content))
# need to render partials
partials = {}
for key, val in self._raw_partials.items():
partials[key] = bars.compile(self._clean_content(val))
return content(data, helpers=self._meta.helpers, partials=partials)
def render(source, context, helpers=None, partials=None, knownHelpers=None,
knownHelpersOnly=False):
compiler = Compiler()
template = compiler.compile(source)
# For real use, partials is a dict of compiled templates; but for testing
# we compile just-in-time.
if not partials:
real_partials = None
else:
real_partials = dict((key, compiler.compile(value))
for key, value in list(partials.items()))
return str_class(template(context, helpers=helpers, partials=real_partials))
def blog_post(request, post_id):
context = dict()
r = requests.get('{0}/posts?api_key={1}&id={2}'.format(settings.TUMBLR_API_URL,
settings.TUMBLR_API_KEY, post_id))
if r.status_code == 200:
post_response = r.json.get('response', {})
posts = post_response.get('posts', [])
if posts:
post = posts[0]
f_date = datetime.strptime(post['date'], '%Y-%m-%d %H:%M:%S %Z')
post['formated_date'] = f_date.strftime('%B %d, %Y')
if settings.DISQUS_INTEGRATION_ENABLED:
post['disqus_enabled'] = True
path_to_here = os.path.abspath(os.path.dirname(__file__))
f = open('{0}/static/templates/blog-post-{1}.html'.format(path_to_here, post['type']), 'r')
f_data = f.read()
f.close()
compiler = Compiler()
template = compiler.compile(unicode(f_data))
context['post_data'] = template(post)
context['post_title'] = post.get('title', '')
return render(request, 'blog-post.html', context)
def handlebars_dynamic_load(package, name):
""" Dynamically compile a Handlebars template.
NOTE: This will do nothing in production mode!
"""
if not App.is_dev_server:
return None
combined_name = "%s_%s" % (package, name)
if combined_name in handlebars_partials:
handlebars_partials[combined_name]
logging.info("Dynamically loading %s-package/%s.handlebars." %
(package, name))
file_name = "clienttemplates/%s-package/%s.handlebars" % (package, name)
in_file = open(file_name, 'r')
source = unicode(in_file.read())
# HACK: Pybars doesn't handle {{else}} for some reason
source = source.replace("{{else}}", "{{^}}")
matches = re.search('{{>[\s]*([\w\-_]+)[\s]*}}', source)
if matches:
for partial in matches.groups():
(partial_package, partial_name) = partial.split("_")
handlebars_dynamic_load(partial_package, partial_name)
compiler = Compiler()
function = compiler.compile(source)
handlebars_partials[combined_name] = function
return function
def compileHandlebar(path, appName, paramPath=""):
compiler = Compiler()
source = ""
templatePath = os.path.join(path, "templates/" + appName + "/src/config.py.hbs")
with open(templatePath, 'r') as myfile:
data=myfile.read()
template = compiler.compile(data)
if paramPath == "":
paramPath = os.path.join(path, "parameters.json")
with open(paramPath, 'r') as parameterJson:
#check if template is filled with actual data
content = json.load(parameterJson)
for key,value in content.items():
for kkey, vvalue in value.items():
if "<" in vvalue or ">" in vvalue:
raise ValueError ("The chosen param file does not contain all needed values.")
appContent = content[appName]
output = template(appContent)
return output.lower()
def search_string(self):
""""
Returns the JSON string that LendingClub expects for it's search
"""
self.__normalize()
# Get the template
tmpl_source = str(open(self.tmpl_file).read())
# Process template
compiler = Compiler()
template = compiler.compile(tmpl_source)
out = template(self)
if not out:
return False
out = ''.join(out)
#
# Cleanup output and remove all extra space
#
# remove extra spaces
out = re.sub('\n', '', out)
out = re.sub('\s{3,}', ' ', out)
# Remove hanging commas i.e: [1, 2,]
out = re.sub(',\s*([}\\]])', '\\1', out)
# Space between brackets i.e: ], [
out = re.sub('([{\\[}\\]])(,?)\s*([{\\[}\\]])', '\\1\\2\\3', out)
# Cleanup spaces around [, {, }, ], : and , characters
out = re.sub('\s*([{\\[\\]}:,])\s*', '\\1', out)
return out
def _compile_template(swagger_template_file, template_params):
compiler = Compiler()
with codecs.open(swagger_template_file, 'r', 'utf-8') as f:
template_file = f.read()
template = compiler.compile(template_file)
filled_template = template(template_params)
return filled_template
def compileHandlebar(path, appName, paramPath=""):
compiler = Compiler()
source = ""
templatePath = os.path.join(path,
"templates/" + appName + "/src/config.py.hbs")
with open(templatePath, 'r') as myfile:
data = myfile.read()
template = compiler.compile(data)
if paramPath == "":
paramPath = os.path.join(path, "parameters.json")
with open(paramPath, 'r') as parameterJson:
#check if template is filled with actual data
content = json.load(parameterJson)
for key, value in content.items():
for kkey, vvalue in value.items():
if "<" in vvalue or ">" in vvalue:
raise ValueError(
"The chosen param file does not contain all needed values."
)
appContent = content[appName]
output = template(appContent)
return output.lower()
def create_and_save_doc(document_data, index_html, output_pdf):
"""
Creates a PDF invoice by filling an HTML template with a YML file.
Parameters
----------
document_data : dict
Data to use for filling the HTML template.
index_html : str
Absolute path to html template file.
output_pdf : str
Name of the output PDF file.
Returns
-------
Saves the output PDF to output/ directory
"""
pos_number = 1
document_data['totals'] = {'net': 0, 'gross': 0, 'tax': 0}
for pos in document_data['positions']:
if not 'tax_rate' in pos:
pos['tax_rate'] = document_data['tax_rate']
pos['pos_number'] = pos_number
pos['total_net_price'] = pos['net_price'] * pos['amount']
pos['total_tax'] = \
pos['total_net_price'] * (pos['tax_rate'] / float(100))
pos['total_gross_price'] = pos['total_net_price'] + pos['total_tax']
document_data['totals']['net'] += pos['total_net_price']
document_data['totals']['gross'] += pos['total_gross_price']
document_data['totals']['tax'] += pos['total_tax']
pos['amount'] = locale.format_string("%.2f", pos['amount'])
pos['tax_rate'] = locale.format_string("%.2f", pos['tax_rate'])
pos['net_price'] = locale.format_string("%.2f", pos['net_price'])
pos['total_net_price'] = \
locale.format_string("%.2f", pos['total_net_price'])
pos['text'] = pos['text'].replace('\n', '<br>')
pos_number += 1
document_data['totals']['net'] = \
locale.format_string("%.2f", document_data['totals']['net'])
document_data['totals']['gross'] = \
locale.format_string("%.2f", document_data['totals']['gross'])
document_data['totals']['tax'] = \
locale.format_string("%.2f", document_data['totals']['tax'])
with codecs.open(index_html, encoding="utf-8") as index_file:
html_text = index_file.read()
compiler = Compiler()
template = compiler.compile(html_text)
html_text = template(document_data)
weasytemplate = HTML(string=html_text)
weasytemplate.write_pdf(os.path.join('/app', 'output', output_pdf))
return
def handlebars_dynamic_load(package, name):
""" Dynamically compile a Handlebars template.
NOTE: This will do nothing in production mode!
"""
if not App.is_dev_server:
return None
combined_name = "%s_%s" % (package, name)
if combined_name in handlebars_partials:
handlebars_partials[combined_name]
logging.info("Dynamically loading %s-package/%s.handlebars."
% (package, name))
file_name = "clienttemplates/%s-package/%s.handlebars" % (package, name)
in_file = open(file_name, 'r')
source = unicode(in_file.read())
# HACK: Pybars doesn't handle {{else}} for some reason
source = source.replace("{{else}}", "{{^}}")
matches = re.search('{{>[\s]*([\w\-_]+)[\s]*}}', source)
if matches:
for partial in matches.groups():
(partial_package, partial_name) = partial.split("_")
handlebars_dynamic_load(partial_package, partial_name)
compiler = Compiler()
function = compiler.compile(source)
handlebars_partials[combined_name] = function
return function
def test_smoke(self):
compiler = Compiler()
def _list(this, options, items):
result = ['<ul>']
for thing in items:
result.append('<li>')
result.extend(options['fn'](thing))
result.append('</li>')
result.append('</ul>')
return result
source = u"{{#list people}}{{firstName}} {{lastName}}{{/list}}"
template = compiler.compile(source)
context = {
'people': [{
'firstName': "Yehuda",
'lastName': "Katz"
}, {
'firstName': "Carl",
'lastName': "Lerche"
}, {
'firstName': "Alan",
'lastName': "Johnson"
}]
}
rendered = template(context, helpers={u'list': _list})
self.assertEqual(
u"<ul><li>Yehuda Katz</li><li>Carl Lerche</li>"\
"<li>Alan Johnson</li></ul>",
str_class(rendered))
def test_smoke(self):
compiler = Compiler()
def _list(this, options, items):
result = ["<ul>"]
for thing in items:
result.append("<li>")
result.extend(options["fn"](thing))
result.append("</li>")
result.append("</ul>")
return result
source = u"{{#list people}}{{firstName}} {{lastName}}{{/list}}"
template = compiler.compile(source)
context = {
"people": [
{"firstName": "Yehuda", "lastName": "Katz"},
{"firstName": "Carl", "lastName": "Lerche"},
{"firstName": "Alan", "lastName": "Johnson"},
]
}
rendered = template(context, helpers={u"list": _list})
self.assertEqual(
u"<ul><li>Yehuda Katz</li><li>Carl Lerche</li>" "<li>Alan Johnson</li></ul>", str_class(rendered)
)
def blog_post(request, post_id):
context = dict()
r = requests.get('{0}/posts?api_key={1}&id={2}'.format(
settings.TUMBLR_API_URL, settings.TUMBLR_API_KEY, post_id))
if r.status_code == 200:
post_response = r.json.get('response', {})
posts = post_response.get('posts', [])
if posts:
post = posts[0]
f_date = datetime.strptime(post['date'], '%Y-%m-%d %H:%M:%S %Z')
post['formated_date'] = f_date.strftime('%B %d, %Y')
path_to_here = os.path.abspath(os.path.dirname(__file__))
f = open(
'{0}/static/templates/blog-post-{1}.html'.format(
path_to_here, post['type']), 'r')
f_data = f.read()
f.close()
compiler = Compiler()
template = compiler.compile(unicode(f_data))
context['post_data'] = template(post)
context['post_title'] = post['title']
return render(request, 'blog-post.html', context)
def blog_post(request, post_id):
context = dict()
r = requests.get('{0}/posts?api_key={1}&id={2}'.format(
settings.TUMBLR_API_URL, settings.TUMBLR_API_KEY, post_id))
if r.status_code == 200:
post_response = r.json.get('response', {})
posts = post_response.get('posts', [])
if posts:
post = posts[0]
f_date = datetime.strptime(post['date'], '%Y-%m-%d %H:%M:%S %Z')
post['formated_date'] = f_date.strftime('%B %d, %Y')
if settings.DISQUS_INTEGRATION_ENABLED:
post['disqus_enabled'] = True
path = '{0}/static/templates/blog-post-{1}.html'.format(
os.path.join(os.path.dirname(__file__), '..'), post['type'])
with open(path, 'r') as f:
f_data = f.read()
compiler = Compiler()
template = compiler.compile(unicode(f_data))
context['post_data'] = template(post)
context['post_title'] = post.get('title', None)
return render(request, 'blog-post.html', context)
def blog_post(request, post_id):
context = dict()
r = requests.get("{0}/posts?api_key={1}&id={2}".format(settings.TUMBLR_API_URL, settings.TUMBLR_API_KEY, post_id))
if r.status_code == 200:
post_response = r.json.get("response", {})
posts = post_response.get("posts", [])
if posts:
post = posts[0]
f_date = datetime.strptime(post["date"], "%Y-%m-%d %H:%M:%S %Z")
post["formated_date"] = f_date.strftime("%B %d, %Y")
path_to_here = os.path.abspath(os.path.dirname(__file__))
f = open("{0}/static/templates/blog-post-{1}.html".format(path_to_here, post["type"]), "r")
f_data = f.read()
f.close()
compiler = Compiler()
template = compiler.compile(unicode(f_data))
context["post_data"] = template(post)
context["post_title"] = post["title"]
return render(request, "blog-post.html", context)
def search_string(self):
""""
Returns the JSON string that LendingClub expects for it's search
"""
self.__normalize()
# Get the template
tmpl_source = unicode(open(self.tmpl_file).read())
# Process template
compiler = Compiler()
template = compiler.compile(tmpl_source)
out = template(self)
if not out:
return False
out = ''.join(out)
#
# Cleanup output and remove all extra space
#
# remove extra spaces
out = re.sub('\n', '', out)
out = re.sub('\s{3,}', ' ', out)
# Remove hanging commas i.e: [1, 2,]
out = re.sub(',\s*([}\\]])', '\\1', out)
# Space between brackets i.e: ], [
out = re.sub('([{\\[}\\]])(,?)\s*([{\\[}\\]])', '\\1\\2\\3', out)
# Cleanup spaces around [, {, }, ], : and , characters
out = re.sub('\s*([{\\[\\]}:,])\s*', '\\1', out)
return out
def blog_post(request, post_id):
if settings.BLOG_PLATFORM == 'tumblr':
r = requests.get('{0}/posts?api_key={1}&id={2}'.format(
settings.TUMBLR_API_URL, settings.TUMBLR_API_KEY, post_id))
if r.status_code == 200:
post_response = r.json().get('response', {})
posts = post_response.get('posts', [])
if posts:
post = posts[0]
f_date = datetime.strptime(post['date'],
'%Y-%m-%d %H:%M:%S %Z')
post['formated_date'] = f_date.strftime('%B %d, %Y')
elif settings.BLOG_PLATFORM == 'wordpress':
r = requests.get('{0}/posts/{1}'.format(settings.WORDPRESS_API_URL,
post_id))
if r.status_code == 200:
# Get Wordpress response into the same format as Tumblr so we can
# reuse Handlebars template
post = r.json()
convertWordpressResponse(post)
# At this point we should have a post dict from either Tumblr or Wordpress
post['disqus_enabled'] = settings.DISQUS_INTEGRATION_ENABLED
if settings.SHARETHIS_PUBLISHER_KEY:
post['sharethis_enabled'] = True
path = '{0}/static/templates/blog-post-{1}.html'.format(
os.path.join(os.path.dirname(__file__), '..'), post['type'])
with open(path, 'r') as f:
f_data = f.read()
compiler = Compiler()
template = compiler.compile(unicode(f_data))
context = dict()
context['post_data'] = template(post)
alt_title = ''
if (post['type'] == 'photo' or post['type'] == 'video'):
alt_title = '{0}: {1}'.format(post['type'].capitalize(),
post['caption'][3:-4])
elif (post['type'] == 'quote'):
alt_title = '{0}: {1}'.format(post['type'].capitalize(), post['text'])
elif (post['type'] == 'audio'):
alt_title = '{0}: {1} - {2}'.format(post['type'].capitalize(),
post['artist'], post['track_name'])
context['post_title'] = post.get('title', unescape(alt_title))
if post['type'] == 'text' and post['body']:
context['meta_description'] = strip_tags(post['body'])[:150]
if post['tags']:
context['meta_keywords'] = ', '.join(post['tags'])
return render(request, 'blog-post.html', context)
def applySwap(KeyPairs, File): Template_File = open(File, 'r') with Template_File: source = Template_File.read() compiler = Compiler() template = compiler.compile(source) Swapped = template(KeyPairs) return Swapped
def test_compile_with_path(self):
template = u"Hi {{name}}!"
context = {
'name': 'Ahmed'
}
result = u"Hi Ahmed!"
path = '/project/widgets/templates'
compiler = Compiler()
# compile and check that speficified path is used
self.assertEqual(result, compiler.compile(template, path=path)(context))
self.assertTrue(sys.modules.get('pybars._templates._project_widgets_templates') is not None)
# recompile and check that a new path is used
self.assertEqual(result, compiler.compile(template, path=path)(context))
self.assertTrue(sys.modules.get('pybars._templates._project_widgets_templates_1') is not None)
def test_process_templates(self):
config = "{{#if A}}{{B}}{{/if}}"
values = {"A": "true", "B": "XYZ"}
compiler = Compiler()
template = compiler.compile(config)
assert "XYZ" == template(values)
def analyseAndRender(dataLocation, templateLocation, optionsLocation=""):
global df
if optionsLocation != "":
with open(optionsLocation) as json_file:
options = json.load(json_file)
# For local csv
if ".csv" in dataLocation and "https://docs.google.com" not in dataLocation:
df = _makeDataFrame(dataLocation)
# For google sheets as csv
elif "https://docs.google.com" in dataLocation:
print("It's a google sheet")
# If its already a dataframe
else:
df = dataLocation
with io.open(templateLocation, 'r', encoding='utf-8') as tempSource:
compiler = Compiler()
template = compiler.compile(tempSource.read())
helpers = {
"getCellByNumber": getCellByNumber,
"getCellByLabel": getCellByLabel,
"checkDifferenceBetweenValues": checkDifferenceBetweenValues,
"checkAgainstRollingMean": checkAgainstRollingMean,
"getRollingMean": getRollingMean,
"getDifference": getDifference,
"sortAscending": sortAscending,
"sortDescending": sortDescending,
"getRankedItemDescending": getRankedItemDescending,
"sumAcrossAllCols": sumAcrossAllCols,
"totalSumOfAllCols": totalSumOfAllCols,
"formatNumber": formatNumber,
"groupBy": groupBy,
"groupByTime": groupByTime,
"filterBy": filterBy,
"summariseCol": summariseCol,
"checkDifferenceBetweenResults": checkDifferenceBetweenResults,
"uniqueValues": uniqueValues,
"summariseColByTimePeriod": summariseColByTimePeriod,
"makeList": makeList
}
output = template(df, helpers=helpers)
# String replacements
if optionsLocation != "":
if 'replacements' in options:
output = _replaceStrings(options['replacements'], output)
# print(output.encode('utf-8'))
return output
def timeline_template():
"""Returns a compiled handlebars template (as a function),
which can be called on an input data object to produce HTML
"""
compiler = Compiler()
with open("timeline_view.handlebars", "r", encoding="utf8") as f:
raw_template = f.read()
template = compiler.compile(raw_template)
return template
def _initTemplate(self):
#
# Load the template
#
self.config.logger.info("Reading template file 'email_html_template.mustache'...")
f = codecs.open("email_html_template.mustache", encoding='utf-8', mode='rb')
strtempl = f.read()
f.close()
#
# Compile the template
#
from pybars import Compiler
compiler = Compiler()
self.html_full_results_template = compiler.compile(strtempl)
self.email_html_template = compiler.compile(strtempl)
def blog_post(request, post_id):
if settings.BLOG_PLATFORM == 'tumblr':
r = requests.get('{0}/posts?api_key={1}&id={2}'.format(
settings.TUMBLR_API_URL, settings.TUMBLR_API_KEY, post_id))
if r.status_code == 200:
post_response = r.json().get('response', {})
posts = post_response.get('posts', [])
if posts:
post = posts[0]
f_date = datetime.strptime(post['date'], '%Y-%m-%d %H:%M:%S %Z')
post['formated_date'] = f_date.strftime('%B %d, %Y')
elif settings.BLOG_PLATFORM == 'wordpress':
r = requests.get('{0}/posts/{1}'.format(
settings.WORDPRESS_API_URL, post_id))
if r.status_code == 200:
# Get Wordpress response into the same format as Tumblr so we can
# reuse Handlebars template
post = r.json()
convertWordpressResponse(post)
# At this point we should have a post dict from either Tumblr or Wordpress
post['disqus_enabled'] = settings.DISQUS_INTEGRATION_ENABLED
if settings.SHARETHIS_PUBLISHER_KEY:
post['sharethis_enabled'] = True
path = '{0}/static/templates/blog-post-{1}.html'.format(
os.path.join(os.path.dirname(__file__), '..'), post['type'])
with open(path, 'r') as f:
f_data = f.read()
compiler = Compiler()
template = compiler.compile(unicode(f_data))
context = dict()
context['post_data'] = template(post)
alt_title = ''
if (post['type'] == 'photo' or post['type'] == 'video'):
alt_title = '{0}: {1}'.format(post['type'].capitalize(), post['caption'][3:-4])
elif (post['type'] == 'quote'):
alt_title = '{0}: {1}'.format(post['type'].capitalize(), post['text'])
elif (post['type'] == 'audio'):
alt_title = '{0}: {1} - {2}'.format(post['type'].capitalize(), post['artist'], post['track_name'])
context['post_title'] = post.get('title', unescape(alt_title))
if post['type'] == 'text' and post['body']:
context['meta_description'] = strip_tags(post['body'])[:150]
if post['tags']:
context['meta_keywords'] = ', '.join(post['tags'])
return render(request, 'blog-post.html', context)
def output_pdf(self, pdf_name):
self.prepare_invoice_items()
with codecs.open(self.template, encoding="utf-8") as index_file:
html_text = index_file.read()
compiler = Compiler()
template = compiler.compile(html_text)
html_text = template(self.document_data)
weasytemplate = HTML(string=html_text,
base_url="template/index.html")
weasytemplate.write_pdf(pdf_name)
def map_template(self, *args):
source = self.get_data(args[0]['id'])
# print(source)
abs_file_path = os.path.join(os.path.dirname(__file__),
'../../templates/report.html')
with open(abs_file_path) as data_file:
data = data_file.read()
compiler = Compiler()
template = compiler.compile(data)
output = template(source)
return output
def generate(self, data, templateLocation):
compiler = Compiler()
source = open(templateLocation).read().decode('utf-8')
template = compiler.compile(source)
output = template(data)
parser = etree.XMLParser(remove_blank_text=True)
root = etree.XML(output, parser)
xml_output = etree.tostring(root, pretty_print = True, xml_declaration = True, encoding='UTF-8')
artifactObj = Artifact(xml_output)
return artifactObj
def test_compile_with_path(self):
template = u"Hi {{name}}!"
context = {'name': 'Ahmed'}
result = u"Hi Ahmed!"
path = '/project/widgets/templates'
compiler = Compiler()
# compile and check that speficified path is used
self.assertEqual(result,
compiler.compile(template, path=path)(context))
self.assertTrue(
sys.modules.get('pybars._templates._project_widgets_templates')
is not None)
# recompile and check that a new path is used
self.assertEqual(result,
compiler.compile(template, path=path)(context))
self.assertTrue(
sys.modules.get('pybars._templates._project_widgets_templates_1')
is not None)
def _initTemplate(self):
#
# Load the template
#
self.config.logger.info(
"Reading template file 'email_html_template.mustache'...")
f = codecs.open("email_html_template.mustache",
encoding='utf-8',
mode='rb')
strtempl = f.read()
f.close()
#
# Compile the template
#
from pybars import Compiler
compiler = Compiler()
self.html_full_results_template = compiler.compile(strtempl)
self.email_html_template = compiler.compile(strtempl)
def renderTemplate(templateFileName, nameValueData):
compiler = Compiler()
with codecs.open(templateFileName, encoding='utf-8') as f:
templateString = f.read()
handlebarsTemplate = compiler.compile(templateString)
# remember functionality of helpers and partials
# see https://github.com/wbond/pybars3
from pybarscustom import _equal, _urlify, _languageRadioPartial, _getLanguageTitleInNativeLanguage
helpers = {'equal': _equal, 'urlify': _urlify, 'getLanguageTitle' : _getLanguageTitleInNativeLanguage}
languageRadioPartial = compiler.compile(_languageRadioPartial())
partials = { 'languageRadio' : languageRadioPartial}
render = handlebarsTemplate(nameValueData, helpers = helpers, partials = partials)
return render
class PybarMustacheRemover:
def __init__(self):
self.tmplt_compiler = PybarCompiler()
def clean_template(self, filepath, placeholder):
with open(filepath, 'r') as src_file:
template_content = text_type(src_file.read())
try:
compiled_template = self.tmplt_compiler.compile(template_content)
return compiled_template(PybarPlaceholderContext(placeholder))
except PybarsError as error:
raise_from(
MustacheSubstitutionFail(
'For HTML template file {}: {}'.format(filepath, error)),
error)
def generate(self, data, templateLocation):
compiler = Compiler()
source = open(templateLocation).read().decode('utf-8')
template = compiler.compile(source)
output = template(data)
parser = etree.XMLParser(remove_blank_text=True)
root = etree.XML(output, parser)
xml_output = etree.tostring(root,
pretty_print=True,
xml_declaration=True,
encoding='UTF-8')
artifactObj = Artifact(xml_output)
return artifactObj
def render_post_json(posts,
images_per_row=2,
max_width=512,
template_file='post.hb'):
fb_posts = []
post_idx = 0
for post_id, created_time, message, images, locations, places, tags in posts:
post_idx = post_idx + 1
post_images = []
for i in range(0, len(images)):
image = images[i]
if image.get('src'):
image_url = image['src']
image_url_hash = hashlib.md5(
image_url.encode()).hexdigest()
GhostImporter._resize_image(image)
post_image = {
'filename': image_url_hash,
'width': image['width'],
'height': image['height'],
'src': image_url,
'row': int(i / images_per_row)
}
post_images.append(post_image)
message_lines = [
m for m in message.replace('"', '').splitlines() if m.strip()
] if message else []
fb_post = {
'date': re.sub(" .*", "", created_time),
'message': message_lines,
'has_image': len(post_images) > 0,
'has_locations': locations and len(locations) > 0,
'gallery_idx': post_idx,
'images': post_images,
'locations': ",".join(locations) if locations else None,
'places': places,
'tags': [("with " + ", ".join(tags))] if tags else None
}
fb_posts.append(fb_post)
compiler = Compiler()
template_source = open(template_file, 'r').read()
template = compiler.compile(template_source)
output = template({'fb_posts': fb_posts})
return output
def render(input_file, value_file, output_file, enable_env):
with open(input_file, encoding="utf-8") as inputF:
source = inputF.read()
with open(value_file) as valueF:
values = json.load(valueF)
if enable_env:
for k, v in os.environ.iteritems():
values[k] = v
compiler = Compiler()
template = compiler.compile(source)
output = template(values, helpers={"eq": eq})
with open(output_file, "w+") as outputF:
outputF.write(output)
def __get_compiled_template(self, template_name):
template_path = self.__get_template_path(template_name)
try:
from pybars import Compiler
except ImportError as e:
Compiler = None
logger.debug(str(e))
logger.warning(
"Unable to load pybars; install pybars3 to load profile directly from the current session "
)
with open(template_path, "r") as file_with_template:
source = file_with_template.read()
compiler = Compiler()
template = compiler.compile(source)
return template
def cli(template, source, outputdir, pagename):
outputdir = Path(outputdir)
outputdir.mkdir(parents=True, exist_ok=True)
df = pd.read_csv(source)
compiler = Compiler()
template = compiler.compile(open(template).read())
with open(outputdir / "index.html", "w") as f:
f.write(
template(
{
"data": df,
"dataPerVoltage": {
voltage: dataToTable(
df[df["Input voltage @ V"] == voltage])
for voltage in df["Input voltage @ V"].unique()
},
"pageName": pagename
},
helpers=buildHelpers(outputdir, df)))
def generate_manifests(template_vars: Dict[str, str], dest: Path) -> None:
"""Given template_vars, a dict from template variable name to the value for that variable, recursively find all
files under K8_DIR, expand them as handlebars templates if they have a .tmpl.yml extension, and copy them to the
same relative location in dest. Files found under K8_DIR that do not end with .tmpl.yml are copied unchanged to
dest.
"""
compiler = Compiler()
TEMPLATE_SUFFIX = '.tmpl.yml'
# As we walk cur_dir we'll find additional subdirectories which we'll push here to be explored in later iterations.
to_explore: List[Path] = [K8_DIR.absolute()]
while len(to_explore) > 0:
cur_dir = to_explore.pop().absolute()
log.info('Looking for Kubernetes files and templates in %s', cur_dir)
for file_or_dir in cur_dir.iterdir():
if file_or_dir.is_dir():
to_explore.append(file_or_dir)
else:
dest_file = dest / file_or_dir.absolute().relative_to(
K8_DIR.absolute())
dest_file.parent.mkdir(parents=True, exist_ok=True)
if str(file_or_dir).endswith(TEMPLATE_SUFFIX):
dest_file = dest_file.parent / (
dest_file.name[:-len(TEMPLATE_SUFFIX)] + '.yml')
log.info('Expanding template %s to %s', file_or_dir,
dest_file)
with open(file_or_dir, 'rt', encoding='utf-8') as inf:
contents = inf.read()
template = compiler.compile(contents)
out_contents = template(template_vars)
with open(dest_file, 'wt', encoding='utf-8') as outf:
outf.write(out_contents)
else:
log.info('Copying %s to %s', file_or_dir, dest_file)
shutil.copy(file_or_dir, dest_file)
def run(self, data):
compiler = Compiler()
with open(self.config['template'], 'r') as tmpl:
template = compiler.compile(tmpl.read())
return template({'data': data, 'count': len(data)})
