def render_string(self, filename, **kwargs):
'''
Override render_string to use mako template.
Like tornado render_string method, this method also
pass request handler environment to template engine
'''
try:
# if not self.is_mobile:
# template = self.LOOK_UP.get_template(filename)
# else:
# template = self.LOOK_UP_MOBILE.get_template(filename)
template = self.LOOK_UP.get_template(filename)
env_kwargs = dict(
handler=self,
request=self.request,
locale=self.locale,
_=self.locale.translate,
static_url=self.static_url,
xsrf_form_html=self.xsrf_form_html,
reverse_url=self.application.reverse_url,
agent=self.agent,
)
env_kwargs.update(kwargs)
return template.render(**env_kwargs)
except:
from mako.exceptions import RichTraceback
tb = RichTraceback()
for (module_name, line_no, function_name, line) in tb.traceback:
print('File:{}, Line:{} in {}'.format(module_name, line_no,
function_name))
print(line)
access_log.error('Render {} failed, {}:{}'.format(
filename, tb.error.__class__.__name__, tb.error),
exc_info=True)
raise HTTPError(500, 'Render page failed')
def render_to_string(self, template=False, values={}):
""" Automatically convert's a template BFORM_TYPE to a named type
if it exists in BFORM_TN """
if not self.templates.has_key(template):
# Messy hack for py 2.4
if type(template) == type(1):
template = "t%d" % template
try:
log.debug("render_to_string translating template %s" %
template)
self.templates[template] = self.lookup.get_template(
"%s.mako" % bform.BFORM_TN[int(template[1:])])
except:
self.templates[template] = self.lookup.get_template(template)
if type(values) != type({}):
raise ValueError(
"render_to_string called with bad arguments (bad dict)")
rendered_template = ""
try:
rendered_template = self.templates[template].render_unicode(
state=self.state, **values)
except:
log.exception(exceptions.text_error_template().render())
traceback = RichTraceback()
for (filename, lineno, function, line) in traceback.traceback:
print "File %s, line %s, in %s" % (filename, lineno, function)
print line, "\n"
print "%s: %s" % (str(
traceback.error.__class__.__name__), traceback.error)
rendered_template = "Error: See log\n"
raise
return rendered_template
def render(self, template_name, **kwargs):
""" Redefine the render """
t = self.lookup.get_template(template_name)
args = dict(
handler=self,
request=self.request,
current_user=self.current_user,
locale=self.locale,
_=self.locale.translate,
static_url=self.static_url,
xsrf_form_html=self.xsrf_form_html,
xsrf_cookie=self.xsrf_cookie,
reverse_url=self.application.reverse_url,
LANGUAGES=self.settings['LANGUAGES'],
STATIC_URL=self.settings['STATIC_URL'],
THEME_URL=self.settings['THEME_URL'],
THEME=self.settings['THEME'],
theme_url=self.theme_url,
#method
htime=htime,
ftime=ftime,
has_permission=self.has_permission,
show_error=show_error,
b2s=b2s,
)
args.update(kwargs)
# We can define keyword in views with initialize()
if hasattr(self, 'view_kwargs'):
args.update(self.view_kwargs)
# TODO: more readable bug track
# http://docs.makotemplates.org/en/latest/usage.html#handling-exceptions
try:
html = t.render(**args)
except:
traceback = RichTraceback()
html = u'''<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<link rel="stylesheet" href="/static/css/mako.css" />
<title>LuoYun Mako Template System Trac Info</title>
</head>
<body>
<h1>LuoYun Mako Template System Trac Info</h1>
<pre>'''
for (filename, lineno, function, line) in traceback.traceback:
html += "File %s, line %s, in %s" % (filename, lineno,
function)
html += "%s\n" % line
html += "%s: %s" % (str(
traceback.error.__class__.__name__), traceback.error)
html += "</pre></body></html>"
self.finish(html)
def render(self, *args, **kwargs):
self.context['makoStartTime'] = time.time()
context = self.context
context.update(kwargs)
# noinspection PyBroadException
try:
if self.test_exception:
raise Exception('This is a test Exception')
return self.template.render_unicode(*args, **context)
except Exception as error:
logger.info(f'A mako error occurred: {error}')
context['title'] = '500'
context['header'] = _('Mako Error')
context['backtrace'] = RichTraceback(error=error)
lookup = TemplateLookup(
directories=[
os.path.join(settings.PROG_DIR,
"gui/" + settings.GUI_NAME + "/views/")
],
strict_undefined=settings.BRANCH
and settings.BRANCH != 'master',
format_exceptions=True,
)
return lookup.get_template('500.mako').render_unicode(
*args, **context)
def render_page(page_info, use_local_sources=False):
try:
if use_local_sources:
package_file = open(page_info.datafile)
package_dict = json.loads(package_file.read())
else:
package_dict = requests.get(url_stem + page_info.datafile).json()
except:
sys.stderr.write("Error reading package JSON info from \"%s\".\n" %
page_info.datafile)
raise
package_dict["generated"] = make_friendlier_datetime(
package_dict["generated"])
page_template = get_mako_template(page_info.template)
# Exception code from: https://docs.makotemplates.org/en/latest/usage.html#handling-exceptions
try:
with open(page_info.output, "w") as f:
f.write(postproc(page_template.render(p=package_dict)))
except:
traceback = RichTraceback()
for (filename, lineno, function, line) in traceback.traceback:
print("File %s, line %s, in %s" % (filename, lineno, function))
print(line, "\n")
print("%s: %s" %
(str(traceback.error.__class__.__name__), traceback.error))
raise
def tcpip(self, interface=None, essid=None, channel=None):
# Define this variable in case wireless configuration information is
# passed into this method.
iwconfigs = ''
# Test to see if the interface argument has been passed. If it hasn't
# then this method is being called from Gateways.wireless(), so
# populate it from the class attribute variable.
if interface is None:
interface = self.interface
# If an ESSID and channel were passed to this method, store them in
# class attributes.
if essid:
self.essid = essid
iwconfigs = '<p>Wireless network configuration:</p>\n'
iwconfigs = iwconfigs + '<p>ESSID: ' + essid + '</p>\n'
if channel:
self.channel = channel
iwconfigs = iwconfigs + '<p>Channel: ' + channel + '</p>\n'
# Run the "Are you sure?" page through the template interpeter.
try:
page = templatelookup.get_template("/gateways/confirm.html")
return page.render(title = "Enable gateway?",
purpose_of_page = "Confirm gateway mode.",
interface = interface, iwconfigs = iwconfigs)
except:
traceback = RichTraceback()
for (filename, lineno, function, line) in traceback.traceback:
print "\n"
print "Error in file %s\n\tline %s\n\tfunction %s" % (filename, lineno, function)
print "Execution died on line %s\n" % line
print "%s: %s" % (str(traceback.error.__class__.__name__),
traceback.error)
def tmpl_out(self, tmpl_fname, **kwargs):
"""
templating shortcut, populated with the default app attributes
"""
# pass the app object
kwargs['app'] = self
# production flag
kwargs['prod'] = (cherrypy.config['server.environment']
== 'production')
tmpl = self.tmpl_lookup.get_template(tmpl_fname)
# Render the template
# If an exception occurs, render an error page showing the traceback
try:
return tmpl.render(**kwargs)
except:
traceback_string = "<h1>IPOL template rendering error</h1>"
traceback_string += "<h2>Template: %s</h2>" % tmpl_fname
traceback_string += "<h2>kwargs: %s</h2>" % kwargs
traceback = RichTraceback()
for (filename, lineno, function, line) in traceback.traceback:
traceback_string += \
"File <b>%s</b>, line <b>%d</b>, in <b>%s</b><br>" % \
(filename, lineno, function)
traceback_string += line + "<br><br>"
traceback_string += "%s: %s" % \
(str(traceback.error.__class__.__name__), \
traceback.error) + "<br>"
return traceback_string
def lineage_report(template, command, time, today, data, report_stem, lineage,
flight_figure, import_report, raw_data_csv):
mytemplate = Template(filename=template)
buf = StringIO()
import_data = parse_import_data(import_report)
raw_data = parse_raw_data(raw_data_csv)
ctx = Context(buf,
command=command,
timestamp=time,
date=today,
version=__version__,
summary_data=data,
lineage_data=[lineage],
flight_figure=flight_figure,
import_report=import_data,
raw_data=raw_data)
try:
mytemplate.render_context(ctx)
except:
traceback = RichTraceback()
for (filename, lineno, function, line) in traceback.traceback:
print("File %s, line %s, in %s" % (filename, lineno, function))
print(line, "\n")
print("%s: %s" %
(str(traceback.error.__class__.__name__), traceback.error))
with open(f"{report_stem}_{lineage}.html", "w") as fw:
fw.write(buf.getvalue())
def render_template(destination, **kwargs):
""" Renders the Mako template, and writes output file to the specified destination.
Args:
destination (Path): Location of the output file.
**kwargs (dict): Variables to be used in the Mako template.
Raises:
ERROR: Error log containing information about the line where the exception occurred.
Exception: Re-raised Exception coming from Mako template.
"""
destination.parent.mkdir(parents=True, exist_ok=True)
with open(str(destination), 'w', newline='\n',
encoding='utf-8') as rst_file:
template = Template(filename=str(TEMPLATE_FILE),
output_encoding='utf-8',
input_encoding='utf-8')
try:
template.render_context(Context(rst_file, **kwargs))
except Exception as exc:
traceback = RichTraceback()
logging.error(
"Exception raised in Mako template, which will be re-raised after logging line info:"
)
logging.error("File %s, line %s, in %s: %r",
*traceback.traceback[-1])
raise exc
def render(self, *args, **kwargs):
self.context["makoStartTime"] = time.time()
context = self.context
context.update(kwargs)
# noinspection PyBroadException
try:
if self.test_exception:
raise Exception("This is a test Exception")
return self.template.render_unicode(*args, **context)
except Exception as error:
logger.info(f"A mako error occurred: {error}")
context["title"] = "500"
context["header"] = _("Mako Error")
context["backtrace"] = RichTraceback(error=error)
lookup = TemplateLookup(
directories=[
os.path.join(settings.PROG_DIR,
"gui/" + settings.GUI_NAME + "/views/")
],
strict_undefined=settings.BRANCH
and settings.BRANCH != "master",
format_exceptions=True,
)
return lookup.get_template("500.mako").render_unicode(
*args, **context)
def render_string(self, template_path, **kwargs):
namespace = dict(
handler=self,
request=self.request,
current_user=self.current_user,
# locale=self.locale,
# _=self.locale.translate,
# pgettext=self.locale.pgettext,
static_url=self.static_url,
xsrf_form_html=self.xsrf_form_html,
reverse_url=self.reverse_url,
# custom
s=lambda x: u"\"{0}\"".format(x),
)
# 如果标题未设置，设置一个默认值
if self.title:
namespace['title'] = self.title
else:
namespace['title'] = settings.DEFAULT_HTML_TITLE
namespace.update(self.data)
namespace.update(kwargs)
try:
html = self.application.template_lookup.get_template(
template_path).render(**namespace)
except:
html = self.application.template_lookup.get_template(
'mako_failed.html').render(traceback=RichTraceback())
return html
def render(self, *args, **kwargs):
"""
Render the Page template
"""
for key in self.arguments:
if key not in kwargs:
kwargs[key] = self.arguments[key]
kwargs['makoStartTime'] = time.time()
try:
return self.template.render_unicode(*args, **kwargs)
except Exception:
kwargs['title'] = '500'
kwargs['header'] = 'Mako Error'
kwargs['backtrace'] = RichTraceback()
for (filename, lineno, function,
_) in kwargs['backtrace'].traceback:
logger.log(
u'File {name}, line {line}, in {func}'.format(
name=filename, line=lineno, func=function),
logger.DEBUG)
logger.log(u'{name}: {error}'.format(
name=kwargs['backtrace'].error.__class__.__name__,
error=kwargs['backtrace'].error))
return get_lookup().get_template('500.mako').render_unicode(
*args, **kwargs)
def addtomesh(self, interface=None):
# Store the name of the network interface and whether or not it's
# enabled in the object's attributes. Right now only the Babel
# protocol is supported, so that's hardcoded for the moment (but it
# could change in later releases).
self.interface = interface
self.protocol = 'babel'
self.enabled = 'no'
# Render the HTML page.
try:
page = templatelookup.get_template("/mesh/addtomesh.html")
return page.render(title="Byzantium Node Mesh Configuration",
purpose_of_page="Enable Mesh Interfaces",
interface=self.interface,
protocol=self.protocol)
except:
traceback = RichTraceback()
for (filename, lineno, function, line) in traceback.traceback:
print "\n"
print "Error in file %s\n\tline %s\n\tfunction %s" % (
filename, lineno, function)
print "Execution died on line %s\n" % line
print "%s: %s" % (str(
traceback.error.__class__.__name__), traceback.error)
def get_populated_label(self, delivery, sender, address, option, kwargs):
zpl_file = self._service
if self._specific_label:
# in this case, you must use a really specific label
# (some 'commerçant' use case)
zpl_file += '_' + self._specific_label
zpl_file += '.mako'
zpl_file_path = os.path.join(os.path.dirname(__file__), 'report',
zpl_file)
with open(zpl_file_path, 'r') as opened_file:
file_content = opened_file.read()
self.validate_mako(file_content, delivery, sender, address, option,
kwargs)
try:
#print 'd', delivery, '\na', address, '\ns', sender, '\no', kwargs
zpl = Template(file_content).render(d=delivery,
s=sender,
a=address,
o=option,
**kwargs)
content = zpl.encode(encoding=CODING, errors=ERROR_BEHAVIOR)
if self._test_name:
self._record_unit_test_datas(content, delivery, sender,
address, option, kwargs)
except:
traceback = RichTraceback()
self.extract_mako_error(traceback, zpl_file)
return content
def __unitTestTraceback():
from mako.exceptions import RichTraceback
traceback = RichTraceback()
print "\n\n-------------START TRACEBACK-------------\n"
for (filename, lineno, function, line) in traceback.traceback:
print "File %s, line %s, in %s" % (filename, lineno, function)
print line
print "%s: %s" % (str(traceback.error.__class__.__name__), traceback.error)
print "\n\n-------------END TRACEBACK---------------\n"
def render(self, context=None, request=None):
"""
Render the template with a given context. Here we're adding
some context variables that are required for all templates in
the system like the statix url and the CSRF tokens, etc.
:param context: It must be a dict if provided
:param request: It must be a django.http.HttpRequest if provided
:return: A rendered template
"""
if context is None:
context = {}
context['static'] = static
context['url'] = self.get_reverse_url()
if request is not None:
# As Django doesn't have a global request object,
# it's useful to put it in the context.
context['request'] = request
# Passing the CSRF token is mandatory.
context['csrf_input'] = csrf_input_lazy(request)
context['csrf_token'] = csrf_token_lazy(request)
try:
return self.template.render(**context)
except Exception as e:
traceback = RichTraceback()
source = traceback.source
if not source:
# There's no template source lines then raise
raise e
source = source.split('\n')
line = traceback.lineno
top = max(0, line - 4)
bottom = min(len(source), line + 5)
source_lines = [(i + 1, source[i]) for i in range(top, bottom)]
e.template_debug = {
'name': traceback.records[5][4],
'message': '{}: {}'.format(traceback.errorname,
traceback.message),
'source_lines': source_lines,
'line': line,
'during': source_lines[line - top - 1][1],
'total': bottom - top,
'bottom': bottom,
'top': top + 1,
# mako's RichTraceback doesn't return column number
'before': '',
'after': '',
}
raise e
def try_generate_page(file_name):
try:
page = content.get_template(file_name)
with codecs.open('/'.join([OUTPUT_FOLDER, file_name]),
encoding=FILE_ENCODING,
mode='w') as output_file:
output_file.write(page.render_unicode())
print "*** Successfully generated page: %s" % (file_name)
except:
traceback = RichTraceback()
print_traceback(traceback)
def wireless(self, interface=None):
# Store the name of the network interface chosen by the user in the
# object's attribute set and then generate the name of the client
# interface.
self.mesh_interface = interface
self.client_interface = interface + ':1'
# Default settings for /network/wireless.html page.
channel = 3
essid = 'Byzantium'
# This is a hidden class attribute setting, used for sanity checking
# later in the configuration process.
self.frequency = frequencies[channel - 1]
# Set up the warning in case the interface is already configured.
warning = ''
# If a network interface is marked as configured in the database, pull
# its settings and insert them into the page rather than displaying the
# defaults.
connection = sqlite3.connect(self.netconfdb)
cursor = connection.cursor()
template = (interface, )
cursor.execute(
"SELECT enabled, channel, essid FROM wireless WHERE mesh_interface=?;",
template)
result = cursor.fetchall()
if result and (result[0][0] == 'yes'):
channel = result[0][1]
essid = result[0][2]
warning = '<p>WARNING: This interface is already configured! Changing it now will break the local mesh! You can hit cancel now without changing anything!</p>'
connection.close()
# The forms in the HTML template do everything here, as well. This
# method only accepts input for use later.
try:
page = templatelookup.get_template("/network/wireless.html")
return page.render(
title="Configure wireless for Byzantium node.",
purpose_of_page="Set wireless network parameters.",
warning=warning,
interface=self.mesh_interface,
channel=channel,
essid=essid)
except:
traceback = RichTraceback()
for (filename, lineno, function, line) in traceback.traceback:
print "\n"
print "Error in file %s\n\tline %s\n\tfunction %s" % (
filename, lineno, function)
print "Execution died on line %s\n" % line
print "%s: %s" % (str(
traceback.error.__class__.__name__), traceback.error)
def write_template_to_string(template_filename, **kwargs):
try:
template = Template(filename=template_filename)
# Split + Join fixes line-endings for whatever platform you are using
return '\n'.join(template.render(**kwargs).splitlines())
except:
traceback = RichTraceback()
for (filename, lineno, function, line) in traceback.traceback:
print("File %s, line %s, in %s" % (filename, lineno, function))
print(line, "\n")
print("%s: %s" % (str(traceback.error.__class__.__name__), traceback.error))
def render(self, renderJobs=None):
""" Does the render.
It goes threw the renderJobs and renders all.
"""
if renderJobs is not None:
self.renderJobs = renderJobs
for k, job in self.renderJobs['jobs'].items():
try:
#
# Render the file. Note, that the output of folowing codes is
# syntatically/semantically correct but hard to read. So post process needed.
#
logging.info(" Start rendering jobs, named: '%s' ...", k)
# fetch render template
mylookup = TemplateLookup(directories=[resourcepath])
mytemplate = mylookup.get_template(job['templateFile'])
# DO the RENDER
generated_code = mytemplate.render(
lic=MIT_LICENSE,
commondata = self.renderJobs['common'],
renderdata = job['renderdata']
)
#
# Beautifier
# Make more readable the output file.
#
logging.info(" Start beautifier ...")
# Fetch beautifier parameters:
indentUnit=self.renderJobs['common']['indentUnit']
beautifierFunc = job['beautifierFunc']
method_to_call = getattr(sys.modules[__name__], beautifierFunc)
# BEAUTIFY:
generated_code = method_to_call(generated_code, indentUnit=indentUnit)
# save file:
outdir=self.db['configuration']['hdl']['rtlPath']
os.makedirs(outdir, exist_ok=True)
filename = job['outFilename']
outfile = os.path.abspath(os.path.join(outdir, filename))
logging.info(" Saving file to %s ...", outfile)
with open(outfile, 'w', newline='\n') as f:
f.write('\n'.join(generated_code))
except:
traceback = RichTraceback()
for (filename, lineno, function, line) in traceback.traceback:
print("File %s, line %s, in %s" % (filename, lineno, function))
print(line, "\n")
print("%s: %s" % (str(traceback.error.__class__.__name__), traceback.error))
def apply_template(self, source):
if self.template_encoding != 'ascii':
source = unicode(source, self.template_encoding)
try:
return self.template.render(jsliteral=jsliteral, source=source)
except Exception, err:
traceback = RichTraceback()
for (filename, lineno, function, line) in traceback.traceback:
print "File %s, line %s, in %s" % (filename, lineno, function)
print line, "\n"
print "%s: %s" % (str(traceback.error.__class__.__name__), traceback.error)
print
raise err
def generate_template(template_name,
template_params,
dest_file,
in_zip_file=False):
try:
module_name = template_params['metadata'].config['module_name']
lookup = TemplateLookup(directories=[
'build/templates', 'src/{0}/templates'.format(module_name)
])
template = Template(filename=template_name, lookup=lookup)
rendered_template = template.render(
template_parameters=template_params)
except Exception:
# Because mako expands into python, we catch all errors, not just MakoException.
# Ideally, we'd use text_error_template, but it sucks. html_error_template,
# however, is useful. Unfortunately emitting html isn't acceptable. So we
# re-implement using mako.exceptions.RichTraceback here.
tback = RichTraceback(traceback=None)
line = tback.lineno
lines = tback.source.split('\n')
# The underlying error.
logging.error("\n%s: %s\n" %
(str(tback.error.__class__.__name__), str(tback.error)))
logging.error("Offending Template: %s\n" % template_name)
# Show a source listing of the template, with offending line marked.
for index in range(max(0, line - 4), min(len(lines), line + 5)):
if index + 1 == line:
logging.error(">> %#08d: %s" % (index + 1, lines[index]))
else:
logging.error(" %08d: %s" % (index + 1, lines[index]))
logging.error("\nTraceback (most recent call last):")
for (filename, lineno, function, line) in tback.reverse_traceback:
logging.error(" File %s, line %d, in %s\n %s" %
(filename, lineno, function, line))
logging.error("\n")
sys.exit(1)
logging.debug(rendered_template)
if sys.version_info.major < 3:
file_handle_public = codecs.open(dest_file, mode="w", encoding='utf-8')
file_handle_public.write(rendered_template)
file_handle_public.close()
else:
file_handle_public = open(dest_file, 'wb')
file_handle_public.write(bytes(rendered_template, "UTF-8"))
file_handle_public.close()
def __call__(self, path, target, url_target, **options):
target = os.path.splitext(target)[0] + '.html'
with codecs.open(path, "r", "utf8") as f:
content = f.read() + _FOOTER % {'cnd': self.config['cnd']}
doctree = publish_doctree(content)
title = doctree.children[0].astext()
target = os.path.splitext(target)[0] + '.html'
paths = target.split('/')
is_article = len(paths) > 2
paragraphs = [
'<p>%s</p>' % _tree(text, url_target, title, self.config)
for text in doctree.children[1:]
]
# loading sections
doc_sections = get_document_index(url_target,
title).get('sections', [])
mytemplate = Template(filename=self.config['generic'],
lookup=self.lookup)
body = u'\n'.join(paragraphs)
#body = body.replace(u'--', u'—')
if is_article:
index(url_target, title, 'body', body)
logger.info('Generating %r' % target)
with codecs.open(target, 'w', encoding='utf8') as f:
try:
f.write(
mytemplate.render(body=body,
title=title,
doc_sections=doc_sections,
**options))
except Exception:
traceback = RichTraceback()
for filename, lineno, function, line in traceback.traceback:
print "File %s, line %s, in %s" % (filename, lineno,
function)
print line, "\n"
raise
paths = target.split('/')
if is_article:
index(url_target, title, 'volume', paths[1])
save_index(self.config['metadata'])
def render(self, *args, **kwargs):
self.context['makoStartTime'] = time.time()
context = self.context
context.update(kwargs)
# noinspection PyBroadException
try:
return self.template.render_unicode(*args, **context)
except Exception as error:
print(error)
context['title'] = '500'
context['header'] = _('Mako Error')
context['backtrace'] = RichTraceback()
return get_lookup().get_template('500.mako').render_unicode(
*args, **context)
def render(self, *args, **kwargs):
for key in self.arguments:
if key not in kwargs:
kwargs[key] = self.arguments[key]
kwargs['makoStartTime'] = time.time()
# noinspection PyBroadException
try:
return self.template.render_unicode(*args, **kwargs)
except Exception:
kwargs['title'] = '500'
kwargs['header'] = _('Mako Error')
kwargs['backtrace'] = RichTraceback()
return get_lookup().get_template('500.mako').render_unicode(*args, **kwargs)
def render(self, template_name=None, return_string=False, **kwargs):
""" Redefine the render """
if not template_name:
template_name = self.template_path
t = self.lookup.get_template(template_name)
args = dict(
handler=self,
request=self.request,
current_user=self.current_user,
locale=self.locale,
_=self.locale.translate,
static_url=self.static_url,
xsrf_form_html=self.xsrf_form_html,
xsrf_cookie=self.xsrf_cookie,
reverse_url=self.application.reverse_url,
LANGUAGES=self.settings['LANGUAGES'],
STATIC_URL=self.settings['STATIC_URL'],
THEME_URL=self.settings['THEME_URL'],
THEME=self.settings['THEME'],
theme_url=self.theme_url,
#method
htime=htime,
ftime=ftime,
has_permission=self.has_permission,
show_error=show_error,
b2s=b2s,
title=self.title,
)
args.update(kwargs)
# We can set keyword with initialize() or prepare()
args.update(self.prepare_kwargs)
# TODO: more readable bug track
# http://docs.makotemplates.org/en/latest/usage.html#handling-exceptions
try:
html = t.render(**args)
except:
traceback = RichTraceback()
t = self.lookup.get_template('mako_failed.html')
html = t.render(traceback=traceback)
if return_string: return html
self.finish(html)
def __call__(self, path, target, url_target, **options):
target = os.path.splitext(target)[0] + '.html'
mytemplate = Template(filename=path, lookup=self.lookup)
logger.info('Generating %r' % target)
with codecs.open(target, 'w', encoding='utf8') as f:
try:
f.write(mytemplate.render(**options))
except Exception:
traceback = RichTraceback()
for filename, lineno, function, line in traceback.traceback:
print "File %s, line %s, in %s" % (filename, lineno,
function)
print line, "\n"
raise
def render(self, context=None, request=None):
"""
Render the template with a given context. Here we're adding
some context variables that are required for all templates in
the system like the statix url and the CSRF tokens, etc.
:param context: It must be a dict if provided
:param request: It must be a django.http.HttpRequest if provided
:return: A rendered template
"""
if context is None:
context = {}
for processor in self.engine.template_context_processors:
context.update(processor(request))
try:
return self.template.render(**context)
except Exception as e:
traceback = RichTraceback()
source = traceback.source
if not source:
# There's no template source lines then raise
raise e
source = source.split('\n')
line = traceback.lineno
top = max(0, line - 4)
bottom = min(len(source), line + 5)
source_lines = [(i + 1, source[i]) for i in range(top, bottom)]
e.template_debug = {
'name': traceback.records[5][4],
'message': '{}: {}'.format(traceback.errorname,
traceback.message),
'source_lines': source_lines,
'line': line,
'during': source_lines[line - top - 1][1],
'total': bottom - top,
'bottom': bottom,
'top': top + 1,
# mako's RichTraceback doesn't return column number
'before': '',
'after': '',
}
raise e
def render_template(template, **data):
ctx = context(**data)
buf = ctx._buffer_stack[0]
try:
template.render_context(ctx)
out = buf.getvalue()
return out
except:
from mako.exceptions import RichTraceback
traceback = RichTraceback()
for (filename, lineno, function, line) in traceback.traceback:
print "File %s, line %s, in %s" % (filename, lineno, function)
print line
print "%s: %s" % (str(
traceback.error.__class__.__name__), traceback.error)
def serve_template(self, template_name, **kwargs):
try:
if self.template_exists(template_name):
template = self._template_exists_cache[template_name]
return template.render(**kwargs)
else:
lookup = self._get_template_lookup()
template = lookup.get_template(template_name)
return template.render(**kwargs)
except:
traceback = RichTraceback()
for (filename, lineno, function, line) in traceback.traceback:
print("File %s, line %s, in %s" % (filename, lineno, function))
print(line, "\n")
print("%s: %s" %
(str(traceback.error.__class__.__name__), traceback.error))
