thanks
Iain
In config/environment.py:
from genshi.template import TemplateLoader as GenshiTemplateLoader
def load_environment(global_conf, app_conf):
...
...
# Create the chameleon TemplateLoader
config['pylons.app_globals'].pt_loader = TemplateLoader(
paths['templates'], auto_reload=True)
Add a new file in lib (mine is called lib/pt.py):
from pylons.templating import pylons_globals
from pylons.templating import cached_template
def render_pt(template_name, cache_key=None, cache_type=None,
cache_expire=None):
"""Render a page template with z3c.pt."""
def render_template():
globs = pylons_globals()
template = globs["app_globals"].pt_loader.load(template_name)
return template(**globs)
return cached_template(template_name, render_template,
cache_key=cache_key,
cache_type=cache_type, cache_expire=cache_expire)
def render_text(template_name, cache_key=None, cache_type=None,
cache_expire=None):
"""Render a text template with z3c.pt."""
def render_template():
globs = pylons_globals()
template = globs["app_globals"].pt_loader.load(template_name,
format="text")
return template(**globs)
return cached_template(template_name, render_template,
cache_key=cache_key,
cache_type=cache_type, cache_expire=cache_expire)
you can then use render_pt to render html/xml templates, and render_text
to render text templates, exactly like you use other templating languages.
Wichert.
--
Wichert Akkerman <wic...@wiggy.net> It is simple to make things.
http://www.wiggy.net/ It is hard to make things simple.
Iain
Thanks Wichert, I've hit some problems here, and muddled along a bit, if
you ( or someone ) can check this that would be great.
>
> In config/environment.py:
>
> from genshi.template import TemplateLoader as GenshiTemplateLoader
I assume I'm also supposed to add??
from chameleon.zpt.loader import TemplateLoader
I copied the above in, and imported render_pt from lib/pt.py, but when I
try to render a template like so:
(in a controller)
def zpt(self):
"test of using zpt templates"
return render_pt("mytemplate.pt")
I get the following traceback, any help much appreciated.
File '/home/ymh/pylons_full/pylons_full/controllers/peek.py', line 50 in
zpt
File '/home/ymh/pylons_full/pylons_full/lib/pt.py', line 15 in render_pt
cache_key=cache_key, cache_type=cache_type, cache_expire=cache_expire)
File
'/home/ymh/lib/python2.5/site-packages/Pylons-0.9.7-py2.5.egg/pylons/templating.py', line 249 in cached_template
return render_func()
File '/home/ymh/pylons_full/pylons_full/lib/pt.py', line 11 in
render_template
template = globs["app_globals"].pt_loader.load(template_name)
File
'/home/ymh/lib/python2.5/site-packages/chameleon.zpt-1.0.0-py2.5.egg/chameleon/zpt/loader.py', line 11 in load
template.PageTemplateFile)
File
'/home/ymh/lib/python2.5/site-packages/chameleon.core-1.0.0-py2.5.egg/chameleon/core/loader.py', line 8 in load
self.registry[args] = template = func(self, *args)
File
'/home/ymh/lib/python2.5/site-packages/chameleon.core-1.0.0-py2.5.egg/chameleon/core/loader.py', line 39 in load
path, self.parser, auto_reload=self.auto_reload)
TypeError: __init__() takes exactly 2 non-keyword arguments (3 given)
Doh, that line should have read:
from chameleon.genshi.loader import TemplateLoader
> I assume I'm also supposed to add??
>
> from chameleon.zpt.loader import TemplateLoader
That depends. Personally I use chameleon.genshi since I prefer Genshi
syntax over zpt. If you want to use the Zope page template syntax you'll
want to replace chameleon.zpt.
Hm, the chameleon.zpt template has not seen as much love as the
chameleon.genshi version so it might have broken somewhere. Can you test
if chameleon.genshi works for you? If so I'll look at fixing up the
chameleon.zpt version.
I think I fixed that in chameleon.zpt. Can you try the current svn trunk
(see http://svn.repoze.org/chameleon.zpt/trunk ) and let me know if that
works for you?
What is Chameleon anyway? I googled and found this
http://www.interfaceware.com/manual/chameleon.html
"Welcome to Chameleon, an intuitive and easy-to-use software tool for
adding industry-standard message capabilities to new or existing
healthcare applications."
Is this the Chameleon you're talking about?
--
Mike Orr <slugg...@gmail.com>
That's the one.
So it's a template engine unifier, the way Buffet was and render_*
are. It also claims to be faster than the native engines ported to
it?
--
Mike Orr <slugg...@gmail.com>
Yes, it compiles both genshi and zpt templates to bytecode. That's about
all I know! chameleon.zpt is the out-of-the-box template standard for
repoze.bfg apps
Iain
If I remember correctly Buffet was a wrapper around template engines,
which provided a common API for rendering templates. Chameleon is
something different: it is a template rendering engine with frontends
for handling Zope page templates and Genshi syntax. You could compare it
to gcc with its different frontends for C, C++, Fortran, etc. It is a
lot faster than the original implementations. From what I remember it is
about 10-14 times faster than the original implementations for both with
the bigtable benchmark, which puts it in the same ballpark as Mako.
Thanks, Chameleon genshi is working with your correction. Is the plan
for chameleon to eventually be able to support both genshi and tal
attributes at the same time or will it always be an either or?
I also like genshi syntax a lot, so I'm just happy to use a fast genshi,
but it seems like there are some nice extras in the tal world as well.
Thanks
Iain
I've got the genshi templates being rendered, but I don't seem to be
able to use HTML() or XML() to unescape html tags if the values being
injected into the template are xhtml. Can anyone tell me what I need to
do to display HTML properly within a genshi template rendered by
chameleon, or why the HMTL function is not available?
thanks
Iain
Same system as Mako uses: it checks for a __html__ method. If you use
pylons that means you can use webhelpers.html.literal to indicate a
string should not be escaped. For example:
from webhelpers.html import literal
def my_func_in_lib_helpers():
return literal(u"Hello, <em>world</em>!")
My correction was in chameleon.zpt. chameleon.genshi has always had a
working template loader.
As far as I know there are no plans to support both Genshi and Page
Template syntax in the same file, and I have to admit that I personally
do not see any real benefits to doing that. chameleon.zpt does go a
little bit beyond the official zpt standards though: it also supports
${...} expansions, similar to Genshi templates.
To be more precise: chameleon.genshi implements the Genshi XML template
syntax as described in
http://genshi.edgewall.org/wiki/Documentation/0.5.x/xml-templates.html .
<?python> is not a part of that syntax.
That tutorial does not work due to a limitation chameleon.genshi
currently has: match templates defined in included templates are not
applied to the calling document. That is documented at
http://pypi.python.org/pypi/chameleon.genshi. If enough people ask
Malthe if he can add support for that might be fixed :)
Wichert.
--
Wichert Akkerman <wic...@wiggy.net> It is simple to make things.
Sorry if I'm being dumb here, but I'm confused by the above. Does this
mean that one can't use a master and derived templates setup with match
templates? That would seem to be a big limitation, but maybe I am doing
this wrong. Can you tell me how you handle template inheritance or
master templates with chameleon.genshi?
thanks
Iain
That's what I took it to mean.
Another way to get the same effect is to use something like
deliverance or repoze.tempita which is why I wasn't too worried about
it.
http://svn.repoze.org/repoze.tempita/trunk/README.txt
http://www.coactivate.org/projects/deliverance/introduction
Though I'm wondering now whether the overhead of either of these 2
would eliminate any gains from chameleon.genshi over straight genshi
--
Thomas G. Willis