def _render_newspage(self,htmlfile,atomfile,title,subtitle,entries):
# only look in cwd and this file's directory
loader = TemplateLoader(['.' , os.path.dirname(__file__)],
variable_lookup='lenient')
tmpl = loader.load("etc/newspage.template.xht2")
stream = tmpl.generate(title=title,
entries=entries)
# tmpfilename = mktemp()
tmpfilename = htmlfile.replace(".html",".xht2")
assert(tmpfilename != htmlfile)
Util.ensureDir(tmpfilename)
fp = codecs.open(tmpfilename,"w", encoding="utf-8")
x = stream.render()
fp.write(x)
fp.close()
Util.ensureDir(htmlfile)
Util.transform("xsl/static.xsl", tmpfilename, htmlfile, validate=False)
tmpl = loader.load("etc/newspage.template.atom")
stream = tmpl.generate(title=title,
subtitle=subtitle,
entries=entries,
feeduri=u'https://lagen.nu/%s' % atomfile.replace("data/", ""),
pageuri=u'https://lagen.nu/%s' % htmlfile.replace("data/", ""))
tmpfilename = mktemp()
fp = codecs.open(tmpfilename,"w", encoding="utf-8")
fp.write(stream.render())
fp.close()
Util.ensureDir(atomfile)
Util.replace_if_different(tmpfilename, atomfile)
log.info("rendered %s (%s)" % (htmlfile, atomfile))
def run(request):
# Render the header.
loader = TemplateLoader(['.'])
tmpl = loader.load('header.tmpl', None, TextTemplate)
output = tmpl.generate(version = config.__version__).render('text')
request.write(output)
# Perform the task.
state_db = StateDB(os.path.join(config.data_dir, 'installer_states'))
step_id = request.get_data().get_int('step')
prev_step_id = step_id - 1
state = state_db.get(prev_step_id)
step_cls = steps[step_id]
if prev_step_id >= 0:
prev_step = steps[prev_step_id](prev_step_id, request, state)
if prev_step.check() and prev_step.submit():
state_db.save(step_id, state)
step = step_cls(step_id, request, state)
step.show()
else:
step = step_cls(step_id, request, state)
step.show()
# Render the footer.
tmpl = loader.load('footer.tmpl', None, TextTemplate)
output = tmpl.generate().render('text')
request.write(output)
class TemplateSet(object):
def __init__(self, basedir, namespace_module=None):
self.basedir = basedir
if isinstance(basedir, list):
self.dirs = basedir
else:
self.dirs = [self.basedir]
self.loader = TemplateLoader(self.dirs,
auto_reload=True,
callback=self.template_loaded)
if hasattr(namespace_module, '__dict__'):
self.namespace_module = namespace_module.__dict__
else:
self.namespace_module = namespace_module
def file(self, name):
fn = os.path.join(self.basedir, name)
assert os.path.dirname(fn) == self.basedir
return file(fn)
def template_loaded(self, template):
pass
def template(self, tname):
return self.loader.load(tname)
def text_template(self, tname):
return self.loader.load(tname, cls=NewTextTemplate)
#------------------------------------------------------------
def _inject_django_things_into_namespace(self, request, ns):
ns['request'] = request
ns['user'] = getattr(request, 'user', None)
ns['ROOT'] = request and request.META['SCRIPT_NAME']
if not 'errors' in ns:
ns['errors'] = None
if self.namespace_module is not None:
ns.update(self.namespace_module)
def render(self, tname, **kwargs):
request = get_request()
self._inject_django_things_into_namespace(request, kwargs)
return HttpResponse(
self.template(tname).generate(**kwargs).render('xhtml'))
def render_xml(self, tname, **kwargs):
request = get_request()
self._inject_django_things_into_namespace(request, kwargs)
content_type = kwargs.get('content_type', 'application/xml')
return HttpResponse(
self.template(tname).generate(**kwargs).render('xml'),
content_type=content_type)
def plaintext(self, tname, **kwargs):
request = get_request()
content_type = kwargs.get('content_type', 'text/plain')
self._inject_django_things_into_namespace(request, kwargs)
txt = self.text_template(tname).generate(**kwargs).render('text')
return txt
def _render_newspage(self,htmlfile,atomfile,title,subtitle,entries):
# only look in cwd and this file's directory
loader = TemplateLoader(['.' , os.path.dirname(__file__)],
variable_lookup='lenient')
tmpl = loader.load("etc/newspage.template.xht2")
stream = tmpl.generate(title=title,
entries=entries)
# tmpfilename = mktemp()
tmpfilename = htmlfile.replace(".html",".xht2")
assert(tmpfilename != htmlfile)
Util.ensureDir(tmpfilename)
fp = codecs.open(tmpfilename,"w", encoding="utf-8")
x = stream.render()
fp.write(x)
fp.close()
Util.ensureDir(htmlfile)
Util.transform("xsl/static.xsl", tmpfilename, htmlfile, validate=False)
tmpl = loader.load("etc/newspage.template.atom")
stream = tmpl.generate(title=title,
subtitle=subtitle,
entries=entries,
feeduri=u'https://lagen.nu/%s' % atomfile.replace("data/", ""),
pageuri=u'https://lagen.nu/%s' % htmlfile.replace("data/", ""))
tmpfilename = mktemp()
fp = codecs.open(tmpfilename,"w", encoding="utf-8")
fp.write(stream.render())
fp.close()
Util.ensureDir(atomfile)
Util.replace_if_different(tmpfilename, atomfile)
log.info("rendered %s (%s)" % (htmlfile, atomfile))
class BaseController(WSGIController):
def __init__(self):
self.loader = TemplateLoader(
os.path.join(os.path.dirname(os.path.dirname(__file__)),
'templates'),
auto_reload=True
)
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
return WSGIController.__call__(self, environ, start_response)
# TODO: add support for jurisdictions
def license2xml(self, license, locale='en'):
"""Turn a cc.license.License object into XML"""
tmpl = self.loader.load('license.xml')
html = cc.license.formatters.HTML.format(license, locale=locale)
stream = tmpl.generate(license=license,
locale=locale,
license_html=html)
return stream.render(method='xml')
def generate_error(self, id, msg):
tmpl = self.loader.load('error.xml')
stream = tmpl.generate(id=id, msg=msg)
return stream.render(method='xml')
class Engine(object):
"""docstring for Engine"""
defaults = {
'auto_reload': False,
'search_paths': ['./templates']
}
def __init__(self, app, conf=None):
super(Engine, self).__init__()
self.app = app
self.config = conf or {}
self.config.update(copy.deepcopy(Engine.defaults))
paths = self.config.get('search_paths')
for i,p in enumerate(paths):
if p.find('./') == 0:
paths[i] = p.replace('./', config['project']['paths']['root']+'/')
self._loader = TemplateLoader(paths, auto_reload=True)
self.method = "xhtml"
self.doctype = "xhtml-transitional"
def add_search_path(self, path):
"""Adds a directory to the template loader search path.
You can specify templates by base name as long as the directories
in which they reside are in the search path.
"""
if path not in self._loader.search_path:
self._loader.search_path.append(path)
def load(self, filename):
return self._loader.load(filename)
def page(self, tpl, data):
"""Loads a Genshi template and returns its output as
an XHTML page, taking care of some details.
- tpl is a path, relative to the app directory.
- data is a dictionary to populate the template instance.
"""
if isinstance(data, basestring):
return data
t = self._loader.load(tpl)
return t.generate(**self.app.todict(**data)).render(method=self.method, doctype=self.doctype, encoding="utf-8")
def render(self, *args, **kwargs):
"""Function to render the given data to the template specified via the
``@output`` decorator.
"""
if args:
assert len(args) == 1, \
'Expected exactly one argument, but got %r' % (args,)
template = self._loader.load(args[0])
else:
template = thread_data.template
ctxt = Context(**self.app.tpl_context)
ctxt.push(kwargs)
return template.generate(ctxt)
def check_bundler(self):
""" Check templates in Bundler for syntax errors. """
loader = TemplateLoader()
for entry in self.core.plugins['Bundler'].entries.values():
if (self.HandlesFile(entry.name) and entry.template is not None):
try:
loader.load(entry.name, cls=MarkupTemplate)
except TemplateSyntaxError:
err = sys.exc_info()[1]
self.LintError("genshi-syntax-error",
"Genshi syntax error: %s" % err)
def check_tgenshi(self):
""" Check templates in TGenshi for syntax errors """
loader = TemplateLoader()
for eset in self.core.plugins['TGenshi'].entries.values():
for fname, sdata in list(eset.entries.items()):
if self.HandlesFile(fname):
try:
loader.load(sdata.name, cls=NewTextTemplate)
except TemplateSyntaxError:
err = sys.exc_info()[1]
self.LintError("genshi-syntax-error",
"Genshi syntax error: %s" % err)
def check_bundler(self):
""" Check templates in Bundler for syntax errors """
loader = TemplateLoader()
for entry in self.core.plugins['Bundler'].entries.values():
if (self.HandlesFile(entry.name) and
isinstance(entry, BundleTemplateFile)):
try:
loader.load(entry.name, cls=MarkupTemplate)
except TemplateSyntaxError:
err = sys.exc_info()[1]
self.LintError("genshi-syntax-error",
"Genshi syntax error: %s" % err)
def run(self):
''' class for (test) orderprint; delevers a valid html-file.
Uses a kid-template for the enveloping/merging.
use kid to write; no envelope grammar is used
'''
try:
from genshi.template import TemplateLoader
except:
txt=botslib.txtexc()
raise ImportError(_(u'Dependency failure: editype "template" requires python library "genshi". Error:\n%s'%txt))
defmessage = grammar.grammarread(self.ta_info['editype'],self.ta_info['messagetype']) #needed because we do not know envelope; read syntax for editype/messagetype
self.ta_info.update(defmessage.syntax)
botslib.tryrunscript(self.userscript,self.scriptname,'ta_infocontent',ta_info=self.ta_info)
if not self.ta_info['envelope-template']:
raise botslib.OutMessageError(_(u'While enveloping in "$editype.$messagetype": syntax option "envelope-template" not filled; is required.'),editype=self.ta_info['editype'],messagetype=self.ta_info['messagetype'])
templatefile = botslib.abspath('templateshtml',self.ta_info['envelope-template'])
ta_list = self.filelist2absolutepaths()
try:
botsglobal.logger.debug(u'Start writing envelope to file "%s".',self.ta_info['filename'])
loader = TemplateLoader(auto_reload=False)
tmpl = loader.load(templatefile)
except:
txt=botslib.txtexc()
raise botslib.OutMessageError(_(u'While enveloping in "$editype.$messagetype", error:\n$txt'),editype=self.ta_info['editype'],messagetype=self.ta_info['messagetype'],txt=txt)
try:
f = botslib.opendata(self.ta_info['filename'],'wb')
stream = tmpl.generate(data=ta_list)
stream.render(method='xhtml',encoding=self.ta_info['charset'],out=f)
except:
txt=botslib.txtexc()
raise botslib.OutMessageError(_(u'While enveloping in "$editype.$messagetype", error:\n$txt'),editype=self.ta_info['editype'],messagetype=self.ta_info['messagetype'],txt=txt)
def construct_submission(template_path, action, submission_input, center):
'''construct XML for submission
:param action: action for submission -
:param submission_input: schema_xmls or schema_targets depending on action
ADD/MODIFY: schema_xmls
CANCEL/RELEASE: schema_targets
:param loader: object of TemplateLoader in genshi
:param center: center name used to register ENA Webin
:return submission_xml: filename of submission XML
'''
xsds, templates = actors(template_path)
template = templates['submission']
loader = TemplateLoader(search_path=template_path)
Template = loader.load(template)
stream = Template.generate(action=action,
input=submission_input,
center=center)
submission_xml = construct_xml('submission', stream, xsds['submission'])
return submission_xml
def send_project_index(environ,
start_response,
parent_dir=None,
env_paths=None):
req = Request(environ, start_response)
loadpaths = [pkg_resources.resource_filename('trac', 'templates')]
use_clearsilver = False
if req.environ.get('trac.env_index_template'):
tmpl_path, template = os.path.split(
req.environ['trac.env_index_template'])
loadpaths.insert(0, tmpl_path)
use_clearsilver = template.endswith('.cs') # assume Clearsilver
if use_clearsilver:
req.hdf = HDFWrapper(
loadpaths) # keep that for custom .cs templates
else:
template = 'index.html'
data = {
'trac': {
'version': TRAC_VERSION,
'time': format_datetime()
},
'req': req
}
if req.environ.get('trac.template_vars'):
for pair in req.environ['trac.template_vars'].split(','):
key, val = pair.split('=')
data[key] = val
if use_clearsilver:
req.hdf[key] = val
try:
href = Href(req.base_path)
projects = []
for env_name, env_path in get_environments(environ).items():
try:
env = open_environment(env_path,
use_cache=not environ['wsgi.run_once'])
proj = {
'env': env,
'name': env.project_name,
'description': env.project_description,
'href': href(env_name)
}
except Exception, e:
proj = {'name': env_name, 'description': to_unicode(e)}
projects.append(proj)
projects.sort(lambda x, y: cmp(x['name'].lower(), y['name'].lower()))
data['projects'] = projects
if use_clearsilver:
req.hdf['projects'] = projects
req.display(template)
loader = TemplateLoader(loadpaths, variable_lookup='lenient')
tmpl = loader.load(template)
stream = tmpl.generate(**data)
output = stream.render('xhtml', doctype=DocType.XHTML_STRICT)
req.send(output, 'text/html')
def run(self):
try:
from genshi.template import TemplateLoader
except:
raise ImportError('Dependency failure: editype "templatehtml" requires python library "genshi".')
self._openoutenvelope()
self.ta_info.update(self.out.ta_info)
botslib.tryrunscript(self.userscript, self.scriptname, 'ta_infocontent', ta_info=self.ta_info)
if not self.ta_info['envelope-template']:
raise botslib.OutMessageError(_('While enveloping in "%(editype)s.%(messagetype)s": syntax option "envelope-template" not filled; is required.'),
self.ta_info)
templatefile = botslib.abspath(self.__class__.__name__, self.ta_info['envelope-template'])
ta_list = self.filelist2absolutepaths()
try:
botsglobal.logger.debug('Start writing envelope to file "%(filename)s".', self.ta_info)
loader = TemplateLoader(auto_reload=False)
tmpl = loader.load(templatefile)
except:
txt = botslib.txtexc()
raise botslib.OutMessageError(_('While enveloping in "%(editype)s.%(messagetype)s", error:\n%(txt)s'),
{'editype': self.ta_info['editype'], 'messagetype': self.ta_info['messagetype'], 'txt': txt})
try:
filehandler = botslib.opendata_bin(self.ta_info['filename'], 'wb')
stream = tmpl.generate(data=ta_list)
stream.render(method='xhtml', encoding=self.ta_info['charset'], out=filehandler)
except:
txt = botslib.txtexc()
raise botslib.OutMessageError(_('While enveloping in "%(editype)s.%(messagetype)s", error:\n%(txt)s'),
{'editype': self.ta_info['editype'], 'messagetype': self.ta_info['messagetype'], 'txt': txt})
finally:
filehandler.close()
def writeall(self):
''' Very different writeall:
there is no tree of nodes; there is no grammar.structure/recorddefs; kid opens file by itself.
'''
try:
from genshi.template import TemplateLoader
except:
txt=botslib.txtexc()
raise ImportError(_(u'Dependency failure: editype "template" requires python library "genshi". Error:\n%s'%txt))
#for template-grammar: only syntax is used. Section 'syntax' has to have 'template'
self.outmessagegrammarread(self.ta_info['editype'],self.ta_info['messagetype'])
templatefile = botslib.abspath(u'templateshtml',self.ta_info['template'])
try:
botsglobal.logger.debug(u'Start writing to file "%s".',self.ta_info['filename'])
loader = TemplateLoader(auto_reload=False)
tmpl = loader.load(templatefile)
except:
txt=botslib.txtexc()
raise botslib.OutMessageError(_(u'While templating "$editype.$messagetype", error:\n$txt'),editype=self.ta_info['editype'],messagetype=self.ta_info['messagetype'],txt=txt)
try:
f = botslib.opendata(self.ta_info['filename'],'wb')
stream = tmpl.generate(data=self.data)
stream.render(method='xhtml',encoding=self.ta_info['charset'],out=f)
except:
txt=botslib.txtexc()
raise botslib.OutMessageError(_(u'While templating "$editype.$messagetype", error:\n$txt'),editype=self.ta_info['editype'],messagetype=self.ta_info['messagetype'],txt=txt)
botsglobal.logger.debug(_(u'End writing to file "%s".'),self.ta_info['filename'])
def _format_plaintext(self, event):
blog_post = event.blog_post
blog_comment = event.blog_comment
data = dict(
name=blog_post.name,
author=event.author,
time=event.timestamp,
category=event.category,
version=event.version,
link=event.remote_addr,
title=blog_post.title,
body=blog_post.body,
comment=event.comment,
)
chrome = Chrome(self.env)
dirs = []
for provider in chrome.template_providers:
dirs += provider.get_templates_dirs()
templates = TemplateLoader(dirs, variable_lookup='lenient')
template = templates.load('fullblog_plaintext.txt',
cls=NewTextTemplate)
if template:
stream = template.generate(**data)
output = stream.render('text')
return output
def get_diffs(self, req, title, old_text, new_text):
diff_style, diff_options, diff_data = get_diff_options(req)
diff_context = 3
for option in diff_options:
if option.startswith('-U'):
diff_context = int(option[2:])
break
if diff_context < 0:
diff_context = None
diffs = diff_blocks(old_text.splitlines(), new_text.splitlines(), context=diff_context,
tabwidth=2,
ignore_blank_lines=True,
ignore_case=True,
ignore_space_changes=True)
chrome = Chrome(self.env)
loader = TemplateLoader(chrome.get_all_templates_dirs())
tmpl = loader.load('diff_div.html')
changes=[{'diffs': diffs, 'props': [],
'title': title,
'new': {'path':"", 'rev':'', 'shortrev': '', 'href':''},
'old': {'path':"", 'rev':'', 'shortrev': '', 'href': ''}}]
data = chrome.populate_data(req,
{ 'changes':changes , 'no_id':True, 'diff':diff_data,
'longcol': '', 'shortcol': ''})
diff_data['style']='sidebyside';
data.update({ 'changes':changes , 'no_id':True, 'diff':diff_data,
'longcol': '', 'shortcol': ''})
stream = tmpl.generate(**data)
return stream.render()
def run(self):
''' class for (test) orderprint; delevers a valid html-file.
Uses a kid-template for the enveloping/merging.
use kid to write; no envelope grammar is used
'''
try:
from genshi.template import TemplateLoader
except:
raise ImportError(_(u'Dependency failure: editype "template" requires python library "genshi".'))
self._openoutenvelope()
self.ta_info.update(self.out.ta_info)
botslib.tryrunscript(self.userscript,self.scriptname,'ta_infocontent',ta_info=self.ta_info)
if not self.ta_info['envelope-template']:
raise botslib.OutMessageError(_(u'While enveloping in "%(editype)s.%(messagetype)s": syntax option "envelope-template" not filled; is required.'),
self.ta_info)
templatefile = botslib.abspath('templateshtml',self.ta_info['envelope-template'])
ta_list = self.filelist2absolutepaths()
try:
botsglobal.logger.debug(u'Start writing envelope to file "%(filename)s".',self.ta_info)
loader = TemplateLoader(auto_reload=False)
tmpl = loader.load(templatefile)
except:
txt = botslib.txtexc()
raise botslib.OutMessageError(_(u'While enveloping in "%(editype)s.%(messagetype)s", error:\n%(txt)s'),
{'editype':self.ta_info['editype'],'messagetype':self.ta_info['messagetype'],'txt':txt})
try:
filehandler = botslib.opendata(self.ta_info['filename'],'wb')
stream = tmpl.generate(data=ta_list)
stream.render(method='xhtml',encoding=self.ta_info['charset'],out=filehandler)
except:
txt = botslib.txtexc()
raise botslib.OutMessageError(_(u'While enveloping in "%(editype)s.%(messagetype)s", error:\n%(txt)s'),
{'editype':self.ta_info['editype'],'messagetype':self.ta_info['messagetype'],'txt':txt})
def run_construct(template_path, schema_targets, center, vir, tool):
'''construct XMLs for schema in schema_targets
:param schema_targets: dictionary of 'schema:targets' generated
by extract_targets()
:param loader: object of TemplateLoader in genshi
:param center: center name used to register ENA Webin
:param tool: dict of tool_name and tool_version , by default ena-upload-cli
:param vir: flag to enable viral sample submission
:return schema_xmls: dictionary of 'schema:filename'
'''
xsds, templates = actors(template_path, vir)
schema_xmls = {}
loader = TemplateLoader(search_path=template_path)
for schema, targets in schema_targets.items():
template = templates[schema]
Template = loader.load(template)
stream = generate_stream(schema, targets, Template, center, tool)
schema_xmls[schema] = construct_xml(schema, stream, xsds[schema])
return schema_xmls
class TplFactory(object):
known_exts = {
'.thtml': XmlTemplate,
'.tcss': PlainTemplate,
'.tjs': PlainTemplate,
}
def __init__(self, default_tpl_dir, tpl_dir):
# We use lenient mode here because we want an easy way to check whether
# a template variable is defined, or the empty string, thus defined()
# will only work for the 'whether it is defined' part of the test.
self.loader = TemplateLoader([tpl_dir, default_tpl_dir],
variable_lookup='lenient')
def is_known_template_type(self, file):
filename, ext = os.path.splitext(os.path.basename(file))
return ext in self.known_exts.keys()
def load(self, tpl_ident):
if self.is_known_template_type(tpl_ident):
filename, ext = os.path.splitext(os.path.basename(tpl_ident))
tpl_class = self.known_exts[ext]
tpl = self.loader.load(tpl_ident, cls=tpl_class.genshi_tpl_class)
return tpl_class(self, tpl)
else:
raise ValueError(_('Unknown template type for %s' % tpl_ident))
def test():
base_path = os.path.dirname(os.path.abspath(__file__))
loader = TemplateLoader([base_path], auto_reload=True)
start = time.clock()
tmpl = loader.load('test.html')
print ' --> parse stage: %.4f ms' % ((time.clock() - start) * 1000)
data = dict(hello='<world>', skin='default', hey='ZYX', bozz=None,
items=['Number %d' % num for num in range(1, 15)],
prefix='#')
print tmpl.generate(**data).render(method='html')
times = []
for i in range(1000):
start = time.clock()
list(tmpl.generate(**data))
times.append(time.clock() - start)
sys.stdout.write('.')
sys.stdout.flush()
print
print ' --> render stage: %s ms (average)' % (
(sum(times) / len(times) * 1000))
class Aspect(TemplateAspectBase):
RELOAD_TEMPLATES = "reload_templates"
# TODO: use coming genshi.template.plugin.MarkupTemplateEnginePlugin.doctypes
doctypes = dict((key.lower().replace('_', '-'), item)
for key, item in DocType.__dict__.items()
if key.isupper() and isinstance(item, tuple))
def post_init_configure(self, cfg):
self.__super.post_init_configure(cfg)
autoReload = str(cfg.get(self.RELOAD_TEMPLATES, False)) == str(True)
self.loader = TemplateLoader(['.'], auto_reload=autoReload)
def load_template(self):
return self.loader.load(
os.path.join(self.templateBase, self.templateName))
def make_result_generator(self, graph, resource, lang, data=None):
tplt = self.load_template()
allData = dict(self.generate_query_items(graph, resource, lang))
if data: allData.update(data)
# TODO: although genshi has a serialize (to stream) too, it doesn't
# take encoding. Find the simplest way to get around that (without too
# much duplicatiom of render innards..).. Or just remove this todo?
def generator(format, encoding):
doctype = self.doctypes.get(format)
format = format.split('-')[0]
yield tplt.generate(**allData).render(format,
doctype=doctype,
encoding=encoding)
return generator
class Plugin(object):
name = 'genshi'
api = 2
def __init__(self, auto_reload=True):
self.loader = TemplateLoader([resource_filename(__name__, 'templates')],
auto_reload=auto_reload)
from bottle import request
from . import static_url
from .models import Config
self.global_variables = dict(
static_url = static_url,
request = request,
Config = Config,
)
def setup(self, app):
pass
def apply(self, callback, route):
template_name = route.config.get('template')
serializer = route.config.get('serializer', 'xhtml')
if template_name is None:
return callback
else:
def wrapper(*args, **kw):
namespace = callback(*args, **kw)
namespace.update(self.global_variables)
template = self.loader.load(template_name)
return template.generate(**namespace).render(serializer)
return wrapper
def close(self):
pass
def __call__(self):
assert 'orders' in self.request.params
oids = self.request.params['orders'].split(',')
assert oids
labels = []
for oid in oids:
ret = cc.makeRequest('/process-instance',
'post', {'businessKey': oid},
withProcessVariables=(
'orderId',
'externalOrderId',
'factoryNumber',
'customerName',
'customerRegionCode',
),
processInstanceIdField='id',
hoistProcessVariables=True)
pkgId = ret[0]['pkgId'] = shortuuid.uuid()
ret[0]['labelUrl'] = f'{self.request.host_url}/ikea/shipOrder?' \
f'orderId={oid}&pkgId={pkgId}'
labels.append(ret[0])
loader = TemplateLoader([os.path.dirname(__file__)])
template = loader.load('shippingLabel.rml')
stream = template.generate(labels=labels, view=self)
body = rml2pdf.parseString(stream.render()).read()
response = Response(content_type='application/pdf',
content_disposition='filename="labels.pdf"',
content_length=len(body),
body=body)
return response
def construct_submission(template_path, action, submission_input, center, vir, tool):
'''construct XML for submission
:param action: action for submission -
:param submission_input: schema_xmls or schema_targets depending on action
ADD/MODIFY: schema_xmls
CANCEL/RELEASE: schema_targets
:param loader: object of TemplateLoader in genshi
:param center: center name used to register ENA Webin
:param tool: tool name, by default ena-upload-cli
:param vir: flag to enable viral sample submission
:return submission_xml: filename of submission XML
'''
xsds, templates = actors(template_path, vir)
template = templates['submission']
loader = TemplateLoader(search_path=template_path)
Template = loader.load(template)
stream = Template.generate(action=action, input=submission_input,
center=center, tool_name=tool['tool_name'],tool_version=tool['tool_version'])
submission_xml = construct_xml('submission', stream, xsds['submission'])
return submission_xml
def run(self):
try:
from genshi.template import TemplateLoader
except:
raise ImportError('Dependency failure: editype "templatehtml" requires python library "genshi".')
self._openoutenvelope()
self.ta_info.update(self.out.ta_info)
botslib.tryrunscript(self.userscript,self.scriptname,'ta_infocontent',ta_info=self.ta_info)
if not self.ta_info['envelope-template']:
raise botslib.OutMessageError(_('While enveloping in "%(editype)s.%(messagetype)s": syntax option "envelope-template" not filled; is required.'),
self.ta_info)
templatefile = botslib.abspath(self.__class__.__name__,self.ta_info['envelope-template'])
ta_list = self.filelist2absolutepaths()
try:
botsglobal.logger.debug('Start writing envelope to file "%(filename)s".',self.ta_info)
loader = TemplateLoader(auto_reload=False)
tmpl = loader.load(templatefile)
except:
txt = botslib.txtexc()
raise botslib.OutMessageError(_('While enveloping in "%(editype)s.%(messagetype)s", error:\n%(txt)s'),
{'editype':self.ta_info['editype'],'messagetype':self.ta_info['messagetype'],'txt':txt})
try:
filehandler = botslib.opendata_bin(self.ta_info['filename'],'wb')
stream = tmpl.generate(data=ta_list)
stream.render(method='xhtml',encoding=self.ta_info['charset'],out=filehandler)
except:
txt = botslib.txtexc()
raise botslib.OutMessageError(_('While enveloping in "%(editype)s.%(messagetype)s", error:\n%(txt)s'),
{'editype':self.ta_info['editype'],'messagetype':self.ta_info['messagetype'],'txt':txt})
finally:
filehandler.close()
class TplFactory(object):
known_exts = {
'.thtml': XmlTemplate,
'.tcss' : PlainTemplate,
'.tjs' : PlainTemplate,
}
def __init__(self, default_tpl_dir, tpl_dir):
# We use lenient mode here because we want an easy way to check whether
# a template variable is defined, or the empty string, thus defined()
# will only work for the 'whether it is defined' part of the test.
self.loader = TemplateLoader([tpl_dir, default_tpl_dir],
variable_lookup='lenient')
def is_known_template_type(self, file):
filename, ext = os.path.splitext(os.path.basename(file))
return ext in self.known_exts.keys()
def load(self, tpl_ident):
if self.is_known_template_type(tpl_ident):
filename, ext = os.path.splitext(os.path.basename(tpl_ident))
tpl_class = self.known_exts[ext]
tpl = self.loader.load(tpl_ident, cls=tpl_class.genshi_tpl_class)
return tpl_class(self, tpl)
else:
raise ValueError(_('Unknown template type for %s' % tpl_ident))
class Genshi(BaseEngine):
app_dirname = 'genshi'
def __init__(self, params):
params = params.copy()
options = params.pop('OPTIONS').copy()
self.app_dirname = options.get('app_dirname', self.app_dirname)
super(Genshi, self).__init__(params)
auto_reload = options.get('auto_reload', False)
self.loader = TemplateLoader(self.template_dirs,
auto_reload=auto_reload)
self.serialization = options.get('serialization', 'html')
self.doctype = options.get('doctype', 'html')
def from_string(self, template_code):
return Template(MarkupTemplate(template_code),
self.serialization,
self.doctype)
def get_template(self, template_name):
try:
return Template(self.loader.load(template_name),
self.serialization,
self.doctype)
except TemplateNotFound as exc:
six.reraise(TemplateDoesNotExist, TemplateDoesNotExist(exc.args),
sys.exc_info()[2])
except GenshiTemplateSyntaxError as exc:
six.reraise(TemplateSyntaxError, TemplateSyntaxError(exc.args),
sys.exc_info()[2])
def login_html(tmpl_dir, **kwargs):
'''Dispatches to the template renderer to generate the HTML of the login page
'''
loader = TemplateLoader(tmpl_dir)
tmpl = loader.load('oid_login.html')
stream = tmpl.generate(**kwargs)
return stream.render('html', doctype='html', encoding='utf-8')
def command(self):
config=load_config(self.args)
path_genshi= config.get('exportanag.path_genshi')
opath= config.get('exportanag.path_out')
print path_genshi
loader_genshi = TemplateLoader([path_genshi],
auto_reload=True)
if self.options.run:
reparti = DBSession.query(Reparti).all()
rep_dict = {}
prods = {}
for r in reparti:
rep = slugify(r.reparto)
values = []
print "========", rep
prodotti = DBSession.query(Prodotti).filter_by(numeroreparto=r.numeroreparto).order_by(Prodotti.descrizioneestesa).all()
for p in prodotti:
desc = p.descrizioneestesa
if not desc:
desc = p.prodotto
values.append([p.eans[0].codicebilancia, desc])
print "%4s %s"%(p.eans[0].codicebilancia,desc )
tmpl = loader_genshi.load('index.html')
print "STREAM"
stream = tmpl.generate(r=r, values=values)
print "RENDER"
s = stream.render('html', doctype='xhtml', encoding='utf-8')
output_html = open(os.path.join(opath,rep+'.html'), 'w')
print "WRITE"
output_html.write(s)
print "written %s"%(os.path.join(opath,rep+'.html'))
def test():
base_path = os.path.dirname(os.path.abspath(__file__))
loader = TemplateLoader([base_path], auto_reload=True)
start = time.clock()
tmpl = loader.load('test.html')
print(' --> parse stage: %.4f ms' % ((time.clock() - start) * 1000))
data = dict(hello='<world>', skin='default', hey='ZYX', bozz=None,
items=['Number %d' % num for num in range(1, 15)],
prefix='#')
print(tmpl.generate(**data).render(method='html'))
times = []
for i in range(1000):
start = time.clock()
list(tmpl.generate(**data))
times.append(time.clock() - start)
sys.stdout.write('.')
sys.stdout.flush()
print()
print(' --> render stage: %s ms (average)' % (
(sum(times) / len(times) * 1000)))
class GenshiTemplateLoader(TemplateLoader):
def __init__(self, search_path, encoding='utf-8', **kwargs):
TemplateLoader.__init__(self, search_path, encoding)
from genshi.template import TemplateLoader as GenshiLoader
from genshi.template.loader import TemplateNotFound
self.not_found_exception = TemplateNotFound
reload_template = kwargs.pop('auto_reload', True)
kwargs.pop('default_encoding', None)
self.loader = GenshiLoader(search_path,
default_encoding=encoding,
auto_reload=reload_template,
**kwargs)
self.output_type = 'html'
self.encoding = encoding
def get_template(self, template_name):
try:
return self.loader.load(template_name, encoding=self.encoding)
except self.not_found_exception as e:
raise TemplateNotFound(template_name)
def render_to_string(self, template_name, context=None):
context = context or {}
tmpl = self.get_template(template_name)
return tmpl.generate(**context).render(self.output_type, encoding=None)
def _render_text_template(self, filename, **kwargs):
loader = TemplateLoader(['web'])
tmpl = loader.load(filename, None, TextTemplate)
self.output += tmpl.generate(web_dir = '/web',
current_user = self.get_current_user(),
txt = gettext,
**kwargs).render('text')
class Aspect(TemplateAspectBase):
RELOAD_TEMPLATES = "reload_templates"
# TODO: use coming genshi.template.plugin.MarkupTemplateEnginePlugin.doctypes
doctypes = dict(
(key.lower().replace('_', '-'), item)
for key, item in DocType.__dict__.items()
if key.isupper() and isinstance(item, tuple)
)
def post_init_configure(self, cfg):
self.__super.post_init_configure(cfg)
autoReload = str(cfg.get(self.RELOAD_TEMPLATES, False)) == str(True)
self.loader = TemplateLoader(['.'], auto_reload=autoReload)
def load_template(self):
return self.loader.load(os.path.join(self.templateBase, self.templateName))
def make_result_generator(self, graph, resource, lang, data=None):
tplt = self.load_template()
allData = dict( self.generate_query_items(graph, resource, lang) )
if data: allData.update(data)
# TODO: although genshi has a serialize (to stream) too, it doesn't
# take encoding. Find the simplest way to get around that (without too
# much duplicatiom of render innards..).. Or just remove this todo?
def generator(format, encoding):
doctype = self.doctypes.get(format)
format = format.split('-')[0]
yield tplt.generate(**allData).render(
format, doctype=doctype, encoding=encoding)
return generator
def __call__(self, *args, **kwargs):
dojo_theme = kwargs.pop('dojo_theme', None)
striped = kwargs.pop('striped', 'odd_row,even_row')
pdf = kwargs.pop('pdf', False)
genshi_path = kwargs.get('genshi_path')
page = self.page
dojo_theme = dojo_theme or getattr(self.page, 'dojo_theme',
None) or 'tundra'
auth = page._checkAuth()
if auth != AUTH_OK:
return self.page.site.forbidden_exception
if striped:
kwargs['striped'] = itertools.cycle(striped.split(','))
gnr_static_handler = page.site.getStatic('gnr')
tpldirectories = [os.path.dirname(genshi_path), page.parentdirpath
] + page.resourceDirs + [
gnr_static_handler.path(page.gnrjsversion, 'tpl')
]
loader = TemplateLoader(tpldirectories)
template = loader.load(os.path.basename(genshi_path))
page.charset = 'utf-8'
_resources = page.site.resources.keys()
_resources.reverse()
arg_dict = page.build_arg_dict()
arg_dict['mainpage'] = page
arg_dict.update(kwargs)
try:
output = template.generate(**arg_dict).render()
except WSGIHTTPException, exc:
return exc
class TemplateTestCase(unittest.TestCase):
def setUp(self):
template_path = os.path.abspath(os.path.join(os.path.dirname(__file__),
u'..',
u'src',
u'static',
u'templates'))
self.loader = TemplateLoader([template_path],
auto_reload=True, # for development
max_cache_size=100)
def tearDown(self):
pass
def test_unescape(self, text=ESCAPED_UNICODE):
self.assertIsInstance(text, unicode)
unescaped_text = Markup(text)
self.assertIsInstance(unescaped_text, Markup)
self.assertEqual(unescaped_text, UNESCAPED_UNICODE)
def test_render(self, name=u'foundation.html', **kwargs):
template = self.loader.load(name)
self.assertIsInstance(template, genshi.template.MarkupTemplate)
ctxt = Context(**kwargs)
self.assertIsInstance(ctxt, Context)
stream = template.generate(ctxt)
self.assertIsInstance(stream, genshi.core.Stream)
self.assertIsInstance(stream.render('html', doctype='html5'), str)
def writeall(self):
''' Very different writeall:
there is no tree of nodes; there is no grammar.structure/recorddefs; kid opens file by itself.
'''
try:
from genshi.template import TemplateLoader
except:
txt = botslib.txtexc()
raise ImportError(_(u'Dependency failure: editype "template" requires python library "genshi". Error:\n%s'%txt))
#for template-grammar: only syntax is used. Section 'syntax' has to have 'template'
self.outmessagegrammarread(self.ta_info['editype'],self.ta_info['messagetype'])
templatefile = botslib.abspath(u'templateshtml',self.ta_info['template'])
try:
botsglobal.logger.debug(u'Start writing to file "%s".',self.ta_info['filename'])
loader = TemplateLoader(auto_reload=False)
tmpl = loader.load(templatefile)
except:
txt = botslib.txtexc()
raise botslib.OutMessageError(_(u'While templating "$editype.$messagetype", error:\n$txt'),editype=self.ta_info['editype'],messagetype=self.ta_info['messagetype'],txt=txt)
try:
filehandler = botslib.opendata(self.ta_info['filename'],'wb')
stream = tmpl.generate(data=self.data)
stream.render(method='xhtml',encoding=self.ta_info['charset'],out=filehandler)
except:
txt = botslib.txtexc()
raise botslib.OutMessageError(_(u'While templating "$editype.$messagetype", error:\n$txt'),editype=self.ta_info['editype'],messagetype=self.ta_info['messagetype'],txt=txt)
botsglobal.logger.debug(_(u'End writing to file "%s".'),self.ta_info['filename'])
def _format_plaintext(self, event):
blog_post = event.blog_post
blog_comment = event.blog_comment
data = dict(
name = blog_post.name,
author = event.author,
time = event.timestamp,
category = event.category,
version = event.version,
link = event.remote_addr,
title = blog_post.title,
body = blog_post.body,
comment = event.comment,
)
chrome = Chrome(self.env)
dirs = []
for provider in chrome.template_providers:
dirs += provider.get_templates_dirs()
templates = TemplateLoader(dirs, variable_lookup='lenient')
template = templates.load(
'fullblog_plaintext.txt',
cls=NewTextTemplate
)
if template:
stream = template.generate(**data)
output = stream.render('text')
return output
def process_dir(dirpath, filenames, projects):
'''
Process a directory
'''
translations = GNUTranslations(
open(os.path.join(options.podir, options.lang + '.mo')))
loader = TemplateLoader(['.'],
callback=lambda template: template.filters.insert(
0, Translator(translations.ugettext)))
for fn in filenames:
if fn.endswith('~') or fn.endswith('.swp'):
continue
src_file = os.path.join(dirpath, fn)
dest_file = os.path.join(
options.output,
src_file[len(options.input):]) + '.' + options.lang # Hideous
curpage = src_file[len(options.input):].rstrip('.html')
relpath = '../' * (dest_file.count('/') - 1)
relpath = relpath.rstrip('/')
if relpath == '': relpath = '.'
if not os.path.exists(os.path.dirname(dest_file)):
os.makedirs(os.path.dirname(dest_file))
template = loader.load(src_file)
# Variables made availble to all templates
page = template.generate(
_=lambda text: Markup(translations.ugettext(text)),
lang=options.lang,
path=options.basepath,
relpath=relpath,
curpage=curpage,
projects=projects).render(method='html', doctype='html')
output = open(dest_file, 'w')
output.write(page)
output.close()
def get_diffs(self, req, old_text, new_text, id):
diff_style, diff_options, diff_data = get_diff_options(req)
diff_context = 3
for option in diff_options:
if option.startswith('-U'):
diff_context = int(option[2:])
break
if diff_context < 0:
diff_context = None
diffs = diff_blocks(old_text.splitlines(), new_text.splitlines(), context=diff_context,
tabwidth=2,
ignore_blank_lines=True,
ignore_case=True,
ignore_space_changes=True)
chrome = Chrome(self.env)
loader = TemplateLoader(chrome.get_all_templates_dirs())
tmpl = loader.load('diff_div.html')
title = "Estimate:%s Changed" %id
changes=[{'diffs': diffs, 'props': [],
'title': title, 'href': req.href('Estimate', id=id),
'new': {'path':title, 'rev':'', 'shortrev': '', 'href': req.href('Estimate', id=id)},
'old': {'path':"", 'rev':'', 'shortrev': '', 'href': ''}}]
data = chrome.populate_data(req,
{ 'changes':changes , 'no_id':True, 'diff':diff_data,
'longcol': '', 'shortcol': ''})
# diffs = diff_blocks("Russ Tyndall", "Russ Foobar Tyndall", context=None, ignore_blank_lines=True, ignore_case=True, ignore_space_changes=True)
# data = c._default_context_data.copy ()
diff_data['style']='sidebyside';
data.update({ 'changes':changes , 'no_id':True, 'diff':diff_data,
'longcol': '', 'shortcol': ''})
stream = tmpl.generate(**data)
return stream.render()
def __call__(self, *args, **kwargs):
dojo_theme=kwargs.pop('dojo_theme',None)
striped=kwargs.pop('striped','odd_row,even_row')
pdf=kwargs.pop('pdf',False)
genshi_path=kwargs.get('genshi_path')
page = self.page
dojo_theme = dojo_theme or getattr(self.page, 'dojo_theme', None) or 'tundra'
auth = page._checkAuth()
if auth != AUTH_OK:
return self.page.site.forbidden_exception
if striped:
kwargs['striped'] = itertools.cycle(striped.split(','))
gnr_static_handler = page.site.getStatic('gnr')
tpldirectories = [os.path.dirname(genshi_path), page.parentdirpath] + page.resourceDirs + [
gnr_static_handler.path(page.gnrjsversion, 'tpl')]
loader = TemplateLoader(tpldirectories)
template = loader.load(os.path.basename(genshi_path))
page.charset = 'utf-8'
_resources = page.site.resources.keys()
_resources.reverse()
arg_dict = page.build_arg_dict()
arg_dict['mainpage'] = page
arg_dict.update(kwargs)
try:
output = template.generate(**arg_dict).render()
except WSGIHTTPException, exc:
return exc
class ServiceBuilder(object):
def __init__(self):
searchPath = [os.path.split(newservice.__file__)[0] + "/resource"]
self.templateLoader = TemplateLoader(searchPath)
def makeService(self, prefix, serviceName):
""" Create folders and files for a new service. """
serviceFolder = serviceName.lower()
folderStructure = {serviceFolder: {
'config': {},
'docs' : {},
'tests' : {},
'scripts': {},
'resource': {
'templates' : {
serviceName: {}
}
}
}
}
# list of lists, each list is composed of:
# 1. folder name in which to create file
# 2. name of file
# 3. template to use
files=[ [serviceFolder, "%s.py" % serviceFolder, 'service.genshi', TEXT],
["%s/config" % serviceFolder, "service.pcfg", 'serviceconf.genshi', TEXT],
["%s/config" % serviceFolder, "profile.pcfg", 'profileconf.genshi', TEXT],
["%s/config" % serviceFolder, "launch.pcfg", 'launchconf.genshi', TEXT],
["%s/docs" % serviceFolder, "%s.xml"%serviceFolder, 'docs.genshi', XML],
["%s/tests" % serviceFolder, "test%s"%serviceName, 'tests.genshi', TEXT],
[serviceFolder, "__init__.py", "init.genshi", TEXT],
]
try:
self._makeDirs(prefix, folderStructure)
self._makeFiles(serviceName, prefix, files)
except OSError:
print("Could not create directories and files - not writeable or dir exists.")
def _makeDirs(self, prefix, folders):
""" Recursively build a directory structure from a dictionary. """
for folder,subfolders in folders.items():
fpath = prefix+'/'+folder
os.mkdir(fpath)
if subfolders:
self._makeDirs(fpath, subfolders)
def _makeFiles(self, serviceName, prefix, files):
keyData = {'name':serviceName,
'module': serviceName.lower(),
'package': serviceName.lower(),
}
for folder, file, template, tmplCls in files:
tmpl = self.templateLoader.load(template, cls=tmplCls)
of = open(prefix+'/'+folder+'/'+file, 'wt')
of.writelines(tmpl.generate(**keyData).render())#strip_whitespace=False))
of.close()
def load(self, filename, relative_to=None, cls=None, encoding=None):
"""Actual loader function."""
return TemplateLoader.load(self,
self.get_dotted_filename(filename),
relative_to=relative_to,
cls=cls,
encoding=encoding)
def do_conversion(self):
template_filename = self.get_resource('tex_template.tex')
loader = TemplateLoader('.')
templ = loader.load(template_filename, cls=NewTextTemplate)
stream = templ.generate(**self.resume)
#TODO: embed .cls file into resume (or output a .zip with both)
self.generated_resume = stream.render('text')
def __init__(self,template, pagetitle=''):
if pagetitle == '':
pagetitle = template
loader = TemplateLoader(
os.path.join(os.path.dirname(__file__), 'templates'), auto_reload=True
)
tmpl = loader.load(template)
self.render = tmpl.generate(title=pagetitle).render('html',doctype='html')
def load(self, name, cls=MarkupTemplate, relative_to=None):
abs = path.join(template_root, path.dirname(relative_to or ''), name)
watch_file(abs)
_, ext = path.splitext(name)
cls = template_class.get(ext, cls)
return TemplateLoader.load(self, name,
cls=cls,
relative_to=relative_to)
def render_template(template_name, template_vals={}):
loader = TemplateLoader('theme/frontend')
template = loader.load(template_name)
template_vals['render'] = render_template
template_vals['Registry'] = Registry
stream = template.generate(**template_vals)
rendered = stream.render()
return Markup(rendered.decode('utf-8'))
def render_template(template_name, template_vals={}):
loader = TemplateLoader('theme/frontend')
template = loader.load(template_name)
template_vals['render']=render_template
template_vals['Registry']=Registry
stream = template.generate(**template_vals)
rendered = stream.render()
return Markup(rendered.decode('utf-8'))
def display(self, **kwargs):
"""Return the HTML code for the given widget."""
self._assert_rendering_was_prepared()
templateloader = TemplateLoader(self._get_all_widget_template_directories(),
auto_reload=True, variable_lookup='lenient')
template = templateloader.load(self.template_filename, cls=MarkupTemplate)
template_data = self._merge_data(kwargs)
return template.generate(**template_data)
def transform(tmpl_filename, html_filename, context):
loader = TemplateLoader('templates', auto_reload=True)
tmpl = loader.load(tmpl_filename)
rendered = tmpl.generate(title=context['title'] , date=context['date'], images=context['images']).render('html', doctype='html')
f = open(html_filename, 'w')
f.write(rendered)
f.close()
def bind_entry(self, entry, metadata):
self.bind_info_to_entry(entry, metadata)
used = self.get_pertinent_entries(entry, metadata)
basefile = used.pop(0)
if entry.get('perms').lower() == 'inherit':
# use on-disk permissions
fname = "%s/%s" % (self.path, entry.get('name'))
entry.set('perms',
str(oct(stat.S_IMODE(os.stat(fname).st_mode))))
if entry.tag == 'Path':
entry.set('type', 'file')
if basefile.name.endswith(".genshi"):
if not have_genshi:
logger.error("Cfg: Genshi is not available")
raise Bcfg2.Server.Plugin.PluginExecutionError
try:
template_cls = NewTextTemplate
loader = TemplateLoader()
template = loader.load(basefile.name, cls=template_cls,
encoding=self.encoding)
fname = entry.get('realname', entry.get('name'))
stream = template.generate(name=fname,
metadata=metadata,
path=basefile.name).filter(removecomment)
try:
data = stream.render('text', encoding=self.encoding,
strip_whitespace=False)
except TypeError:
data = stream.render('text', encoding=self.encoding)
if data == '':
entry.set('empty', 'true')
except Exception:
e = sys.exc_info()[1]
logger.error("Cfg: genshi exception: %s" % e)
raise Bcfg2.Server.Plugin.PluginExecutionError
else:
data = basefile.data
for delta in used:
data = process_delta(data, delta)
if entry.get('encoding') == 'base64':
entry.text = binascii.b2a_base64(data)
else:
try:
entry.text = u_str(data, self.encoding)
except UnicodeDecodeError:
e = sys.exc_info()[1]
logger.error("Failed to decode %s: %s" % (entry.get('name'), e))
logger.error("Please verify you are using the proper encoding.")
raise Bcfg2.Server.Plugin.PluginExecutionError
except ValueError:
e = sys.exc_info()[1]
logger.error("Error in specification for %s" % entry.get('name'))
logger.error("%s" % e)
logger.error("You need to specify base64 encoding for %s." %
entry.get('name'))
raise Bcfg2.Server.Plugin.PluginExecutionError
if entry.text in ['', None]:
entry.set('empty', 'true')
def __init__(self,
file=None,
max_blocks=None,
allow_empty_author=False,
strict=True,
templatedir=_TEMPLATEDIR,
vcsbrowser=None):
debian.changelog.Changelog.__init__(
self,
file=file,
max_blocks=max_blocks,
allow_empty_author=allow_empty_author,
strict=strict)
self.templatedir = templatedir
loader = TemplateLoader(self.templatedir)
self.html_tmpl = loader.load('cl.html', encoding='utf-8')
self.block_tmpl = loader.load('block.html', encoding='utf-8')
self.filter = HTMLChangelogFilter(vcsbrowser=vcsbrowser)
def run(self):
''' class for (test) orderprint; delevers a valid html-file.
Uses a kid-template for the enveloping/merging.
use kid to write; no envelope grammar is used
'''
try:
from genshi.template import TemplateLoader
except:
txt = botslib.txtexc()
raise ImportError(
_(u'Dependency failure: editype "template" requires python library "genshi". Error:\n%s'
% txt))
defmessage = grammar.grammarread(
self.ta_info['editype'], self.ta_info['messagetype']
) #needed because we do not know envelope; read syntax for editype/messagetype
self.ta_info.update(defmessage.syntax)
botslib.tryrunscript(self.userscript,
self.scriptname,
'ta_infocontent',
ta_info=self.ta_info)
if not self.ta_info['envelope-template']:
raise botslib.OutMessageError(_(
u'While enveloping in "$editype.$messagetype": syntax option "envelope-template" not filled; is required.'
),
editype=self.ta_info['editype'],
messagetype=self.
ta_info['messagetype'])
templatefile = botslib.abspath('templateshtml',
self.ta_info['envelope-template'])
ta_list = self.filelist2absolutepaths()
try:
botsglobal.logger.debug(u'Start writing envelope to file "%s".',
self.ta_info['filename'])
loader = TemplateLoader(auto_reload=False)
tmpl = loader.load(templatefile)
except:
txt = botslib.txtexc()
raise botslib.OutMessageError(
_(u'While enveloping in "$editype.$messagetype", error:\n$txt'
),
editype=self.ta_info['editype'],
messagetype=self.ta_info['messagetype'],
txt=txt)
try:
filehandler = botslib.opendata(self.ta_info['filename'], 'wb')
stream = tmpl.generate(data=ta_list)
stream.render(method='xhtml',
encoding=self.ta_info['charset'],
out=filehandler)
except:
txt = botslib.txtexc()
raise botslib.OutMessageError(
_(u'While enveloping in "$editype.$messagetype", error:\n$txt'
),
editype=self.ta_info['editype'],
messagetype=self.ta_info['messagetype'],
txt=txt)
def __init__(self, context, request):
super(ProcessForm, self).__init__(context, request)
formName = request.matchdict['form']
loader = TemplateLoader([os.path.dirname(__file__)])
try:
self.template = loader.load(formName + '.rml')
except TemplateNotFound:
raise HTTPNotFound()
def handle_error_404(status, message, traceback, version):
from urllib import quote
from genshi.template import TemplateLoader, Context
template_loader = TemplateLoader(cherrypy.config.get('tools.genshi_template.dir'))
template = template_loader.load('notfound.html')
context = Context(url=cherrypy.url, quote=quote)
stream = template.generate(context)
return stream.render('xhtml')
def outputEPub(self, rootDir):
ep = epub.EpubBook()
ep.set_lang('zh-CN')
ep.set_title(self.title)
for author in self.authors:
ep.add_creator(author)
for translator in self.translators:
ep.add_creator(translator, 'trl')
loader = TemplateLoader('templates')
tmpl = loader.load(self.TITLE_PAGE_TEMPLATE)
stream = tmpl.generate(lines=self.getTitlePageLines())
html = stream.render('xhtml', doctype='xhtml11', drop_xml_decl=False)
ep.add_title_page(html)
ep.add_toc_page()
ep.add_cover(self.imagePaths[0])
tmpl = loader.load(self.PAGE_TEMPLATE)
for i, imagePath in enumerate(self.imagePaths):
imageItem = ep.add_mage(imagePath, 'img%d.jpg' % (i + 1))
htmlItem = ep.add_html_for_image(imageItem)
ep.add_spine_item(htmlItem)
for k, chapter in enumerate(self.chapters):
stream = tmpl.generate(chapter=chapter)
html = stream.render('xhtml',
doctype='xhtml11',
drop_xml_decl=False)
item = ep.add_html('', 'ch%d.html' % (k + 1), html)
ep.add_spine_item(item)
if chapter.title != '':
ep.add_toc_map_node(item.destPath, chapter.title,
chapter.level)
if self.outputFileName == '':
self.outputFileName = self.title
outputDir = os.path.join(rootDir, self.outputFileName.encode('cp936'))
outputFile = os.path.join(
rootDir,
self.outputFileName.encode('cp936') + '.epub')
ep.create_book(outputDir)
ep.create_archive(outputDir, outputFile)
ep.check_epub('epubcheck-1.1.jar', outputFile)
def deco(*a, **b):
template_dict = func(*a, **b)
if not TvbProfile.current.web.RENDER_HTML:
return template_dict
### Generate HTML given the path to the template and the data dictionary.
loader = TemplateLoader()
template = loader.load(template_path)
stream = template.generate(**template_dict)
return stream.render('xhtml')
class GenshiLoader(): def __init__(self): self.loader = None def __call__(self, filename, dir, auto_reload = False, type = 'xhtml', sitemap_prio = '-1'): from genshi.template import TemplateLoader if self.loader == None: self.loader = TemplateLoader(dir, auto_reload=auto_reload) template = self.loader.load(filename) cherrypy.request.handler = GenshiHandler(template, cherrypy.request.handler, type)
class Book:
def __init__(self):
self.impl = epub.EpubBook()
self.title = ''
self.authors = []
self.cover = ''
#self.lang = 'en-US'
self.lang = 'zh-CN'
self.sections = []
self.templateLoader = TemplateLoader('templates',
default_encoding="utf-8")
def __addSection(self, section, id, depth): #hyjiang
if depth > 0:
stream = self.templateLoader.load(
section.templateFileName).generate(section=section)
#html = stream.render('xhtml', doctype = 'xhtml11', drop_xml_decl = False)
html = stream.render('xhtml', drop_xml_decl=False)
item = self.impl.addHtml('', '%s.xhtml' % id, html)
if section.withImg:
for item2 in section.text:
#print('**********************')
#print(item2)
if type(item2) == type({}):
#print('**********************')
#print(item2['img_src'])
#print(item2['img_dst'])
self.impl.addImage(item2['img_src'], item2['img_dst'])
self.impl.addSpineItem(item)
self.impl.addTocMapNode(item.destPath, section.title, depth)
id += '.'
if len(section.subsections) > 0:
for i, subsection in enumerate(section.subsections):
self.__addSection(subsection, id + str(i + 1), depth + 1)
def make(self, outputDir):
outputFile = outputDir + '.epub'
self.impl.setTitle(self.title)
self.impl.setLang(self.lang)
for author in self.authors:
self.impl.addCreator(author)
if self.cover:
self.impl.addCover(self.cover)
self.impl.addTitlePage()
self.impl.addTocPage()
root = Section()
root.subsections = self.sections
self.__addSection(root, 's', 0)
self.impl.createBook(outputDir)
#self.impl.createArchive(outputDir, outputFile)
self.impl.createEPUB(outputDir, outputFile)
self.impl.checkEpub('epubcheck-1.0.5.jar', outputFile)
def genshi(dirname, verbose=False):
from genshi.template import TemplateLoader
loader = TemplateLoader([dirname], auto_reload=False)
template = loader.load('template.html')
def render():
data = dict(title=TITLE, user=USER, items=ITEMS)
return template.generate(**data).render('xhtml')
if verbose:
print(render())
return render
def genshi(dirname, verbose=False):
from genshi.template import TemplateLoader
loader = TemplateLoader([dirname], auto_reload=False)
template = loader.load('template.html')
def render():
return template.generate(**DATA.copy()).render('xhtml')
if verbose:
pr(render())
return render
