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