def create_genshi_raw_report(self, cr, uid, ids, data, report_xml, context=None, output='raw', tmpl=False): def preprocess(data, aeroo_print): aeroo_print.epl_images.reverse() while aeroo_print.epl_images: img = aeroo_print.epl_images.pop() data = data.replace('<binary_data>', img, 1) return data.replace('\n', '\r\n') print_id = context.get('print_id', False) aeroo_print = self.active_prints[print_id] # Aeroo print object if not aeroo_print.start_time: aeroo_print.start_time = time.time() if not context: context={} context = context.copy() objects = self.getObjects_mod(cr, uid, ids, report_xml.report_type, context) oo_parser = self.parser(cr, uid, self.name2, context=context) oo_parser.localcontext.update(context) oo_parser.set_context(objects, data, ids, report_xml.report_type) self.set_xml_data_fields(oo_parser.objects, oo_parser) # Get/Set XML oo_parser.localcontext['data'] = data oo_parser.localcontext['user_lang'] = context.get('lang', False) if len(objects)>0: oo_parser.localcontext['o'] = objects[0] xfunc = ExtraFunctions(cr, uid, report_xml.id, oo_parser.localcontext) oo_parser.localcontext.update(xfunc.functions) model = context.get('active_model', data.get('model')) or data.get('model') rec_id = context.get('active_id', data.get('id')) or data.get('id') file_data = tmpl or context.get('aeroo_tmpl') or \ self.get_other_template(cr, uid, model, rec_id, oo_parser) or report_xml.report_sxw_content # Get other Template if not file_data or file_data=='False': raise osv.except_osv(_('Error!'), _('No template found!')) ################################################ if not file_data: self.logger("End process %s (%s), elapsed time: %s" % (self.name, self.table, time.time() - aeroo_print.start_time), logging.INFO) # debug mode return False, output print_id = context.get('print_id', False) aeroo_print = self.active_prints[print_id] oo_parser.localcontext['include_subreport'] = self._subreport(cr, uid, aeroo_print, output='raw', aeroo_ooo=False, context=context) oo_parser.localcontext['epl2_gw'] = self._epl2_gw(aeroo_print) deferred = context.get('deferred_process') oo_parser.localcontext['progress_update'] = deferred and deferred.progress_update or (lambda:True) aeroo_print.epl_images = [] basic = NewTextTemplate(source=base64.decodestring(file_data)) #try: if genshi_version<='0.6': data = preprocess(basic.generate(**oo_parser.localcontext).render().decode('utf8').encode(report_xml.charset), aeroo_print) else: data = preprocess(basic.generate(**oo_parser.localcontext).render().encode(report_xml.charset), aeroo_print) #except Exception, e: # self.logger(str(e), logging.ERROR) # return False, output if report_xml.content_fname: output = report_xml.content_fname self.logger("End process %s (%s), elapsed time: %s" % (self.name, self.table, time.time() - aeroo_print.start_time), logging.INFO) # debug mode return data, output
def decorate_message(self, event, message, decorates=None): if event.realm == 'ticket': if 'status' in event.changes: action = 'Status -> %s' % (event.target['status']) template = NewTextTemplate( self.ticket_email_subject.encode('utf8')) # Create a fallback for invalid custom Genshi template in option. default_template = NewTextTemplate( Option.registry[ ('announcer', 'ticket_email_subject') ].default.encode('utf8')) try: subject = template.generate( ticket=event.target, event=event, action=event.category ).render('text', encoding=None) except TemplateError: # Use fallback template. subject = default_template.generate( ticket=event.target, event=event, action=event.category ).render('text', encoding=None) prefix = self.config.get('announcer', 'email_subject_prefix') if prefix == '__default__': prefix = '[%s] ' % self.env.project_name if prefix: subject = "%s%s" % (prefix, subject) if event.category != 'created': subject = 'Re: %s' % subject set_header(message, 'Subject', subject) return next_decorator(event, message, decorates)
def decorate_message(self, event, message, decorates=None): if event.realm == 'ticket': if 'status' in event.changes: action = 'Status -> %s' % (event.target['status']) template = NewTextTemplate( self.ticket_email_subject.encode('utf8')) # Create a fallback for invalid custom Genshi template in option. default_template = NewTextTemplate(Option.registry[( 'announcer', 'ticket_email_subject')].default.encode('utf8')) try: subject = template.generate(ticket=event.target, event=event, action=event.category).render( 'text', encoding=None) except TemplateError: # Use fallback template. subject = default_template.generate( ticket=event.target, event=event, action=event.category).render('text', encoding=None) prefix = self.config.get('announcer', 'email_subject_prefix') if prefix == '__default__': prefix = '[%s] ' % self.env.project_name if prefix: subject = "%s%s" % (prefix, subject) if event.category != 'created': subject = 'Re: %s' % subject set_header(message, 'Subject', subject) return next_decorator(event, message, decorates)
def create_genshi_raw_report(self, cr, uid, ids, data, report_xml, context=None, output='raw', tmpl=False): def preprocess(data, aeroo_print): aeroo_print.epl_images.reverse() while aeroo_print.epl_images: img = aeroo_print.epl_images.pop() data = data.replace('<binary_data>', img, 1) return data.replace('\n', '\r\n') print_id = context.get('print_id', False) aeroo_print = self.active_prints[print_id] # Aeroo print object if not aeroo_print.start_time: aeroo_print.start_time = time.time() if not context: context={} context = context.copy() objects = self.getObjects_mod(cr, uid, ids, report_xml.report_type, context) oo_parser = self.parser(cr, uid, self.name2, context=context) oo_parser.localcontext.update(context) oo_parser.set_context(objects, data, ids, report_xml.report_type) self.set_xml_data_fields(oo_parser.objects, oo_parser) # Get/Set XML oo_parser.localcontext['data'] = data oo_parser.localcontext['user_lang'] = context.get('lang', False) if len(objects)>0: oo_parser.localcontext['o'] = objects[0] xfunc = ExtraFunctions(cr, uid, report_xml.id, oo_parser.localcontext) oo_parser.localcontext.update(xfunc.functions) file_data = tmpl or self.get_other_template(cr, uid, data, oo_parser) or report_xml.report_sxw_content # Get other Tamplate if not file_data or file_data=='False': raise osv.except_osv(_('Error!'), _('No template found!')) ################################################ if not file_data: self.logger("End process %s (%s), elapsed time: %s" % (self.name, self.table, time.time() - aeroo_print.start_time), logging.INFO) # debug mode return False, output print_id = context.get('print_id', False) aeroo_print = self.active_prints[print_id] oo_parser.localcontext['include_subreport'] = self._subreport(cr, uid, aeroo_print, output='raw', aeroo_ooo=False, context=context) oo_parser.localcontext['epl2_gw'] = self._epl2_gw(aeroo_print) deferred = context.get('deferred_process') oo_parser.localcontext['progress_update'] = deferred and deferred.progress_update or (lambda:True) aeroo_print.epl_images = [] basic = NewTextTemplate(source=base64.decodestring(file_data)) #try: if genshi_version<='0.6': data = preprocess(basic.generate(**oo_parser.localcontext).render().decode('utf8').encode(report_xml.charset), aeroo_print) else: data = preprocess(basic.generate(**oo_parser.localcontext).render().encode(report_xml.charset), aeroo_print) #except Exception, e: # self.logger(str(e), logging.ERROR) # return False, output if report_xml.content_fname: output = report_xml.content_fname self.logger("End process %s (%s), elapsed time: %s" % (self.name, self.table, time.time() - aeroo_print.start_time), logging.INFO) # debug mode return data, output
def update(self, tags, filename): logging.info('Updating %s' % filename) with open(filename) as stmpl: tmpl = NewTextTemplate(stmpl.read()) stream = tmpl.generate(**tags) with open(filename, 'w') as out: out.write(stream.render())
def convert(inputFile, templateFile, outputFile): def preprocess(x): return x v = { 'delimiter' : ",", 'header' : None, 'footer' : '', 'preamble' : '', 'body' : '', 'skip_rows' : 0, 'process_rows' : 0, 'preprocess':preprocess } execfile(templateFile,{},v) template = NewTextTemplate(v['body']) #print v['preamble'] output = open(outputFile,'wb') output.write(v['preamble']) i = 0 for row in csv.DictReader(open(inputFile),fieldnames = v['header'], delimiter=v['delimiter']): if v['skip_rows'] > 0: print 'skipping', row v['skip_rows'] -= 1 continue i += 1 if v['process_rows'] > 0 and i > v['process_rows']: break row['linenum'] = str(i) row = v['preprocess'](row) if row == None: continue o = template.generate(**row) output.write(o.render()) output.write(v['footer'])
def _process_template(self, template_filename, **kwargs): f = open(os.path.join(self.template_folder, template_filename)) template_text = f.read() template = NewTextTemplate(template_text) f.close() stream = template.generate(**kwargs) return stream.render()
def render_genshi_tmpl(tmplstr, context, tmplpath=None): ''' Render a Genshi template. A method should be passed in as part of the context. If no method is passed in, xml is assumed. Valid methods are: .. code-block: - xml - xhtml - html - text - newtext - oldtext Note that the ``text`` method will call ``NewTextTemplate``. If ``oldtext`` is desired, it must be called explicitly ''' method = context.get('method', 'xml') if method == 'text' or method == 'newtext': from genshi.template import NewTextTemplate tmpl = NewTextTemplate(tmplstr) elif method == 'oldtext': from genshi.template import OldTextTemplate tmpl = OldTextTemplate(tmplstr) else: from genshi.template import MarkupTemplate tmpl = MarkupTemplate(tmplstr) return tmpl.generate(**context).render(method)
def create_genshi_raw_report(self, cr, uid, ids, data, report_xml, context=None, output='raw'): def preprocess(data): self.epl_images.reverse() while self.epl_images: img = self.epl_images.pop() data = data.replace('<binary_data>', img, 1) return data.replace('\n', '\r\n') if context is None: context = {} else: context = context.copy() # get parser and objects oo_parser = self.parser(cr, uid, self.name2, context=context) objects = self.getObjects_mod(cr, uid, ids, report_xml, context, parser=oo_parser) oo_parser.objects = objects self.set_xml_data_fields(objects, oo_parser) # Get/Set XML oo_parser.localcontext['objects'] = objects oo_parser.localcontext['data'] = data oo_parser.localcontext['user_lang'] = context.get('lang', False) if len(objects) > 0: oo_parser.localcontext['o'] = objects[0] xfunc = ExtraFunctions(cr, uid, report_xml.id, oo_parser.localcontext) oo_parser.localcontext.update(xfunc.functions) file_data = self.get_other_template( cr, uid, data, oo_parser) or report_xml.report_sxw_content # Get other Tamplate ################################################ if not file_data: return False, output oo_parser.localcontext['include_subreport'] = self._subreport( cr, uid, output='raw', aeroo_ooo=False, context=context) oo_parser.localcontext['epl2_gw'] = self._epl2_gw self.epl_images = [] basic = NewTextTemplate(source=base64.decodestring(file_data)) data = preprocess( basic.generate( **oo_parser.localcontext).render().decode('utf8').encode( report_xml.charset)) return self._onResult(cr, uid, objects, (data, output), context=context)
def _generate_from_template(self, executable=False, **kwargs): destination = kwargs['destination'] source = kwargs['source'] name = kwargs['name'] output_file = os.path.join(destination, name) with open(source, 'r') as template: template = NewTextTemplate(template) context = Context(name=name, buildout=self.buildout, options=kwargs) try: output = template.generate(context).render() except (TemplateSyntaxError, UndefinedError) as e: raise zc.buildout.UserError( 'Error in template {0:s}:\n{1:s}'.format(name, e.msg)) if executable: output = '#!{0:s}\n{1:s}'.format(sys.executable, output) if executable and sys.platform == 'win32': from pkg_resources import resource_string exe = output_file + '.exe' open(exe, 'wb').write(resource_string('setuptools', 'cli.exe')) output_file = output_file + '-script.py' with open(output_file, 'wb') as outfile: outfile.write(output.encode('utf8')) if executable: self.logger.info('Generated script %r.', name) try: os.chmod(output_file, 493) # 0755 / 0o755 except (AttributeError, os.error): pass else: self.logger.info('Generated file %r.', name)
def render_genshi_tmpl(tmplstr, context, tmplpath=None): """ Render a Genshi template. A method should be passed in as part of the context. If no method is passed in, xml is assumed. Valid methods are: .. code-block: - xml - xhtml - html - text - newtext - oldtext Note that the ``text`` method will call ``NewTextTemplate``. If ``oldtext`` is desired, it must be called explicitly """ method = context.get("method", "xml") if method == "text" or method == "newtext": from genshi.template import NewTextTemplate # pylint: disable=no-name-in-module tmpl = NewTextTemplate(tmplstr) elif method == "oldtext": from genshi.template import OldTextTemplate # pylint: disable=no-name-in-module tmpl = OldTextTemplate(tmplstr) else: from genshi.template import MarkupTemplate # pylint: disable=no-name-in-module tmpl = MarkupTemplate(tmplstr) return tmpl.generate(**context).render(method)
def format_subject(self, transport, realm, style, event): if transport == "email": if realm == "wiki": template = NewTextTemplate(self.wiki_email_subject) return template.generate(page=event.target, event=event, action=event.category).render()
def decorate_message(self, event, message, decorates=None): if event.realm == "blog": template = NewTextTemplate(self.blog_email_subject.encode('utf8')) subject = template.generate(blog=event.blog_post, action=event.category).render( 'text', encoding=None) set_header(message, 'Subject', subject) return next_decorator(event, message, decorates)
def generate(self): inf = open(self.source) tmpl = NewTextTemplate(inf.read()) inf.close() self.maybeMakeParentDir(self.target) self.config.log.action('WRITE', self.target) outf = open(self.target, 'w') print >>outf, tmpl.generate(self.config.makeContext(self)) outf.close()
def format_subject(self, transport, realm, style, event): action = None if transport == "email": if realm == "ticket": if event.changes: if "status" in event.changes: action = "Status -> %s" % (event.target["status"]) template = NewTextTemplate(self.ticket_email_subject) return to_unicode(template.generate(ticket=event.target, event=event, action=action).render())
def decorate_message(self, event, message, decorates=None): if event.realm == "blog": template = NewTextTemplate(self.blog_email_subject.encode('utf8')) subject = template.generate( blog=event.blog_post, action=event.category ).render('text', encoding=None) set_header(message, 'Subject', subject) return next_decorator(event, message, decorates)
def render(self): log.debug("rendering genshi output") from genshi.template import NewTextTemplate if self.tmpl_content: tmpl = NewTextTemplate(self.tmpl_content) res = tmpl.generate(**self.data).render() return res else: log.debug('template content is empty.') return ''
def format_subject(self, transport, realm, style, event): action = None if transport == "email": if realm == "ticket": if event.changes: if 'status' in event.changes: action = 'Status -> %s' % (event.target['status']) template = NewTextTemplate(self.ticket_email_subject) return template.generate(ticket=event.target, event=event, action=action).render()
def _execute(self): from genshi.template import Context, NewTextTemplate from genshi.template.eval import UndefinedError template = NewTextTemplate(self.source) context = Context(parts=self.buildout, options=self.options) try: self.result = template.generate(context).render() except UndefinedError, e: raise zc.buildout.UserError("Error in template %s:\n%s" % (self.input, e.msg))
def render_fragmentTemplate(self,ctx,data): sess = util.getStoreSession(ctx) items = yield sess.getItems(fragmenttype.FragmentType) for item in items: if item.name == self.original.protectedObject.type: fragmentType = item break template = fragmentType.template from genshi.template import NewTextTemplate as TextTemplate tmpl = TextTemplate(fragmentType.template) output = tmpl.generate(**self.original.protectedObject.data) returnValue(T.xml(output.render('text')))
def render_string(config, in_s): '''Render a Genshi template as a string :param config: data dictionary :param in_s: genshi template ''' tmpl = NewTextTemplate(in_s) # older versions of python don't allow unicode keyword arguments # so we have to encode the keys (for best compatibility in the client side tools) config = _encode_unicode_keys(config) return tmpl.generate(**config).render('text').decode('utf8')
def process_script(input_path, output_path): ''' Given an input path, pass the script through genshi with the current gdb context, writing it to the given output path. ''' input_script = open(input_path, 'rt') tmpl = NewTextTemplate(input_script) stream = tmpl.generate(gdb=gdb) output_script = open(output_path, 'wt') output_script.write(stream.render()) output_script.close() input_script.close()
def _execute(self): from genshi.template import Context, NewTextTemplate from genshi.template.eval import UndefinedError template = NewTextTemplate(self.source, filepath=self.input, filename=self.input) context = Context(parts=self.buildout, options=self.options) try: self.result = template.generate(context).render(encoding='utf-8') except UndefinedError, e: raise zc.buildout.UserError("Error in template {}:\{}".format( self.input, e.msg))
def _execute(self): from genshi.template import Context, NewTextTemplate from genshi.template.eval import UndefinedError template = NewTextTemplate( self.source, filepath=self.input, filename=self.input) context = Context(parts=self.buildout, options=self.options) try: self.result = template.generate( context).render(encoding='utf-8') except UndefinedError, e: raise zc.buildout.UserError( "Error in template {}:\{}".format(self.input, e.msg))
def render(genshi_data, saltenv='base', sls='', method='xml', **kws): ''' Render a Genshi template. A method should be passed in as part of the kwargs. If no method is passed in, xml is assumed. Valid methods are: .. code-block: - xml - xhtml - html - text - newtext - oldtext Note that the ``text`` method will call ``NewTextTemplate``. If ``oldtext`` is desired, it must be called explicitly :rtype: A Python data structure ''' if not HAS_LIBS: raise SaltRenderError('Failed to import genshi template') if not isinstance(genshi_data, six.string_types): genshi_data = genshi_data.read() if genshi_data.startswith('#!'): genshi_data = genshi_data[(genshi_data.find('\n') + 1):] if not genshi_data.strip(): return {} if method == 'text' or method == 'newtext': tmpl = NewTextTemplate(genshi_data) elif method == 'oldtext': tmpl = OldTextTemplate(genshi_data) else: tmpl = MarkupTemplate(genshi_data) generated = tmpl.generate(salt=__salt__, grains=__grains__, pillar=__pillar__, opts=__opts__, proxy=__proxy__, saltenv=saltenv, sls=sls, **kws) return generated.render(method)
def render(self, data_dict, template): """ Take a data dictionary and render it using the given template file. Required Arguments: :param data_dict: The data dictionary to render. :param template: The path to the template, after the ``template_module`` or ``template_dirs`` prefix as defined in the application. :returns: str (the rendered template text) """ LOG.debug("rendering output using '%s' as a template." % template) content = self.load_template(template) tmpl = NewTextTemplate(content) return tmpl.generate(**data_dict).render()
def render(self, data_dict, template): """ Take a data dictionary and render it using the given template file. Required Arguments: :param data_dict: The data dictionary to render. :param template: The path to the template, after the ``template_module`` or ``template_dir`` prefix as defined in the application. :returns: str (the rendered template text) """ LOG.debug("rendering output using '%s' as a template." % template) content = self.load_template(template) tmpl = NewTextTemplate(content) return tmpl.generate(**data_dict).render()
def decorate_message(self, event, message, decorates=None): if event.realm == 'wiki': template = NewTextTemplate(self.wiki_email_subject.encode('utf8')) subject = template.generate(page=event.target, event=event, action=event.category).render( 'text', encoding=None) prefix = self.config.get('announcer', 'email_subject_prefix') if prefix == '__default__': prefix = '[%s] ' % self.env.project_name if prefix: subject = "%s%s" % (prefix, subject) if event.category != 'created': subject = 'Re: %s' % subject set_header(message, 'Subject', subject) return next_decorator(event, message, decorates)
def decorate_message(self, event, message, decorates=None): if event.realm == 'wiki': template = NewTextTemplate(self.wiki_email_subject.encode('utf8')) subject = template.generate( page=event.target, event=event, action=event.category ).render('text', encoding=None) prefix = self.config.get('announcer', 'email_subject_prefix') if prefix == '__default__': prefix = '[%s] ' % self.env.project_name if prefix: subject = "%s%s" % (prefix, subject) if event.category != 'created': subject = 'Re: %s' % subject set_header(message, 'Subject', subject) return next_decorator(event, message, decorates)
def create_genshi_raw_report(self, cr, uid, ids, data, report_xml, context=None, output='raw'): def preprocess(data): self.epl_images.reverse() while self.epl_images: img = self.epl_images.pop() data = data.replace('<binary_data>', img, 1) return data.replace('\n', '\r\n') if not context: context={} context = context.copy() objects = self.getObjects_mod(cr, uid, ids, report_xml.report_type, context) oo_parser = self.parser(cr, uid, self.name2, context=context) oo_parser.objects = objects self.set_xml_data_fields(objects, oo_parser) # Get/Set XML oo_parser.localcontext['objects'] = objects oo_parser.localcontext['data'] = data oo_parser.localcontext['user_lang'] = context.get('lang', False) if len(objects)>0: oo_parser.localcontext['o'] = objects[0] xfunc = ExtraFunctions(cr, uid, report_xml.id, oo_parser.localcontext) oo_parser.localcontext.update(xfunc.functions) file_data = self.get_other_template(cr, uid, data, oo_parser) or report_xml.report_sxw_content # Get other Tamplate ################################################ if not file_data: return False, output oo_parser.localcontext['include_subreport'] = self._subreport(cr, uid, output='raw', aeroo_ooo=False, context=context) oo_parser.localcontext['epl2_gw'] = self._epl2_gw self.epl_images = [] basic = NewTextTemplate(source=base64.decodestring(file_data)) #try: data = preprocess(basic.generate(**oo_parser.localcontext).render().decode('utf8').encode(report_xml.charset)) #except Exception, e: # self.logger(str(e), netsvc.LOG_ERROR) # return False, output if report_xml.content_fname: output = report_xml.content_fname return data, output
def render(genshi_data, saltenv="base", sls="", method="xml", **kws): """ Render a Genshi template. A method should be passed in as part of the kwargs. If no method is passed in, xml is assumed. Valid methods are: .. code-block: - xml - xhtml - html - text - newtext - oldtext Note that the ``text`` method will call ``NewTextTemplate``. If ``oldtext`` is desired, it must be called explicitly :rtype: A Python data structure """ if not HAS_LIBS: return {} if not isinstance(genshi_data, str): genshi_data = genshi_data.read() if genshi_data.startswith("#!"): genshi_data = genshi_data[(genshi_data.find("\n") + 1):] if not genshi_data.strip(): return {} if method == "text" or method == "newtext": tmpl = NewTextTemplate(genshi_data) elif method == "oldtext": tmpl = OldTextTemplate(genshi_data) else: tmpl = MarkupTemplate(genshi_data) return tmpl.generate(**kws).render(method)
def render(genshi_data, saltenv='base', sls='', method='xml', **kws): ''' Render a Genshi template. A method should be passed in as part of the kwargs. If no method is passed in, xml is assumed. Valid methods are: .. code-block: - xml - xhtml - html - text - newtext - oldtext Note that the ``text`` method will call ``NewTextTemplate``. If ``oldtext`` is desired, it must be called explicitly :rtype: A Python data structure ''' if not HAS_LIBS: return {} if not isinstance(genshi_data, string_types): genshi_data = genshi_data.read() if genshi_data.startswith('#!'): genshi_data = genshi_data[(genshi_data.find('\n') + 1):] if not genshi_data.strip(): return {} if method == 'text' or method == 'newtext': tmpl = NewTextTemplate(genshi_data) elif method == 'oldtext': tmpl = OldTextTemplate(genshi_data) else: tmpl = MarkupTemplate(genshi_data) return tmpl.generate(**kws).render(method)
def _generate_from_template(self, executable=False, **kwargs): destination = kwargs["destination"] source = kwargs["source"] name = kwargs["name"] output_file = os.path.join(destination, name) with open(source, "r") as template: template = NewTextTemplate(template) context = Context(name=name, buildout=self.buildout, options=kwargs) try: output = template.generate(context).render() except (TemplateSyntaxError, UndefinedError) as e: raise zc.buildout.UserError("Error in template %s:\n%s" % (name, e.msg)) if executable: output = "#!%s\n%s" % (sys.executable, output) if executable and sys.platform == "win32": exe = output_file + ".exe" open(exe, "wb").write(pkg_resources.resource_string("setuptools", "cli.exe")) self.generated.append(exe) output_file = output_file + "-script.py" with open(output_file, "wb") as outfile: outfile.write(output.encode("utf8")) if executable: self.logger.info("Generated script %r.", name) try: os.chmod(output_file, 493) # 0755 / 0o755 except (AttributeError, os.error): pass else: self.logger.info("Generated file %r.", name) self.generated.append(output_file)
Note that the ``text`` method will call ``NewTextTemplate``. If ``oldtext`` is desired, it must be called explicitly :rtype: A Python data structure ''' if not HAS_LIBS: raise SaltRenderError('Failed to import genshi template') if not isinstance(genshi_data, six.string_types): genshi_data = genshi_data.read() if genshi_data.startswith('#!'): genshi_data = genshi_data[(genshi_data.find('\n') + 1):] if not genshi_data.strip(): return {} if method == 'text' or method == 'newtext': tmpl = NewTextTemplate(genshi_data) elif method == 'oldtext': tmpl = OldTextTemplate(genshi_data) else: tmpl = MarkupTemplate(genshi_data) generated = tmpl.generate( salt=__salt__, grains=__grains__, pillar=__pillar__, opts=__opts__, proxy=__proxy__, saltenv=saltenv, sls=sls, **kws) return generated.render(method)
folder = "output" if not exists(folder): mkdir(folder) flattened = [] for key in sorted(missing, reverse = True): if key > localtime(): # ignore items not released yet continue flattened.extend([x for x in missing[key] if x["url"]!=None]) count = len(flattened) perpage = 10 pages = int(math.ceil(count/(perpage*1.0))) print count, pages links = [("1", "index.html")] + [(str(x), "index%03d.html"%x) for x in range(2, pages+1)] for start in range(0, count, perpage): index = (start/perpage) + 1 if index == 1: name = "index.html" else: name = "index%03d.html"%index print flattened[start:start+perpage] nt = NewTextTemplate(file("template.html").read()) open(join(folder,name), "wb").write(nt.generate(albums = flattened[start:start+perpage], links = links, index = str(index)).render())
class TemplateMessage(Message): """ This is a genshi-based template mail renderer. """ # we need the staticmethod to prevent self being bound as first param loader = staticmethod(package("abl.devtools", "")) def __init__(self, **kwargs): """ This is a genshi-based template mail renderer. It derives from L{Message} and introduces three additional keyword-args: - "html" for a MarkupTemplate - "text" for a TextTemplate - "subject" for a TextTemplate to use for the subject The templates are currently always loaded relative to the package:: abl.devtools """ html = kwargs.pop("html", None) text = kwargs.pop("text", None) subject = kwargs.pop("subject", None) super(TemplateMessage, self).__init__(**kwargs) self._html_template = self._text_template = None if html is not None: _, _, inf, _ = self.loader(html) self._html_template = MarkupTemplate(inf) if text is not None: _, _, inf, _ = self.loader(text) self._text_template = NewTextTemplate(inf) else: self._text_template = None if subject is not None: _, _, inf, _ = self.loader(subject) self._subject_template = NewTextTemplate(inf) else: self._subject_template = None def render(self, **values): if self._html_template is not None: self.rich = self._html_template.generate(**values).render('html', doctype='html') if self._text_template is not None: self.plain = self._text_template.generate(**values).render() if self._subject_template is not None: subject = self._subject_template.generate(**values).render() # ensure the subject is just one line subject = " ".join(subject.split("\n")) self.subject = subject def send(self): interface.send(self)
topright = get_pixel(column + 1, row) bottomleft = get_pixel(column, row + 1) bottomright = get_pixel(column + 1, row + 1) return sum([ topleft * (1.0 - col_blend) * (1.0 - row_blend), topright * (col_blend) * (1.0 - row_blend), bottomleft * (1.0 - col_blend) * (row_blend), bottomright * (col_blend) * (row_blend), ]) def color(x, y): r, g, b = rgb(x, y) m = max(r, g, b, vary_color_limit) return '%f %f %f' % (r / m, g / m, b / m) def intensity(x, y): #return max(rgb(x, y)) r, g, b = rgb(x, y) return 0.299 * r + 0.587 * g + 0.114 * b from genshi.template import NewTextTemplate template = NewTextTemplate(open('pipes.rib').read()) data = str(template.generate(sin=math.sin, rng=float_range, **locals())) print data #with open('out.rib', 'w') as stream: # stream.write(data) #subprocess.check_call(['rndr', 'out.rib'])
def get_target_path(self): tmpl = NewTextTemplate(self._target_path) stream = tmpl.generate(**self._profile_provider().properties) return stream.render('text').strip()
def format_subject(self, transport, realm, style, event): if transport == "email": if realm == "wiki": template = NewTextTemplate(self.wiki_email_subject) return to_unicode(template.generate(page=event.target, event=event, action=event.category).render())
def expandText(self, text, page): tmpl = NewTextTemplate(text) return tmpl.generate(page.config.makeContext(page))