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 __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 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 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 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 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 _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 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 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 _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 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 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 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 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 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 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(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 _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_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 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, **kwargs):
markup = kwargs.pop("markup")
if markup:
tmpl = MarkupTemplate(self.template_text, encoding="utf-8")
else:
tmpl = NewTextTemplate(self.template_text, encoding="utf-8")
content = tmpl.generate(**kwargs)
print content.render(encoding="utf-8")
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 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 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 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 _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)
def launch(self, session, req):
from tempfile import mkstemp
from os import write,close
import os
run = data.Run(req, time.strftime("%Y-%m-%d %H:%M:%S"))
session.add(run)
session.commit()
try:
JOB_DIR = run.get_job_dir(config.get('Scheduler', 'work_dir'))
os.makedirs(JOB_DIR)
query = objectify.make_instance(req.query, p=objectify.DOM)
cmd = NewTextTemplate(req.app.param_template).generate(**query.__dict__).render('text').strip()
fh = open(JOB_DIR+'/'+config.get('Scheduler', 'cmd_file'),'w')
fh.write(cmd)
fh.close()
files = session.query(data.File).filter(data.File.request == req, data.File.type == 'input')
for f in files:
f.write(JOB_DIR)
pid = self.queue_interface.queue_run(JOB_DIR)
self.running += 1
run.status = 'RUNNING'
run.pid = pid
req.status = 'PROCESSING'
cherrypy.engine.log("Executed run %d, for request %d under PID=%d" % (run.id,req.id,pid))
except:
cherrypy.engine.log("Failed to execute run %d, for request %d." % (run.id,req.id))
cherrypy.engine.log(''.join(traceback.format_exception(*sys.exc_info())))
run.status = 'FAILED'
req.status = 'FAILED'
session.commit()
def get_target_path(self):
tmpl = NewTextTemplate(self._target_path)
stream = tmpl.generate(**self._profile_provider().properties)
return stream.render('text').strip()
def make_command(self, template):
return NewTextTemplate(template).generate(**self.tree.__dict__).render('text').strip()
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 transform(self, template, ctx):
return NewTextTemplate(template).generate(ticket=ctx).render()
def expandText(self, text, page):
tmpl = NewTextTemplate(text)
return tmpl.generate(page.config.makeContext(page))
genshi_tmpl = MarkupTemplate("""
<table xmlns:py="http://genshi.edgewall.org/">
<tr py:for="row in table">
<td py:for="c in row.values()" py:content="c"/>
</tr>
</table>
""")
genshi_tmpl2 = MarkupTemplate("""
<table xmlns:py="http://genshi.edgewall.org/">$table</table>
""")
genshi_text_tmpl = NewTextTemplate("""
<table>
{% for row in table %}<tr>
{% for c in row.values() %}<td>{c}</td>{% end %}
</tr>{% end %}
</table>
""")
if DjangoTemplate:
django_tmpl = DjangoTemplate("""<table>
{% for row in table %}<tr>
{% for col in row.values %}<td>{{ col|escape }}</td>{% endfor %}
</tr>{% endfor %}
</table>
""")
def test_django():
"""Django template"""
context = DjangoContext({'table': table})
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'])
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)
downstreamQueryTemplate = NewTextTemplate('''
PREFIX sio: <http://semanticscience.org/resource/>
PREFIX prov: <http://www.w3.org/ns/prov#>
prefix go: <http://purl.org/obo/owl/GO#GO_>
SELECT distinct ?participant ?participantLabel ?participantType ?target ?targetType ?targetLabel ?interaction ?interactionType ?typeLabel ?probability ?searchEntity ?searchTerm where {
{ let ( ?searchEntity := <${search}>)
let ( ?participant := <${search}> ) }
<${search}> rdfs:label ?searchTerm.
graph ?assertion {
?interaction sio:has-participant <${search}>.
?interaction sio:has-target ?target.
?interaction a ?interactionType.
}
OPTIONAL { ?interactionType rdfs:label ?typeLabel. }
OPTIONAL {
?assertion sio:SIO_000008 [
a sio:SIO_000765;
sio:SIO_000300 ?probability;
].
}
OPTIONAL { <${search}> a ?participantType. }
OPTIONAL { ?target a ?targetType. }
?target rdfs:label ?targetLabel.
<${search}> rdfs:label ?participantLabel.
} LIMIT 10000''')
upstreamQueryTemplate = NewTextTemplate('''
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())
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())
#!/usr/bin/python # -*- encoding: utf-8 -*- import sys, os, glob from genshi.template import NewTextTemplate from api import API if __name__ == "__main__": try: tDir = os.path.dirname(__file__) for tName in glob.glob(os.path.join(tDir, "*.cpp")) + glob.glob(os.path.join(tDir, "*.hpp")): with open(tName) as t, open(os.path.join(os.getcwd(), os.path.basename(tName)), 'w') as f: print >> f, NewTextTemplate(t).generate( api = API(os.path.expanduser(sys.argv[1])) ).render() except IOError as e: print e except IndexError as e: print >> sys.stderr, "Usage: %s <swagger.yaml>" % sys.argv[0]
def build(self, logfile=sys.stderr):
logging.info("Starting Building")
# Por cada paquete generar un directorio de addon.
for k in self.model.iterclass(uml.CPackage):
package = self.model[k]
# Si el paquete es externo no lo construyo.
if package.is_stereotype('external'):
logging.debug("Ignoring external package %s" % package.name)
continue
logging.debug("Building package %s" % package.name)
# Configuro las variables y tags para este paquete
ptag = package.tag
root_classes_obj = package.get_entities(
uml.CClass, no_stereotypes=["wizard", "report"])
wizard_classes_obj = package.get_entities(uml.CClass,
stereotypes=["wizard"])
report_classes_obj = package.get_entities(uml.CClass,
stereotypes=["report"])
root_classes = [(c.xmi_id, c.name) for c in root_classes_obj]
wizard_classes = [(c.xmi_id, c.name) for c in wizard_classes_obj]
report_classes = [(c.xmi_id, c.name) for c in report_classes_obj]
#view_files = [ 'view/%s_view.xml' % name for xml_id, name in root_classes ]
view_files = [
"view/%s_view.xml" % n
for n in self.sort_classes(root_classes_obj)
]
wizard_view_files = [
"wizard/%s_view.xml" % n
for n in self.sort_classes(wizard_classes_obj)
]
wizard_workflow_files = [
'wizard/%s_workflow.xml' % name
for xml_id, name in wizard_classes if len(
list(self.model[xml_id].iter_over_inhereted_attrs(
'statemachines'))[0:1]) > 0
]
menu_files = ['view/%s_menuitem.xml' % package.name]
properties_files = [
"data/%s_properties.xml" % n
for n in self.sort_classes(root_classes_obj)
]
track_files = [
"data/%s_track.xml" % n
for n in self.sort_classes(root_classes_obj)
]
group_files = ['security/%s_group.xml' % package.name]
workflow_files = [
'workflow/%s_workflow.xml' % name
for xml_id, name in root_classes if len(
list(self.model[xml_id].iter_over_inhereted_attrs(
'statemachines'))[0:1]) > 0
]
app_files = ['%s_app.xml' % package.name]
security_files = ['security/ir.model.access.csv']
# Calcula dependencias
dependencies = set([ self.model[ass].name for ass in self.model.iterclass(uml.CPackage) ]) \
- set(['res', 'ir', package.name])
# Construyo los tags
tags = {
'stereotype_dict':
stereotype_dict,
'names':
names,
'escape':
escape,
'quote':
lambda s: escape(s, {
'"': '"',
"'": '"'
}),
'doublequote':
lambda s: escape(s, {"'": '"'}),
'uml':
uml,
'datatype': {
'Boolean': 'boolean',
'Integer': 'integer',
'Float': 'float',
'Char': 'char',
'Text': 'text',
'Date': 'date',
'Datetime': 'datetime',
'Binary': 'binary',
'HTML': 'html',
},
'PACKAGE':
package,
'YEAR':
str(date.today().year),
'MODULE_NAME':
package.name,
'MODULE_LABEL':
ptag.get('label', package.name),
'MODULE_SHORT_DESCRIPTION':
ptag.get('label', '\n').split('\n')[0],
'MODULE_DESCRIPTION':
ptag.get('documentation', 'No documented'),
'MODULE_AUTHOR':
ptag.get('author', 'No author.'),
'MODULE_AUTHOR_EMAIL':
ptag.get('email', 'No email'),
'MODULE_VERSION':
ptag.get('version', 'No version'),
'MODULE_CATEGORY':
ptag.get('category', 'base.module_category_hidden'),
'MODULE_WEBSITE':
ptag.get('website', ''),
'MODULE_LICENSE':
ptag.get('license', 'AGPL-3'),
'MODULE_DEPENDS':
ptag.get('depends', ''),
'MENUES':
self.sort_menues([
cu for cu in self.model.session.query(uml.CUseCase)
if cu.is_stereotype('menu')
]),
'GROUPS':
self.sort_by_gen([
ac for ac in self.model.session.query(uml.CActor)
if ac.is_stereotype('group')
]),
'ROOT_IMPORT':
'\n'.join([
"import %s" % n
for n in self.sort_classes(root_classes_obj)
]),
'WIZARD_IMPORT':
'\n'.join([
"import %s" % n
for n in self.sort_classes(wizard_classes_obj)
]),
'REPORT_IMPORT':
'\n'.join([
"import %s" % n
for n in self.sort_classes(report_classes_obj)
]),
}
tags.update({
'LICENSE_HEADER':
str(
NewTextTemplate(
pkg_resources.resource_stream(
__name__,
os.path.join(
'data', 'licenses',
filter(lambda c: c.isalpha() or c.isdigit(),
tags['MODULE_LICENSE'].lower()) +
'-header.txt')).read()).generate(**tags)),
'MODULE_DICTIONARY':
self.pp.pformat({
'name':
tags['MODULE_SHORT_DESCRIPTION'],
'version':
tags['MODULE_VERSION'],
'author':
tags['MODULE_AUTHOR'],
'category':
tags['MODULE_CATEGORY'],
'website':
tags['MODULE_WEBSITE'],
'license':
tags['MODULE_LICENSE'],
'description':
tags['MODULE_DESCRIPTION'],
'depends':
list(dependencies),
'init_xml': [],
'demo_xml': [],
'update_xml':
group_files + view_files + properties_files + track_files +
workflow_files + security_files + wizard_view_files +
wizard_workflow_files + menu_files,
'test': [],
'active':
False,
'installable':
True,
}),
})
# Copio la estructura basica al nuevo directorio.
source = pkg_resources.resource_filename(
__name__, os.path.join('data', 'template'))
target = os.path.join(self.path, package.name)
logging.info("Copy template structure from: %s to %s" %
(source, target))
shutil.copytree(source,
target,
ignore=shutil.ignore_patterns(
'*CLASS*', '*PACKAGE_*'))
# Rename python files from .py_ to .py.
for root, dirs, files in os.walk(target):
for f in files:
if f[-4:] == '.py_':
# Renombrar este archivo
os.rename(os.path.join(root, f),
os.path.join(root, f[:-4] + '.py'))
# Generate menu file
source_code = os.path.join(source, 'view/PACKAGE_menuitem.xml')
target_code = os.path.join(target,
'view/%s_menuitem.xml' % package.name)
shutil.copy(source_code, target_code)
self.update(tags, target_code)
# Generate groups file
source_code = os.path.join(source, 'security/PACKAGE_group.xml')
target_code = os.path.join(target,
'security/%s_group.xml' % package.name)
shutil.copy(source_code, target_code)
self.update(tags, target_code)
# Proceso el template basico sobre los archivos copiados.
for root, dirs, files in os.walk(target):
for f in files:
self.update(tags, os.path.join(root, f))
# Por cada clase genero un archivo. El archivo lo agrego a la lista de importacion.
for xmi_id, name in root_classes:
# Prepare data
cclass = self.model[xmi_id]
if len(cclass.child_of) > 0:
generalization = cclass.child_of[0]
parent = generalization.parent
extend_parent = generalization.is_extend
else:
parent = None
extend_parent = False
ctag = cclass.tag
tags.update({
'CLASS':
cclass,
'CLASS_EXTEND_PARENT':
extend_parent,
'CLASS_LABEL':
cclass.tag.get('label', name),
'CLASS_MODULE':
parent.package.name
if extend_parent else cclass.package.name,
'CLASS_NAME':
parent.name if extend_parent else name,
'CLASS_PARENT_MODULE':
parent.package.name if parent is not None else None,
'CLASS_PARENT_NAME':
parent.name if parent is not None else None,
'CLASS_DOCUMENTATION':
ctag.get('documentation', None),
'CLASS_ATTRIBUTES': [
m for m in cclass.members
if m.entityclass == 'cattribute'
],
'CLASS_ASSOCIATIONS':
[cclass.all_associations(ctype=uml.CClass, parents=False)],
'MENU_PARENT':
cclass.tag.get('menu_parent', None) or ([
ass.participant.tag['label']
for ass in cclass.associations if type(ass.swap[0]) is
uml.CUseCase and ass.swap[0].is_stereotype('menu')
] + [None])[0],
'MENU_SEQUENCE':
cclass.tag.get('menu_sequence', '100'),
'STEREOTYPES': [s.name for s in cclass.stereotypes],
'tree_types':
lambda c: [''] + (any(
c.all_associations(ctype=uml.CUseCase,
stereotypes=["editable"])
) and ['_edit'] or []) + (any(
c.all_associations(ctype=uml.CUseCase,
stereotypes=["hierarchical"])) and
['_hier'] or []),
})
# Generate class file
source_code = os.path.join(source, 'CLASS.py_')
target_code = os.path.join(target, '%s.py' % name)
shutil.copy(source_code, target_code)
self.update(tags, target_code)
# Generate view file
source_code = os.path.join(source, 'view/CLASS_view.xml')
target_code = os.path.join(target, 'view/%s_view.xml' % name)
shutil.copy(source_code, target_code)
self.update(tags, target_code)
# Generate properties file
source_code = os.path.join(source, 'data/CLASS_properties.xml')
target_code = os.path.join(target,
'data/%s_properties.xml' % name)
shutil.copy(source_code, target_code)
self.update(tags, target_code)
# Generate track file
source_code = os.path.join(source, 'data/CLASS_track.xml')
target_code = os.path.join(target, 'data/%s_track.xml' % name)
shutil.copy(source_code, target_code)
self.update(tags, target_code)
# Generate workflow file
if len(
list(cclass.iter_over_inhereted_attrs('statemachines'))
[0:1]) > 0:
source_code = os.path.join(source,
'workflow/CLASS_workflow.xml')
target_code = os.path.join(
target, 'workflow/%s_workflow.xml' % name)
shutil.copy(source_code, target_code)
self.update(tags, target_code)
# Por cada wizard genero un archivo. El archivo lo agrego a la lista de importacion.
for xmi_id, name in wizard_classes:
# Prepare data
cclass = self.model[xmi_id]
if len(cclass.child_of) > 0:
generalization = cclass.child_of[0]
parent = generalization.parent
extend_parent = generalization.is_extend
else:
parent = None
extend_parent = False
ctag = cclass.tag
tags.update({
'CLASS':
cclass,
'CLASS_EXTEND_PARENT':
extend_parent,
'CLASS_LABEL':
cclass.tag.get('label', name),
'CLASS_MODULE':
parent.package.name
if extend_parent else cclass.package.name,
'CLASS_NAME':
parent.name if extend_parent else name,
'CLASS_PARENT_MODULE':
parent.package.name if parent is not None else None,
'CLASS_PARENT_NAME':
parent.name if parent is not None else None,
'CLASS_DOCUMENTATION':
ctag.get('documentation', None),
'CLASS_ATTRIBUTES': [
m for m in cclass.members
if m.entityclass == 'cattribute'
],
'CLASS_ASSOCIATIONS':
[cclass.all_associations(ctype=uml.CClass, parents=False)],
'MENU_PARENT':
cclass.tag.get('menu_parent', None) or ([
ass.participant.tag['label']
for ass in cclass.associations if type(ass.swap[0]) is
uml.CUseCase and ass.swap[0].is_stereotype('menu')
] + [None])[0],
'MENU_SEQUENCE':
cclass.tag.get('menu_sequence', '100'),
'STEREOTYPES': [s.name for s in cclass.stereotypes],
'tree_types':
lambda c: [''] + (any(
c.all_associations(ctype=uml.CUseCase,
stereotypes=["editable"])
) and ['_edit'] or []) + (any(
c.all_associations(ctype=uml.CUseCase,
stereotypes=["hierarchical"])) and
['_hier'] or []),
})
# Generate class file
source_code = os.path.join(source, 'wizard', 'CLASS.py_')
target_code = os.path.join(target, 'wizard', '%s.py' % name)
shutil.copy(source_code, target_code)
self.update(tags, target_code)
# Generate view file
source_code = os.path.join(source, 'wizard', 'CLASS_view.xml')
target_code = os.path.join(target, 'wizard',
'%s_view.xml' % name)
shutil.copy(source_code, target_code)
self.update(tags, target_code)
# Generate workflow file
source_code = os.path.join(source, 'wizard',
'CLASS_workflow.xml')
target_code = os.path.join(target, 'wizard',
'%s_workflow.xml' % name)
shutil.copy(source_code, target_code)
self.update(tags, target_code)
