def generateHtml(content):
template_name = "ns.html"
template = loader.load(template_name)
# stream = template.generate(unscheduled = UNSCHEDULED, scheduled = SCHEDULED)
stream = template.generate(message=content)
rendered = stream.render('html', doctype='html5')
return rendered
def index(self, default=None):
"""Return the index page."""
template = self._loader.load('index.html')
return template.generate(partner_id='direct',
default=default,
agreements=agreements.handlers).render('xhtml')
def index(self):
query = self.session.query(scicom.mta.material.Material)
materials = query.select()
template = self.__loader.load('material-index.html')
stream = template.generate(materials=materials)
return stream.render('xhtml')
def index(self, default=None):
"""Return the index page."""
template = self._loader.load('index.html')
return template.generate(
partner_id='direct',
default=default,
agreements=agreements.handlers).render('xhtml')
def view(self, id):
# get the Material
query = self.session.query(scicom.mta.material.Material)
material = query.select_by(material_id=id)
# pass the Material off to a template
template = self.__loader.load('material.html')
stream = template.generate(material=material[0])
return stream.render('xhtml')
def __render(self, file):
engine = harkfm.Engine()
template = self.__class__.loader.load(file)
search_path = 'file:///' + self.__class__.loader.search_path[0].replace('\\', '/') + '/'
html = template.generate(
current=engine.current,
lastfm=engine.lfm_props(),
config=harkfm.Storage.config
).render('html', doctype='html')
self.QWebEngineView.setHtml(html, QUrl(search_path))
self.__class__._last_page = file
def generate(dir, xslt, blog_entries, reading_entries, config):
# index
template = template_loader.load('index.html')
rendered = template.generate(blog_entries=blog_entries,
reading_entries=reading_entries,
config=config).render('xhtml')
transformed = str(xslt(lxml.etree.fromstring(rendered)))
constance.output(os.path.join(dir, 'index.html'), transformed)
# firehose
rendered = template_loader.load('firehose.atom').generate(
items=chain(blog_entries, reading_entries),
config=config).render('xml')
constance.output(os.path.join(dir, 'firehose.atom'), rendered)
def iframe(self, partner_id=None, stylesheet=None, default=None):
# partner_id is required
if partner_id is None:
raise MissingParameterException()
# render the template and return the value
template = self._loader.load('iframe.html')
stream = template.generate(partner_id=partner_id,
default=default,
stylesheet=stylesheet,
agreements=agreements.handlers)
return stream.render('xhtml')
def iframe(self, partner_id=None, stylesheet=None, default=None):
# partner_id is required
if partner_id is None:
raise MissingParameterException()
# render the template and return the value
template = self._loader.load('iframe.html')
stream = template.generate(partner_id=partner_id,
default=default,
stylesheet=stylesheet,
agreements=agreements.handlers
)
return stream.render('xhtml')
def rendered_markup_eq_(template_text, **context):
import genshi, genshi.template
chunked_raw = chunk_assertion_blocks(template_text)
if not chunked_raw:
raise AssertionError("No test chunks found in template text.")
template = genshi.template.MarkupTemplate(template_text)
stream = template.generate(**context)
output = stream.render('xhtml')
chunked_output = chunk_assertion_blocks(output)
for idx, label, lhs, rhs in chunked_output:
assert lhs == rhs, "test %s: %r != %r" % (label, lhs, rhs)
eq_(len(chunked_raw), len(chunked_output))
def rendered_markup_eq_(template_text, **context):
import genshi, genshi.template
chunked_raw = chunk_assertion_blocks(template_text)
if not chunked_raw:
raise AssertionError("No test chunks found in template text.")
template = genshi.template.MarkupTemplate(template_text)
stream = template.generate(**context)
output = stream.render('xhtml')
chunked_output = chunk_assertion_blocks(output)
for idx, label, lhs, rhs in chunked_output:
assert lhs == rhs, "test %s: %r != %r" % (label, lhs, rhs)
eq_(len(chunked_raw), len(chunked_output))
def write(file_number, variables):
for number in range(1, 5):
variables.setdefault('summary%d' % number, '.' * 60)
variables.setdefault('id%d' % number, ' ')
variables.setdefault('description%d' % number, '')
svg_filename = 'cards%s.svg' % file_number
pdf_filename = 'cards%s.pdf' % file_number
print 'Creating', svg_filename
output = codecs.open(svg_filename, 'w', 'utf-8')
svg = unicode(template.generate(**variables))
output.write(svg)
output.close()
print 'Creating', pdf_filename
subprocess.check_call(['inkscape', '--export-pdf', pdf_filename, svg_filename])
pdf_filenames.append(pdf_filename)
def generate(self, template, context):
return template.generate(context)
def agreement(self, code, version):
template = self.__loader.load("deed.html")
stream = template.generate(code=code, version=version)
return stream.render("xhtml")
def generate(self, template, context):
from flatland.out.genshi import flatland_filter
return flatland_filter(template.generate(context), context)
def generate(self, template, context):
return template.generate(context)
def index(self):
cherrypy.response.headers['Content-Type'] = 'application/xhtml+xml'
template = self.get_template()
not_watched = lambda m: m.class_ != 'watched'
movies = Index(filter=not_watched)
return template.generate(movies=movies, title="Movies to Watch").render('xml')
def embed_gen(self, debug):
template = self.__loader.load("embed-wizard.html")
stream = template.generate(embedded=True, debug=debug)
lines = stream.render("xhtml").split('\n')
return '\n'.join(map(lambda l: "document.write('%s');" % l.replace("'","\\'"), lines))
def chooser_gen(self, template_file="chooser.html", debug=False, embedded=False):
template = self.__loader.load(template_file)
stream = template.generate(debug=debug, embedded=embedded)
return stream.render("xhtml")
def generate(self, template, context):
from flatland.out.genshi import flatland_filter
return flatland_filter(template.generate(context), context)
def render (self, template, beans) :
template = self.context.template_loader.load (template)
beans['float'] = render_float
return template.generate (** beans) .render ('html', doctype = 'html')
def stats(self):
"""Return the stats page."""
template = self._loader.load('stats.html')
return template.generate(total = self._stats.total(),
counts = self._stats.counts()).render('xhtml')
def stats(self):
"""Return the stats page."""
template = self._loader.load('stats.html')
return template.generate(total=self._stats.total(),
counts=self._stats.counts()).render('xhtml')
dsn = 'rocky2lemma'
plot_db = db.PlotDatabase(model_type, model_region, buffer,
model_year, summary_level,
image_source, image_version, dsn)
metadata = plot_db.get_metadata_field_dictionary(table_name)
ordinal_dict = {}
for key in metadata.keys():
ordinal_dict[metadata[key]['ORDINAL']] = key
for ordinal in sorted(ordinal_dict.keys()):
key = ordinal_dict[ordinal]
yield metadata[key]
if __name__ == '__main__':
#name of database table for which to generate metadata
table_name = sys.argv[1]
#name and path of output xml file containing metadata
out_file = sys.argv[2]
loader = template.TemplateLoader(['C:/code/interpreted_redesign/metadata/templates/'])
template = loader.load('sppsz_all_template.xml')
meta = GenerateMetadata()
#collection = meta.create_metadata_file(table_name)
#stream = template.generate(collection)
stream = template.generate(collection=meta.create_metadata_file(table_name))
out_fh = open(out_file, 'w')
out_fh.write(stream.render('xml'))
def mesh_test(self):
template = self.__loader.load("mesh-test.html")
stream = template.generate()
return stream.render("xhtml")
def legalcode(self, code, version, kwargs):
template = self.__loader.load("legal.html")
stream = template.generate(agreementType=code, version=version, agreementText=self.legaltext(code, version), **kwargs)
return stream.render("xhtml")
def deed(self, code, version, kwargs):
template = self.__loader.load("deed.html")
basecode = self.basecode(code)
# same for all deeds
permissions = [
{'long': 'Use the materials for research that you supervise',
'uri': 'sc:YourResearch'},
{'long': 'Allow others under your supervision to use the materials',
'uri': 'sc:OthersResearch'},
{'long':'Publish the results of your research',
'uri': 'sc:Publish'}]
# default
footer = 'You will acknowledge provider in publications reporting use of the materials.'
legalurl = '/agreements/' + code + "/" + version + '/legalcode'
if code == 'ubmta':
longname = 'Uniform Biological Material Transfer Agreement'
conditions = [
{'long': 'You may not use the materials for clinical purposes.',
'code': 'no-clinical',
'uri': 'sc:Clinical' },
{'long': 'You may only use the materials for teaching and academic research.',
'code': 'nc',
'uri': 'cc:CommercialUse'},
{'long': 'You may not transfer or distribute the materials, except only Modifications to non-profit organizations under the UBMTA. ',
'code': 'no-distribution',
'uri': 'sc:Transfer'},
{'long': 'You will return or destroy materials upon completion of research or expiration of the implementing letter.',
'uri': 'sc:Retention',
'code': 'return'}]
if code == 'sla':
longname = 'Simple Letter Agreement'
conditions = [
{'long': 'You may not use the materials for clinical purposes.',
'code': 'no-clinical',
'uri': 'sc:Clinical'},
{'long': 'You may only use the materials for teaching and academic research.',
'code': 'nc',
'uri': 'cc:CommercialUse'},
{'long': 'You may not transfer or distribute the materials without permission.',
'code': 'no-distribution',
'uri': 'sc:Transfer'}]
# must be sc
splits = code.split('-')
if splits[0] == 'sc':
longname = 'Science Commons Material Transfer Agreement'
fieldStr = 'Limited to %s' % kwargs['fieldSpec'] if kwargs.__contains__('fieldSpec') else None;
footer = ''
conditions = [
{'long': 'You may not use the materials for clinical purposes.',
'code': 'no-clinical',
'uri': 'sc:Clinical'},
{'long': 'You may not use the materials in connection with the sale of a product or service.',
'code': 'nc',
'uri': 'cc:CommercialUse'},
{'long': 'You may not transfer or distribute the materials. ',
'code': 'no-distribution',
'uri': 'sc:Transfer'}]
if splits.__contains__('rp'):
conditions.insert(0, {'long': 'Your use of the materials is restricted to a specific research protocol.',
'code': 'restricted-field',
'extra': fieldStr})
if splits.__contains__('df'):
conditions.insert(0, {'long': 'Your use of the materials is restricted by fields of use.',
'code': 'restricted-field',
'extra': fieldStr
})
if splits.__contains__('ns'):
conditions.append({'long': 'You may not produce additional quantities of the materials.',
'code': 'no-scaling',
'uri': 'sc:ScalingUp'})
if splits.__contains__('rd'):
conditions.append({'long': 'You will return or destroy the materials upon completion of research or the termination of the agreement.',
'uri': 'sc:Retention',
'code': 'return'})
if kwargs.__contains__('endDate'):
conditions.append({'long': 'This agreement terminates on %s' % kwargs['endDate'],
'code': 'end-date'})
stream = template.generate(code=code, version=version, permissions=permissions, conditions=conditions, footer=footer, legalurl=legalurl, longname=longname)
return stream.render("xhtml")
