def test_load_with_callback(self): fileobj = open(os.path.join(self.dirname, 'tmpl.html'), 'w') try: fileobj.write("""<html> <p>Hello</p> </html>""") finally: fileobj.close() def template_loaded(template): def my_filter(stream, ctxt): for kind, data, pos in stream: if kind is TEXT and data.strip(): data = ', '.join([data, data.lower()]) yield kind, data, pos template.filters.insert(0, my_filter) loader = TemplateLoader([self.dirname], callback=template_loaded) tmpl = loader.load('tmpl.html') self.assertEqual("""<html> <p>Hello, hello</p> </html>""", tmpl.generate().render()) # Make sure the filter is only added once tmpl = loader.load('tmpl.html') self.assertEqual("""<html> <p>Hello, hello</p> </html>""", tmpl.generate().render())
def test_load_with_callback(self): fileobj = open(os.path.join(self.dirname, 'tmpl.html'), 'w') try: fileobj.write("""<html> <p>Hello</p> </html>""") finally: fileobj.close() def template_loaded(template): def my_filter(stream, ctxt): for kind, data, pos in stream: if kind is TEXT and data.strip(): data = ', '.join([data, data.lower()]) yield kind, data, pos template.filters.insert(0, my_filter) loader = TemplateLoader([self.dirname], callback=template_loaded) tmpl = loader.load('tmpl.html') self.assertEqual( """<html> <p>Hello, hello</p> </html>""", tmpl.generate().render(encoding=None)) # Make sure the filter is only added once tmpl = loader.load('tmpl.html') self.assertEqual( """<html> <p>Hello, hello</p> </html>""", tmpl.generate().render(encoding=None))
def test_load_with_explicit_encoding(self): f = open(os.path.join(self.dirname, 'tmpl.html'), 'w') try: f.write(u'<div>\xf6</div>'.encode('iso-8859-1')) finally: f.close() loader = TemplateLoader([self.dirname], default_encoding='utf-8') loader.load('tmpl.html', encoding='iso-8859-1')
def test_load_with_explicit_encoding(self): f = open(os.path.join(self.dirname, "tmpl.html"), "wb") try: f.write(u"<div>\xf6</div>".encode("iso-8859-1")) finally: f.close() loader = TemplateLoader([self.dirname], default_encoding="utf-8") loader.load("tmpl.html", encoding="iso-8859-1")
def test_abspath_include_caching_without_search_path(self): file1 = open(os.path.join(self.dirname, "tmpl1.html"), "w") try: file1.write( """<html xmlns:xi="http://www.w3.org/2001/XInclude"> <xi:include href="tmpl2.html" /> </html>""" ) finally: file1.close() file2 = open(os.path.join(self.dirname, "tmpl2.html"), "w") try: file2.write("""<div>Included</div>""") finally: file2.close() os.mkdir(os.path.join(self.dirname, "sub")) file3 = open(os.path.join(self.dirname, "sub", "tmpl1.html"), "w") try: file3.write( """<html xmlns:xi="http://www.w3.org/2001/XInclude"> <xi:include href="tmpl2.html" /> </html>""" ) finally: file3.close() file4 = open(os.path.join(self.dirname, "sub", "tmpl2.html"), "w") try: file4.write("""<div>Included from sub</div>""") finally: file4.close() loader = TemplateLoader() tmpl1 = loader.load(os.path.join(self.dirname, "tmpl1.html")) self.assertEqual( """<html> <div>Included</div> </html>""", tmpl1.generate().render(encoding=None), ) tmpl2 = loader.load(os.path.join(self.dirname, "sub", "tmpl1.html")) self.assertEqual( """<html> <div>Included from sub</div> </html>""", tmpl2.generate().render(encoding=None), ) assert "tmpl2.html" not in loader._cache
def test_include_expr(self): file1 = open(os.path.join(self.dirname, "tmpl1.txt"), "w") try: file1.write("Included") finally: file1.close() file2 = open(os.path.join(self.dirname, "tmpl2.txt"), "w") try: file2.write( """----- Included data below this line ----- {% include ${'%s.txt' % ('tmpl1',)} %} ----- Included data above this line -----""" ) finally: file2.close() loader = TemplateLoader([self.dirname]) tmpl = loader.load("tmpl2.txt", cls=NewTextTemplate) self.assertEqual( """----- Included data below this line ----- Included ----- Included data above this line -----""", tmpl.generate().render(encoding=None), )
def test_relative_include_samesubdir(self): file1 = open(os.path.join(self.dirname, 'tmpl1.html'), 'w') try: file1.write("""<div>Included tmpl1.html</div>""") finally: file1.close() os.mkdir(os.path.join(self.dirname, 'sub')) file2 = open(os.path.join(self.dirname, 'sub', 'tmpl1.html'), 'w') try: file2.write("""<div>Included sub/tmpl1.html</div>""") finally: file2.close() file3 = open(os.path.join(self.dirname, 'sub', 'tmpl2.html'), 'w') try: file3.write("""<html xmlns:xi="http://www.w3.org/2001/XInclude"> <xi:include href="tmpl1.html" /> </html>""") finally: file3.close() loader = TemplateLoader([self.dirname]) tmpl = loader.load('sub/tmpl2.html') self.assertEqual("""<html> <div>Included sub/tmpl1.html</div> </html>""", tmpl.generate().render())
def test_include_inline_recursive(self): dirname = tempfile.mkdtemp(suffix='genshi_test') try: file1 = open(os.path.join(dirname, 'tmpl1.html'), 'w') try: file1.write( '<div xmlns:xi="http://www.w3.org/2001/XInclude"' ' xmlns:py="http://genshi.edgewall.org/">' '$depth' '<py:with vars="depth = depth + 1">' '<xi:include href="tmpl1.html"' ' py:if="depth < 3"/>' '</py:with>' '</div>' ) finally: file1.close() loader = TemplateLoader([dirname], auto_reload=False) tmpl = loader.load(os.path.join(dirname, 'tmpl1.html')) self.assertEqual( "<div>0<div>1<div>2</div></div></div>", tmpl.generate(depth=0).render(encoding=None)) finally: shutil.rmtree(dirname)
def test_abspath_caching(self): abspath = os.path.join(self.dirname, 'abs') os.mkdir(abspath) file1 = open(os.path.join(abspath, 'tmpl1.html'), 'w') try: file1.write("""<html xmlns:xi="http://www.w3.org/2001/XInclude"> <xi:include href="tmpl2.html" /> </html>""") finally: file1.close() file2 = open(os.path.join(abspath, 'tmpl2.html'), 'w') try: file2.write("""<div>Included from abspath.</div>""") finally: file2.close() searchpath = os.path.join(self.dirname, 'searchpath') os.mkdir(searchpath) file3 = open(os.path.join(searchpath, 'tmpl2.html'), 'w') try: file3.write("""<div>Included from searchpath.</div>""") finally: file3.close() loader = TemplateLoader(searchpath) tmpl1 = loader.load(os.path.join(abspath, 'tmpl1.html')) self.assertEqual( """<html> <div>Included from searchpath.</div> </html>""", tmpl1.generate().render(encoding=None)) assert 'tmpl2.html' in loader._cache
def test_relative_absolute_template_preferred(self): file1 = open(os.path.join(self.dirname, 'tmpl1.html'), 'w') try: file1.write("""<div>Included</div>""") finally: file1.close() os.mkdir(os.path.join(self.dirname, 'sub')) file2 = open(os.path.join(self.dirname, 'sub', 'tmpl1.html'), 'w') try: file2.write("""<div>Included from sub</div>""") finally: file2.close() file3 = open(os.path.join(self.dirname, 'sub', 'tmpl2.html'), 'w') try: file3.write("""<html xmlns:xi="http://www.w3.org/2001/XInclude"> <xi:include href="tmpl1.html" /> </html>""") finally: file3.close() loader = TemplateLoader() tmpl = loader.load( os.path.abspath(os.path.join(self.dirname, 'sub', 'tmpl2.html'))) self.assertEqual( """<html> <div>Included from sub</div> </html>""", tmpl.generate().render(encoding=None))
def test_relative_include_without_search_path_nested(self): file1 = open(os.path.join(self.dirname, 'tmpl1.html'), 'w') try: file1.write("""<div>Included</div>""") finally: file1.close() file2 = open(os.path.join(self.dirname, 'tmpl2.html'), 'w') try: file2.write("""<div xmlns:xi="http://www.w3.org/2001/XInclude"> <xi:include href="tmpl1.html" /> </div>""") finally: file2.close() file3 = open(os.path.join(self.dirname, 'tmpl3.html'), 'w') try: file3.write("""<html xmlns:xi="http://www.w3.org/2001/XInclude"> <xi:include href="tmpl2.html" /> </html>""") finally: file3.close() loader = TemplateLoader() tmpl = loader.load(os.path.join(self.dirname, 'tmpl3.html')) self.assertEqual( """<html> <div> <div>Included</div> </div> </html>""", tmpl.generate().render(encoding=None))
class GenshiRenderer(object): def __init__(self, *a, **k): self.loader = TemplateLoader(*a, **k) def __call__(self, template, args={}, encoding=None): return self.loader.load(template).generate(**args).render( encoding=encoding)
class GenshiRenderer(object): def __init__(self, *a, **k): self.loader = TemplateLoader(*a, **k) def __call__(self, template, args={}, encoding=None): return self.loader.load(template).generate(**args).render(encoding=encoding)
def test_select_included_elements(self): dirname = tempfile.mkdtemp(suffix='genshi_test') try: file1 = open(os.path.join(dirname, 'tmpl1.html'), 'w') try: file1.write("""<li>$item</li>""") finally: file1.close() file2 = open(os.path.join(dirname, 'tmpl2.html'), 'w') try: file2.write("""<html xmlns:xi="http://www.w3.org/2001/XInclude" xmlns:py="http://genshi.edgewall.org/"> <ul py:match="ul">${select('li')}</ul> <ul py:with="items=(1, 2, 3)"> <xi:include href="tmpl1.html" py:for="item in items" /> </ul> </html>""") finally: file2.close() loader = TemplateLoader([dirname]) tmpl = loader.load('tmpl2.html') self.assertEqual("""<html> <ul><li>1</li><li>2</li><li>3</li></ul> </html>""", tmpl.generate().render(encoding=None)) finally: shutil.rmtree(dirname)
def test_relative_include_samesubdir(self): file1 = open(os.path.join(self.dirname, 'tmpl1.html'), 'w') try: file1.write("""<div>Included tmpl1.html</div>""") finally: file1.close() os.mkdir(os.path.join(self.dirname, 'sub')) file2 = open(os.path.join(self.dirname, 'sub', 'tmpl1.html'), 'w') try: file2.write("""<div>Included sub/tmpl1.html</div>""") finally: file2.close() file3 = open(os.path.join(self.dirname, 'sub', 'tmpl2.html'), 'w') try: file3.write("""<html xmlns:xi="http://www.w3.org/2001/XInclude"> <xi:include href="tmpl1.html" /> </html>""") finally: file3.close() loader = TemplateLoader([self.dirname]) tmpl = loader.load('sub/tmpl2.html') self.assertEqual( """<html> <div>Included sub/tmpl1.html</div> </html>""", tmpl.generate().render())
def test_include_inlined_in_loop(self): dirname = tempfile.mkdtemp(suffix='genshi_test') try: file1 = open(os.path.join(dirname, 'tmpl1.html'), 'w') try: file1.write("""<div>Included $idx</div>""") finally: file1.close() file2 = open(os.path.join(dirname, 'tmpl2.html'), 'w') try: file2.write("""<html xmlns:xi="http://www.w3.org/2001/XInclude" xmlns:py="http://genshi.edgewall.org/"> <xi:include href="tmpl1.html" py:for="idx in range(3)" /> </html>""") finally: file2.close() loader = TemplateLoader([dirname], auto_reload=False) tmpl = loader.load('tmpl2.html') self.assertEqual("""<html> <div>Included 0</div><div>Included 1</div><div>Included 2</div> </html>""", tmpl.generate().render(encoding=None)) finally: shutil.rmtree(dirname)
def test_abspath_caching(self): abspath = os.path.join(self.dirname, 'abs') os.mkdir(abspath) file1 = open(os.path.join(abspath, 'tmpl1.html'), 'w') try: file1.write("""<html xmlns:xi="http://www.w3.org/2001/XInclude"> <xi:include href="tmpl2.html" /> </html>""") finally: file1.close() file2 = open(os.path.join(abspath, 'tmpl2.html'), 'w') try: file2.write("""<div>Included from abspath.</div>""") finally: file2.close() searchpath = os.path.join(self.dirname, 'searchpath') os.mkdir(searchpath) file3 = open(os.path.join(searchpath, 'tmpl2.html'), 'w') try: file3.write("""<div>Included from searchpath.</div>""") finally: file3.close() loader = TemplateLoader(searchpath) tmpl1 = loader.load(os.path.join(abspath, 'tmpl1.html')) self.assertEqual("""<html> <div>Included from searchpath.</div> </html>""", tmpl1.generate().render()) assert 'tmpl2.html' in loader._cache
def test_dynamic_include_href(self): dirname = tempfile.mkdtemp(suffix='genshi_test') try: file1 = open(os.path.join(dirname, 'tmpl1.html'), 'w') try: file1.write("""<div>Included</div>""") finally: file1.close() file2 = open(os.path.join(dirname, 'tmpl2.html'), 'w') try: file2.write("""<html xmlns:xi="http://www.w3.org/2001/XInclude" xmlns:py="http://genshi.edgewall.org/"> <xi:include href="${name}.html" /> </html>""") finally: file2.close() loader = TemplateLoader([dirname]) tmpl = loader.load('tmpl2.html') self.assertEqual("""<html> <div>Included</div> </html>""", tmpl.generate(name='tmpl1').render(encoding=None)) finally: shutil.rmtree(dirname)
def test_nested_include_in_fallback(self): dirname = tempfile.mkdtemp(suffix='genshi_test') try: file1 = open(os.path.join(dirname, 'tmpl2.html'), 'w') try: file1.write("""<div>Included</div>""") finally: file1.close() file2 = open(os.path.join(dirname, 'tmpl3.html'), 'w') try: file2.write("""<html xmlns:xi="http://www.w3.org/2001/XInclude"> <xi:include href="tmpl2.html"> <xi:fallback> <xi:include href="tmpl1.html" /> </xi:fallback> </xi:include> </html>""") finally: file2.close() loader = TemplateLoader([dirname]) tmpl = loader.load('tmpl3.html') self.assertEqual("""<html> <div>Included</div> </html>""", tmpl.generate().render(encoding=None)) finally: shutil.rmtree(dirname)
def deco(*a, **b): """ Allow to get the docstring back""" try: ## Un-comment bellow for profiling each request: #import cherrypy.lib.profiler as profiler #p = profiler.Profiler("/Users/lia.domide/TVB/profiler/") #return p.run(profile, template_path, func, *a, **b) template_dict = func(*a, **b) if not cfg.RENDER_HTML: return template_dict ### Generate HTML given the path to the template and the data dictionary. loader = TemplateLoader() template = loader.load(template_path) stream = template.generate(**template_dict) return stream.render('xhtml') except Exception, excep: if isinstance(excep, cherrypy.HTTPRedirect): raise excep get_logger("tvb.interface.web.controllers.basecontroller" ).exception(excep) set_error_message( "An unexpected exception appeared. Please contact your system administrator." ) raise cherrypy.HTTPRedirect("/tvb?error=True")
def test_include_inlined(self): dirname = tempfile.mkdtemp(suffix='genshi_test') try: file1 = open(os.path.join(dirname, 'tmpl1.html'), 'w') try: file1.write("""<div>Included</div>""") finally: file1.close() file2 = open(os.path.join(dirname, 'tmpl2.html'), 'w') try: file2.write("""<html xmlns:xi="http://www.w3.org/2001/XInclude" xmlns:py="http://genshi.edgewall.org/"> <xi:include href="tmpl1.html" /> </html>""") finally: file2.close() loader = TemplateLoader([dirname], auto_reload=False) tmpl = loader.load('tmpl2.html') # if not inlined the following would be 5 self.assertEqual(7, len(tmpl.stream)) self.assertEqual("""<html> <div>Included</div> </html>""", tmpl.generate().render(encoding=None)) finally: shutil.rmtree(dirname)
def test_relative_include_without_search_path_nested(self): file1 = open(os.path.join(self.dirname, 'tmpl1.html'), 'w') try: file1.write("""<div>Included</div>""") finally: file1.close() file2 = open(os.path.join(self.dirname, 'tmpl2.html'), 'w') try: file2.write("""<div xmlns:xi="http://www.w3.org/2001/XInclude"> <xi:include href="tmpl1.html" /> </div>""") finally: file2.close() file3 = open(os.path.join(self.dirname, 'tmpl3.html'), 'w') try: file3.write("""<html xmlns:xi="http://www.w3.org/2001/XInclude"> <xi:include href="tmpl2.html" /> </html>""") finally: file3.close() loader = TemplateLoader() tmpl = loader.load(os.path.join(self.dirname, 'tmpl3.html')) self.assertEqual("""<html> <div> <div>Included</div> </div> </html>""", tmpl.generate().render())
def test_relative_absolute_template_preferred(self): file1 = open(os.path.join(self.dirname, 'tmpl1.html'), 'w') try: file1.write("""<div>Included</div>""") finally: file1.close() os.mkdir(os.path.join(self.dirname, 'sub')) file2 = open(os.path.join(self.dirname, 'sub', 'tmpl1.html'), 'w') try: file2.write("""<div>Included from sub</div>""") finally: file2.close() file3 = open(os.path.join(self.dirname, 'sub', 'tmpl2.html'), 'w') try: file3.write("""<html xmlns:xi="http://www.w3.org/2001/XInclude"> <xi:include href="tmpl1.html" /> </html>""") finally: file3.close() loader = TemplateLoader() tmpl = loader.load(os.path.abspath(os.path.join(self.dirname, 'sub', 'tmpl2.html'))) self.assertEqual("""<html> <div>Included from sub</div> </html>""", tmpl.generate().render())
def test_relative_include_parentdir(self): file1 = open(os.path.join(self.dirname, "tmpl1.html"), "w") try: file1.write("""<div>Included</div>""") finally: file1.close() os.mkdir(os.path.join(self.dirname, "sub")) file2 = open(os.path.join(self.dirname, "sub", "tmpl2.html"), "w") try: file2.write( """<html xmlns:xi="http://www.w3.org/2001/XInclude"> <xi:include href="../tmpl1.html" /> </html>""" ) finally: file2.close() loader = TemplateLoader([self.dirname]) tmpl = loader.load("sub/tmpl2.html") self.assertEqual( """<html> <div>Included</div> </html>""", tmpl.generate().render(encoding=None), )
def test_prefix_delegation_to_directories_with_subdirs(self): """ Test prefix delegation with the following layout: templates/foo.html sub1/templates/tmpl1.html sub1/templates/tmpl2.html sub1/templates/bar/tmpl3.html Where sub1 is a prefix, and tmpl1.html includes all the others. """ dir1 = os.path.join(self.dirname, 'templates') os.mkdir(dir1) file1 = open(os.path.join(dir1, 'foo.html'), 'w') try: file1.write("""<div>Included foo</div>""") finally: file1.close() dir2 = os.path.join(self.dirname, 'sub1', 'templates') os.makedirs(dir2) file2 = open(os.path.join(dir2, 'tmpl1.html'), 'w') try: file2.write("""<html xmlns:xi="http://www.w3.org/2001/XInclude"> <xi:include href="../foo.html" /> from sub1 <xi:include href="tmpl2.html" /> from sub1 <xi:include href="bar/tmpl3.html" /> from sub1 </html>""") finally: file2.close() file3 = open(os.path.join(dir2, 'tmpl2.html'), 'w') try: file3.write("""<div>tmpl2</div>""") finally: file3.close() dir3 = os.path.join(self.dirname, 'sub1', 'templates', 'bar') os.makedirs(dir3) file4 = open(os.path.join(dir3, 'tmpl3.html'), 'w') try: file4.write("""<div>bar/tmpl3</div>""") finally: file4.close() loader = TemplateLoader([ dir1, TemplateLoader.prefixed(sub1=os.path.join(dir2), sub2=os.path.join(dir3)) ]) tmpl = loader.load('sub1/tmpl1.html') self.assertEqual( """<html> <div>Included foo</div> from sub1 <div>tmpl2</div> from sub1 <div>bar/tmpl3</div> from sub1 </html>""", tmpl.generate().render(encoding=None))
def test_prefix_delegation_to_directories_with_subdirs(self): """ Test prefix delegation with the following layout: templates/foo.html sub1/templates/tmpl1.html sub1/templates/tmpl2.html sub1/templates/bar/tmpl3.html Where sub1 is a prefix, and tmpl1.html includes all the others. """ dir1 = os.path.join(self.dirname, "templates") os.mkdir(dir1) file1 = open(os.path.join(dir1, "foo.html"), "w") try: file1.write("""<div>Included foo</div>""") finally: file1.close() dir2 = os.path.join(self.dirname, "sub1", "templates") os.makedirs(dir2) file2 = open(os.path.join(dir2, "tmpl1.html"), "w") try: file2.write( """<html xmlns:xi="http://www.w3.org/2001/XInclude"> <xi:include href="../foo.html" /> from sub1 <xi:include href="tmpl2.html" /> from sub1 <xi:include href="bar/tmpl3.html" /> from sub1 </html>""" ) finally: file2.close() file3 = open(os.path.join(dir2, "tmpl2.html"), "w") try: file3.write("""<div>tmpl2</div>""") finally: file3.close() dir3 = os.path.join(self.dirname, "sub1", "templates", "bar") os.makedirs(dir3) file4 = open(os.path.join(dir3, "tmpl3.html"), "w") try: file4.write("""<div>bar/tmpl3</div>""") finally: file4.close() loader = TemplateLoader([dir1, TemplateLoader.prefixed(sub1=os.path.join(dir2), sub2=os.path.join(dir3))]) tmpl = loader.load("sub1/tmpl1.html") self.assertEqual( """<html> <div>Included foo</div> from sub1 <div>tmpl2</div> from sub1 <div>bar/tmpl3</div> from sub1 </html>""", tmpl.generate().render(encoding=None), )
def test_abspath_include_caching_without_search_path(self): file1 = open(os.path.join(self.dirname, 'tmpl1.html'), 'w') try: file1.write("""<html xmlns:xi="http://www.w3.org/2001/XInclude"> <xi:include href="tmpl2.html" /> </html>""") finally: file1.close() file2 = open(os.path.join(self.dirname, 'tmpl2.html'), 'w') try: file2.write("""<div>Included</div>""") finally: file2.close() os.mkdir(os.path.join(self.dirname, 'sub')) file3 = open(os.path.join(self.dirname, 'sub', 'tmpl1.html'), 'w') try: file3.write("""<html xmlns:xi="http://www.w3.org/2001/XInclude"> <xi:include href="tmpl2.html" /> </html>""") finally: file3.close() file4 = open(os.path.join(self.dirname, 'sub', 'tmpl2.html'), 'w') try: file4.write("""<div>Included from sub</div>""") finally: file4.close() loader = TemplateLoader() tmpl1 = loader.load(os.path.join(self.dirname, 'tmpl1.html')) self.assertEqual( """<html> <div>Included</div> </html>""", tmpl1.generate().render(encoding=None)) tmpl2 = loader.load(os.path.join(self.dirname, 'sub', 'tmpl1.html')) self.assertEqual( """<html> <div>Included from sub</div> </html>""", tmpl2.generate().render(encoding=None)) assert 'tmpl2.html' not in loader._cache
def test_nested_include_matches(self): # See ticket #157 dirname = tempfile.mkdtemp(suffix='genshi_test') try: file1 = open(os.path.join(dirname, 'tmpl1.html'), 'w') try: file1.write( """<html xmlns:py="http://genshi.edgewall.org/" py:strip=""> <div class="target">Some content.</div> </html>""") finally: file1.close() file2 = open(os.path.join(dirname, 'tmpl2.html'), 'w') try: file2.write("""<html xmlns:py="http://genshi.edgewall.org/" xmlns:xi="http://www.w3.org/2001/XInclude"> <body> <h1>Some full html document that includes file1.html</h1> <xi:include href="tmpl1.html" /> </body> </html>""") finally: file2.close() file3 = open(os.path.join(dirname, 'tmpl3.html'), 'w') try: file3.write("""<html xmlns:py="http://genshi.edgewall.org/" xmlns:xi="http://www.w3.org/2001/XInclude" py:strip=""> <div py:match="div[@class='target']" py:attrs="select('@*')"> Some added stuff. ${select('*|text()')} </div> <xi:include href="tmpl2.html" /> </html> """) finally: file3.close() loader = TemplateLoader([dirname]) tmpl = loader.load('tmpl3.html') self.assertEqual( """ <html> <body> <h1>Some full html document that includes file1.html</h1> <div class="target"> Some added stuff. Some content. </div> </body> </html> """, tmpl.generate().render(encoding=None)) finally: shutil.rmtree(dirname)
def _template2string(template_specification): """ Here we use the TemplateLoader from Genshi, so we are linked to this library for comparison. """ template_specification[common.KEY_SHOW_ONLINE_HELP] = False path_to_form = os.path.join(os.path.dirname(root_html.__file__), 'genericAdapterFormFields.html') loader = TemplateLoader() template = loader.load(path_to_form) stream = template.generate(**template_specification) return stream.render('xhtml').replace('\n', '\t').replace('\'', '"')
def profile(template_path, func, *a, **b): """ Wrapping function, used when profiling. We duplicate the code here, in a separate function, to help profiling, but for the runtime process we do not want a separate call, to increase time. """ template_dict = func(*a, **b) ### Generate HTML given the path to the template and the data dictionary. loader = TemplateLoader() template = loader.load(template_path) stream = template.generate(**template_dict) return stream.render('xhtml')
def test_nested_include_matches(self): # See ticket #157 dirname = tempfile.mkdtemp(suffix='genshi_test') try: file1 = open(os.path.join(dirname, 'tmpl1.html'), 'w') try: file1.write("""<html xmlns:py="http://genshi.edgewall.org/" py:strip=""> <div class="target">Some content.</div> </html>""") finally: file1.close() file2 = open(os.path.join(dirname, 'tmpl2.html'), 'w') try: file2.write("""<html xmlns:py="http://genshi.edgewall.org/" xmlns:xi="http://www.w3.org/2001/XInclude"> <body> <h1>Some full html document that includes file1.html</h1> <xi:include href="tmpl1.html" /> </body> </html>""") finally: file2.close() file3 = open(os.path.join(dirname, 'tmpl3.html'), 'w') try: file3.write("""<html xmlns:py="http://genshi.edgewall.org/" xmlns:xi="http://www.w3.org/2001/XInclude" py:strip=""> <div py:match="div[@class='target']" py:attrs="select('@*')"> Some added stuff. ${select('*|text()')} </div> <xi:include href="tmpl2.html" /> </html> """) finally: file3.close() loader = TemplateLoader([dirname]) tmpl = loader.load('tmpl3.html') self.assertEqual(""" <html> <body> <h1>Some full html document that includes file1.html</h1> <div class="target"> Some added stuff. Some content. </div> </body> </html> """, tmpl.generate().render(encoding=None)) finally: shutil.rmtree(dirname)
def generate_appearance_css(settings, cache_dir=None): """Generate the custom appearance.css file, overwriting if it exists. :param settings: A list of settings key-value tuples. :param cache_dir: Path to the data directory. Optional if the ``pylons.config`` Stacked Object Proxy is available (ie. during the life of a request, but not during websetup or init). :raises TypeError: If cache_dir is not provided and cannot be found. :raises ValueError: If the cache_dir does not exist. """ if cache_dir is None: cache_dir = pylons.config['pylons.cache_dir'] if not os.path.exists(cache_dir): raise ValueError('No valid cache dir provided.') appearance_dir = os.path.join(cache_dir, 'appearance') css_path = os.path.join(appearance_dir, 'appearance.css') vars = dict((k.encode('utf-8'), v.encode('utf-8')) for k, v in settings if k.startswith('appearance_')) vars['uikit_colors'] = uikit_colors[ vars['appearance_navigation_bar_color']] vars['navbar_color'] = vars['appearance_navigation_bar_color'] if vars['appearance_logo']: logo_path = os.path.join(appearance_dir, vars['appearance_logo']) if os.path.exists(logo_path): vars['logo_height'] = Image.open(logo_path).size[1] vars['logo_name'] = vars['appearance_logo'] else: vars['appearance_logo'] = False # Create a simple template loader instead of using # mediadrop.lib.templating.render because that function only works # within the context of a request, when the pylons magic globals # have been populated. tmpl_loader = TemplateLoader([os.path.join(here, 'templates')]) tmpl = tmpl_loader.load('appearance.css', cls=NewTextTemplate) css = tmpl.generate(**vars).render('text') warning = ('/*\n' ' * This file is automatically generated by MediaDrop.\n' ' * Please do not edit this file directly.\n' ' */\n\n') css_file = open(css_path, 'w') css_file.write(warning + css) css_file.close()
def test_error_when_include_not_found(self): dirname = tempfile.mkdtemp(suffix='genshi_test') try: file2 = open(os.path.join(dirname, 'tmpl2.html'), 'w') try: file2.write("""<html xmlns:xi="http://www.w3.org/2001/XInclude"> <xi:include href="tmpl1.html"/> </html>""") finally: file2.close() loader = TemplateLoader([dirname], auto_reload=True) tmpl = loader.load('tmpl2.html') self.assertRaises(TemplateNotFound, tmpl.generate().render) finally: shutil.rmtree(dirname)
def _load_template_snippet(self, filename, data=None): """ Load a genshi template snippet from a file then apply the snippet to any supplied context data. :param filename: the name of the file containing the template snippet :param data: a dictionary of data to which the loaded template snippet may be applied The returned object is a Genshi Markup event stream, containing the HTML generated by applying the template snippet to any supplied context data. """ loader = TemplateLoader(search_path=resource_filename(__name__, 'templates')) template = loader.load(filename) return template.generate(data=data)
def test_prefix_delegation_to_directories(self): """ Test prefix delegation with the following layout: templates/foo.html sub1/templates/tmpl1.html sub2/templates/tmpl2.html Where sub1 and sub2 are prefixes, and both tmpl1.html and tmpl2.html incldue foo.html. """ dir1 = os.path.join(self.dirname, 'templates') os.mkdir(dir1) file1 = open(os.path.join(dir1, 'foo.html'), 'w') try: file1.write("""<div>Included foo</div>""") finally: file1.close() dir2 = os.path.join(self.dirname, 'sub1', 'templates') os.makedirs(dir2) file2 = open(os.path.join(dir2, 'tmpl1.html'), 'w') try: file2.write("""<html xmlns:xi="http://www.w3.org/2001/XInclude"> <xi:include href="../foo.html" /> from sub1 </html>""") finally: file2.close() dir3 = os.path.join(self.dirname, 'sub2', 'templates') os.makedirs(dir3) file3 = open(os.path.join(dir3, 'tmpl2.html'), 'w') try: file3.write("""<div>tmpl2</div>""") finally: file3.close() loader = TemplateLoader([dir1, TemplateLoader.prefixed( sub1 = dir2, sub2 = dir3 )]) tmpl = loader.load('sub1/tmpl1.html') self.assertEqual("""<html> <div>Included foo</div> from sub1 </html>""", tmpl.generate().render())
def test_fallback_when_auto_reload_true(self): dirname = tempfile.mkdtemp(suffix='genshi_test') try: file2 = open(os.path.join(dirname, 'tmpl2.html'), 'w') try: file2.write("""<html xmlns:xi="http://www.w3.org/2001/XInclude"> <xi:include href="tmpl1.html"><xi:fallback> Missing</xi:fallback></xi:include> </html>""") finally: file2.close() loader = TemplateLoader([dirname], auto_reload=True) tmpl = loader.load('tmpl2.html') self.assertEqual("""<html> Missing </html>""", tmpl.generate().render(encoding=None)) finally: shutil.rmtree(dirname)
def test_include(self): file1 = open(os.path.join(self.dirname, 'tmpl1.txt'), 'w') try: file1.write("Included") finally: file1.close() file2 = open(os.path.join(self.dirname, 'tmpl2.txt'), 'w') try: file2.write("""----- Included data below this line ----- {% include tmpl1.txt %} ----- Included data above this line -----""") finally: file2.close() loader = TemplateLoader([self.dirname]) tmpl = loader.load('tmpl2.txt', cls=NewTextTemplate) self.assertEqual("""----- Included data below this line ----- Included ----- Included data above this line -----""", tmpl.generate().render())
def deco(*a, **b): try: ## Un-comment bellow for profiling each request: #import cherrypy.lib.profiler as profiler #p = profiler.Profiler("/Users/lia.domide/TVB/profiler/") #return p.run(profile, template_path, func, *a, **b) template_dict = func(*a, **b) if not cfg.RENDER_HTML: return template_dict ### Generate HTML given the path to the template and the data dictionary. loader = TemplateLoader() template = loader.load(template_path) stream = template.generate(**template_dict) return stream.render('xhtml') except Exception, excep: if isinstance(excep, cherrypy.HTTPRedirect): raise get_logger("tvb.interface.web.controllers.base_controller").exception(excep) set_error_message("An unexpected exception appeared. Please contact your system administrator.") raise cherrypy.HTTPRedirect("/tvb?error=True")
def test_include(self): file1 = open(os.path.join(self.dirname, 'tmpl1.txt'), 'wb') try: file1.write(u"Included\n".encode("utf-8")) finally: file1.close() file2 = open(os.path.join(self.dirname, 'tmpl2.txt'), 'wb') try: file2.write(u"""----- Included data below this line ----- #include tmpl1.txt ----- Included data above this line -----""".encode("utf-8")) finally: file2.close() loader = TemplateLoader([self.dirname]) tmpl = loader.load('tmpl2.txt', cls=OldTextTemplate) self.assertEqual("""----- Included data below this line ----- Included ----- Included data above this line -----""", tmpl.generate().render(encoding=None))
def test_include_fallback_with_directive(self): dirname = tempfile.mkdtemp(suffix='genshi_test') try: file2 = open(os.path.join(dirname, 'tmpl2.html'), 'w') try: file2.write("""<html xmlns:xi="http://www.w3.org/2001/XInclude" xmlns:py="http://genshi.edgewall.org/"> <xi:include href="tmpl1.html"><xi:fallback> <py:if test="True">tmpl1.html not found</py:if> </xi:fallback></xi:include> </html>""") finally: file2.close() loader = TemplateLoader([dirname]) tmpl = loader.load('tmpl2.html') self.assertEqual("""<html> tmpl1.html not found </html>""", tmpl.generate(debug=True).render(encoding=None)) finally: shutil.rmtree(dirname)
def test_include_expr(self): file1 = open(os.path.join(self.dirname, 'tmpl1.txt'), 'wb') try: file1.write(u"Included".encode("utf-8")) finally: file1.close() file2 = open(os.path.join(self.dirname, 'tmpl2.txt'), 'wb') try: file2.write(u"""----- Included data below this line ----- {% include ${'%s.txt' % ('tmpl1',)} %} ----- Included data above this line -----""".encode("utf-8")) finally: file2.close() loader = TemplateLoader([self.dirname]) tmpl = loader.load('tmpl2.txt', cls=NewTextTemplate) self.assertEqual( """----- Included data below this line ----- Included ----- Included data above this line -----""", tmpl.generate().render(encoding=None))
def test_include(self): file1 = open(os.path.join(self.dirname, 'tmpl1.txt'), 'w') try: file1.write("Included\n") finally: file1.close() file2 = open(os.path.join(self.dirname, 'tmpl2.txt'), 'w') try: file2.write("""----- Included data below this line ----- #include tmpl1.txt ----- Included data above this line -----""") finally: file2.close() loader = TemplateLoader([self.dirname]) tmpl = loader.load('tmpl2.txt', cls=OldTextTemplate) self.assertEqual( """----- Included data below this line ----- Included ----- Included data above this line -----""", tmpl.generate().render())
class AbstractTemplateEnginePlugin(object): """Implementation of the plugin API.""" template_class = None extension = None def __init__(self, extra_vars_func=None, options=None): self.get_extra_vars = extra_vars_func if options is None: options = {} self.options = options self.default_encoding = options.get('genshi.default_encoding', None) auto_reload = options.get('genshi.auto_reload', '1') if isinstance(auto_reload, basestring): auto_reload = auto_reload.lower() in ('1', 'on', 'yes', 'true') search_path = [p for p in options.get('genshi.search_path', '').split(':') if p] self.use_package_naming = not search_path try: max_cache_size = int(options.get('genshi.max_cache_size', 25)) except ValueError: raise ConfigurationError('Invalid value for max_cache_size: "%s"' % options.get('genshi.max_cache_size')) loader_callback = options.get('genshi.loader_callback', None) if loader_callback and not hasattr(loader_callback, '__call__'): raise ConfigurationError('loader callback must be a function') lookup_errors = options.get('genshi.lookup_errors', 'strict') if lookup_errors not in ('lenient', 'strict'): raise ConfigurationError('Unknown lookup errors mode "%s"' % lookup_errors) try: allow_exec = bool(options.get('genshi.allow_exec', True)) except ValueError: raise ConfigurationError('Invalid value for allow_exec "%s"' % options.get('genshi.allow_exec')) self.loader = TemplateLoader([p for p in search_path if p], auto_reload=auto_reload, max_cache_size=max_cache_size, default_class=self.template_class, variable_lookup=lookup_errors, allow_exec=allow_exec, callback=loader_callback) def load_template(self, templatename, template_string=None): """Find a template specified in python 'dot' notation, or load one from a string. """ if template_string is not None: return self.template_class(template_string) if self.use_package_naming: divider = templatename.rfind('.') if divider >= 0: from pkg_resources import resource_filename package = templatename[:divider] basename = templatename[divider + 1:] + self.extension templatename = resource_filename(package, basename) return self.loader.load(templatename) def _get_render_options(self, format=None, fragment=False): if format is None: format = self.default_format kwargs = {'method': format} if self.default_encoding: kwargs['encoding'] = self.default_encoding return kwargs def render(self, info, format=None, fragment=False, template=None): """Render the template to a string using the provided info.""" kwargs = self._get_render_options(format=format, fragment=fragment) return self.transform(info, template).render(**kwargs) def transform(self, info, template): """Render the output to an event stream.""" if not isinstance(template, Template): template = self.load_template(template) return template.generate(**info)
class Template(DirectiveFactory): """Abstract template base class. This class implements most of the template processing model, but does not specify the syntax of templates. """ EXEC = StreamEventKind('EXEC') """Stream event kind representing a Python code suite to execute.""" EXPR = StreamEventKind('EXPR') """Stream event kind representing a Python expression.""" INCLUDE = StreamEventKind('INCLUDE') """Stream event kind representing the inclusion of another template.""" SUB = StreamEventKind('SUB') """Stream event kind representing a nested stream to which one or more directives should be applied. """ serializer = None _number_conv = str # function used to convert numbers to event data def __init__(self, source, filepath=None, filename=None, loader=None, encoding=None, lookup='strict', allow_exec=True): """Initialize a template from either a string, a file-like object, or an already parsed markup stream. :param source: a string, file-like object, or markup stream to read the template from :param filepath: the absolute path to the template file :param filename: the path to the template file relative to the search path :param loader: the `TemplateLoader` to use for loading included templates :param encoding: the encoding of the `source` :param lookup: the variable lookup mechanism; either "strict" (the default), "lenient", or a custom lookup class :param allow_exec: whether Python code blocks in templates should be allowed :note: Changed in 0.5: Added the `allow_exec` argument """ self.filepath = filepath or filename self.filename = filename self.loader = loader self.lookup = lookup self.allow_exec = allow_exec self._init_filters() self._init_loader() self._prepared = False if not isinstance(source, Stream) and not hasattr(source, 'read'): if isinstance(source, str): source = StringIO(source) else: source = BytesIO(source) try: self._stream = self._parse(source, encoding) except ParseError as e: raise TemplateSyntaxError(e.msg, self.filepath, e.lineno, e.offset) def __getstate__(self): state = self.__dict__.copy() state['filters'] = [] return state def __setstate__(self, state): self.__dict__ = state self._init_filters() def __repr__(self): return '<%s "%s">' % (type(self).__name__, self.filename) def _init_filters(self): self.filters = [self._flatten, self._include] def _init_loader(self): if self.loader is None: from genshi.template.loader import TemplateLoader if self.filename: if self.filepath != self.filename: basedir = os.path.normpath( self.filepath)[:-len(os.path.normpath(self.filename))] else: basedir = os.path.dirname(self.filename) else: basedir = '.' self.loader = TemplateLoader([os.path.abspath(basedir)]) @property def stream(self): if not self._prepared: self._prepare_self() return self._stream def _parse(self, source, encoding): """Parse the template. The parsing stage parses the template and constructs a list of directives that will be executed in the render stage. The input is split up into literal output (text that does not depend on the context data) and directives or expressions. :param source: a file-like object containing the XML source of the template, or an XML event stream :param encoding: the encoding of the `source` """ raise NotImplementedError def _prepare_self(self, inlined=None): if not self._prepared: self._stream = list(self._prepare(self._stream, inlined)) self._prepared = True def _prepare(self, stream, inlined): """Call the `attach` method of every directive found in the template. :param stream: the event stream of the template """ from genshi.template.loader import TemplateNotFound if inlined is None: inlined = set((self.filepath, )) for kind, data, pos in stream: if kind is SUB: directives = [] substream = data[1] for _, cls, value, namespaces, pos in sorted(data[0]): directive, substream = cls.attach(self, substream, value, namespaces, pos) if directive: directives.append(directive) substream = self._prepare(substream, inlined) if directives: yield kind, (directives, list(substream)), pos else: for event in substream: yield event else: if kind is INCLUDE: href, cls, fallback = data tmpl_inlined = False if (isinstance(href, str) and not getattr(self.loader, 'auto_reload', True)): # If the path to the included template is static, and # auto-reloading is disabled on the template loader, # the template is inlined into the stream provided it # is not already in the stack of templates being # processed. tmpl = None try: tmpl = self.loader.load(href, relative_to=pos[0], cls=cls or self.__class__) except TemplateNotFound: if fallback is None: raise if tmpl is not None: if tmpl.filepath not in inlined: inlined.add(tmpl.filepath) tmpl._prepare_self(inlined) for event in tmpl.stream: yield event inlined.discard(tmpl.filepath) tmpl_inlined = True else: for event in self._prepare(fallback, inlined): yield event tmpl_inlined = True if tmpl_inlined: continue if fallback: # Otherwise the include is performed at run time data = href, cls, list(self._prepare( fallback, inlined)) yield kind, data, pos else: yield kind, data, pos def generate(self, *args, **kwargs): """Apply the template to the given context data. Any keyword arguments are made available to the template as context data. Only one positional argument is accepted: if it is provided, it must be an instance of the `Context` class, and keyword arguments are ignored. This calling style is used for internal processing. :return: a markup event stream representing the result of applying the template to the context data. """ vars = {} if args: assert len(args) == 1 ctxt = args[0] if ctxt is None: ctxt = Context(**kwargs) else: vars = kwargs assert isinstance(ctxt, Context) else: ctxt = Context(**kwargs) stream = self.stream for filter_ in self.filters: stream = filter_(iter(stream), ctxt, **vars) return Stream(stream, self.serializer) def _flatten(self, stream, ctxt, **vars): number_conv = self._number_conv stack = [] push = stack.append pop = stack.pop stream = iter(stream) while 1: for kind, data, pos in stream: if kind is START and data[1]: # Attributes may still contain expressions in start tags at # this point, so do some evaluation tag, attrs = data new_attrs = [] for name, value in attrs: if type(value ) is list: # this is an interpolated string values = [ event[1] for event in self._flatten( value, ctxt, **vars) if event[0] is TEXT and event[1] is not None ] if not values: continue value = ''.join(values) new_attrs.append((name, value)) yield kind, (tag, Attrs(new_attrs)), pos elif kind is EXPR: result = _eval_expr(data, ctxt, vars) if result is not None: # First check for a string, otherwise the iterable test # below succeeds, and the string will be chopped up into # individual characters if isinstance(result, str): yield TEXT, result, pos elif isinstance(result, (int, float)): yield TEXT, number_conv(result), pos elif hasattr(result, '__iter__'): push(stream) stream = _ensure(result) break else: yield TEXT, str(result), pos elif kind is SUB: # This event is a list of directives and a list of nested # events to which those directives should be applied push(stream) stream = _apply_directives(data[1], data[0], ctxt, vars) break elif kind is EXEC: _exec_suite(data, ctxt, vars) else: yield kind, data, pos else: if not stack: break stream = pop() def _include(self, stream, ctxt, **vars): """Internal stream filter that performs inclusion of external template files. """ from genshi.template.loader import TemplateNotFound for event in stream: if event[0] is INCLUDE: href, cls, fallback = event[1] if not isinstance(href, str): parts = [] for subkind, subdata, subpos in self._flatten( href, ctxt, **vars): if subkind is TEXT: parts.append(subdata) href = ''.join([x for x in parts if x is not None]) try: tmpl = self.loader.load(href, relative_to=event[2][0], cls=cls or self.__class__) for event in tmpl.generate(ctxt, **vars): yield event except TemplateNotFound: if fallback is None: raise for filter_ in self.filters: fallback = filter_(iter(fallback), ctxt, **vars) for event in fallback: yield event else: yield event
class TemplateProcessor: def __init__(self): self.paths = [ os.path.join(d, 'templates') for d in [ config.server_dir, pkg_resources.resource_filename('webias', 'data') ] ] self.templateLoader = TemplateLoader(self.paths, auto_reload=True) def template_filename(self, name): for p in self.paths: res = os.path.join(p, name) if os.path.isfile(res): return res def base_filename(self): return self.template_filename('system/base.genshi') def email(self, addr, sbj, body, attachments=[]): import smtplib, os from email.MIMEMultipart import MIMEMultipart from email.MIMEBase import MIMEBase from email.MIMEText import MIMEText from email.Utils import formatdate from email import Encoders msg = MIMEMultipart() msg["To"] = addr msg["Subject"] = sbj msg['Date'] = formatdate(localtime=True) msg.attach(MIMEText(body)) for file in attachments: part = MIMEBase('application', "octet-stream") #part = MIMEText('text','plain') part.set_payload(open(file, "r").read()) Encoders.encode_base64(part) part.add_header( 'Content-Disposition', 'attachment; filename="%s"' % os.path.basename(file)) msg.attach(part) try: msg["From"] = config.get('Mail', 'smtp_mail_from') msg["Return-Path"] = config.get('Mail', 'smtp_mail_from') s = smtplib.SMTP(config.get('Mail', 'smtp_host')) try: s.login(config.get('Mail', 'smtp_login'), config.get('Mail', 'smtp_password')) except ConfigParser.NoOptionError: pass res = s.sendmail(config.get('Mail', 'smtp_mail_from'), addr, msg.as_string()) s.quit() return res except: cherrypy.engine.log("Cannot send e-mail:\n" + msg.as_string(), 40) def email_message(self, address, file='system/email/generic.genshi', app=None, **kwargs): email = self.message(file=file, app=app, type='text', **kwargs) try: (subject, body) = email.split('\n', 1) if subject.startswith('Subject:'): subject = webhelpers.text.lchop(subject, 'Subject:').strip() else: raise Exception() except: subject = "Mesage from %s server." % config.get('Server', 'name') body = email return self.email(address, subject, body) def message(self, file='system/msg/generic.genshi', app=None, type='xhtml', **kwargs): args = TemplateArgs(app) for key in kwargs: args.set(key, kwargs[key]) return self.processTemplate(file, args, type=type) def processTemplate(self, file, args, type='xhtml'): if type == 'xhtml': tmplt = self.templateLoader.load(file) elif type == 'text': tmplt = self.templateLoader.load(file, cls=NewTextTemplate) try: args.mailto = webhelpers.html.tools.mail_to( config.get('Mail', 'admin_email'), unicode(config.get('Mail', 'admin_name'), "UTF-8"), encode="hex") except: pass try: args.e_mail = config.get('Mail', 'admin_email') except: pass try: args.server = config.get('Server', 'name') except: pass try: args.address = config.server_url except: pass try: args.css = config.get('Server', 'css_url') except: pass try: args.media = config.root + '/media' except: pass try: args.root = config.root except: pass try: tmp = cherrypy.request.db except: pass else: if tmp is not None: args.navigation_bar = util.get_WeBIAS().navigation_bar() else: args.navigation_bar = [] args.base = self.base_filename() # args.template_base = config.server_dir + '/templates' args.login = auth.get_login() stream = tmplt.generate(**args.__dict__) return stream.render(type, encoding='UTF-8') def processTemplatePaged(self, file, page, attr, args): count = len(args.get(attr)) step = 20 start = (page - 1) * step pages = (count + step - 1) / step if page < 1 or (page > pages and pages > 0): raise cherrypy.HTTPError(400, "Page out of range.") args.set(attr, args.get(attr)[start:start + step]) args.pages = pages args.page = page return self.processTemplate(file, args)