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