def __call__(self, path, **params):
config = tg.config._current_obj()
try:
func = config['_pluggable_partials_cache'][path]
except:
func = config['_pluggable_partials_cache'][path] = self.resolve(path)
result = func(**params)
if not isinstance(result, dict):
return result
#Expect partials not to expose more than one template
available_engines = list(Decoration.get_decoration(func).engines.values())
engine_name, template_name, exclude_names = available_engines[0][:3]
replaced_template = config.get('_pluggable_templates_replacements', {}).get(template_name)
if replaced_template:
engine_name, template_name = replaced_template.split(':', 1)
#Avoid placing the doctype declaration in genshi templates
render_params = {}
if engine_name == 'genshi':
render_params['doctype'] = None
return tg_render(template_vars=result, template_engine=engine_name, template_name=template_name,
**render_params)
def __call__(self, path, **params):
config = tg.config._current_obj()
try:
func = config['_pluggable_partials_cache'][path]
except:
func = config['_pluggable_partials_cache'][path] = self.resolve(
path)
result = func(**params)
if not isinstance(result, dict):
return result
#Expect partials not to expose more than one template
available_engines = list(
Decoration.get_decoration(func).engines.values())
engine_name, template_name, exclude_names = available_engines[0][:3]
replaced_template = config.get('_pluggable_templates_replacements',
{}).get(template_name)
if replaced_template:
engine_name, template_name = replaced_template.split(':', 1)
# Avoid placing the doctype declaration in Genshi and Kajiki templates
render_params = {}
if engine_name == 'genshi':
render_params['doctype'] = None
if engine_name == 'kajiki':
render_params['is_fragment'] = True
return tg_render(template_vars=result,
template_engine=engine_name,
template_name=template_name,
**render_params)
def __call__(self, path, **params):
config = tg.config._current_obj()
try:
func = config['_pluggable_partials_cache'][path]
except:
func = config['_pluggable_partials_cache'][path] = self.resolve(path)
result = func(**params)
if not isinstance(result, dict):
return result
#Expect partials not to expose more than one template
engine_name, template_name, exclude_names = Decoration.get_decoration(func).engines.values()[0][:3]
replaced_template = config.get('_pluggable_templates_replacements', {}).get(template_name)
if replaced_template:
engine_name, template_name = replaced_template.split(':', 1)
return tg_render(template_vars=result, template_engine=engine_name, template_name=template_name, doctype=None)
def _render_response(self, tgl, controller, response):
"""
Render response takes the dictionary returned by the
controller calls the appropriate template engine. It uses
information off of the decoration object to decide which engine
and template to use, and removes anything in the exclude_names
list from the returned dictionary.
The exclude_names functionality allows you to pass variables to
some template rendering engines, but not others. This behavior
is particularly useful for rendering engines like JSON or other
"web service" style engines which don't use and explicit
template, or use a totally generic template.
All of these values are populated into the context object by the
expose decorator.
"""
req = tgl.request
resp = tgl.response
(content_type, engine_name, template_name, exclude_names, render_params
) = controller.decoration.lookup_template_engine(tgl)
result = dict(response=response, content_type=content_type,
engine_name=engine_name, template_name=template_name)
if content_type is not None:
resp.headers['Content-Type'] = content_type
# if it's a string return that string and skip all the stuff
if not isinstance(response, dict):
if engine_name == 'json' and isinstance(response, list):
raise JsonEncodeError(
'You may not expose with JSON a list return value because'
' it leaves your application open to CSRF attacks.')
return result
# Save these objects as locals from the SOP to avoid expensive lookups
tmpl_context = tgl.tmpl_context
# If there is an identity, push it to the Pylons template context
tmpl_context.identity = req.environ.get('repoze.who.identity')
# Setup the template namespace, removing anything that the user
# has marked to be excluded.
namespace = response
for name in exclude_names:
namespace.pop(name, None)
# If we are in a test request put the namespace where it can be
# accessed directly
if 'paste.testing' in req.environ:
testing_variables = req.environ['paste.testing_variables']
testing_variables['namespace'] = namespace
testing_variables['template_name'] = template_name
testing_variables['exclude_names'] = exclude_names
testing_variables['render_params'] = render_params
testing_variables['controller_output'] = response
# Render the result.
rendered = tg_render(template_vars=namespace, template_engine=engine_name,
template_name=template_name, **render_params)
result['response'] = rendered
return result
def _render_response(self, tgl, controller, response):
"""
Render response takes the dictionary returned by the
controller calls the appropriate template engine. It uses
information off of the decoration object to decide which engine
and template to use, and removes anything in the exclude_names
list from the returned dictionary.
The exclude_names functionality allows you to pass variables to
some template rendering engines, but not others. This behavior
is particularly useful for rendering engines like JSON or other
"web service" style engines which don't use and explicit
template, or use a totally generic template.
All of these values are populated into the context object by the
expose decorator.
"""
req = tgl.request
resp = tgl.response
(engine_content_type, engine_name, template_name, exclude_names,
render_params) = controller.decoration.lookup_template_engine(tgl)
result = dict(response=response,
content_type=engine_content_type,
engine_name=engine_name,
template_name=template_name)
if resp.content_type is None and engine_content_type is not None:
# User didn't set a specific content type during controller
# and template engine has a suggested one. Use template engine one.
resp.headers['Content-Type'] = engine_content_type
content_type = resp.headers['Content-Type']
if 'charset' not in content_type and (
content_type.startswith('text') or content_type
in ('application/xhtml+xml', 'application/xml',
'application/json')):
resp.content_type = content_type + '; charset=utf-8'
# if it's a string return that string and skip all the stuff
if not isinstance(response, dict):
return result
# Setup the template namespace, removing anything that the user
# has marked to be excluded.
namespace = response
for name in exclude_names:
namespace.pop(name, None)
# If we are in a test request put the namespace where it can be
# accessed directly
if 'paste.testing' in req.environ:
testing_variables = req.environ['paste.testing_variables']
testing_variables['namespace'] = namespace
testing_variables['template_name'] = template_name
testing_variables['exclude_names'] = exclude_names
testing_variables['render_params'] = render_params
testing_variables['controller_output'] = response
# Render the result.
rendered = tg_render(template_vars=namespace,
template_engine=engine_name,
template_name=template_name,
**render_params)
result['response'] = rendered
return result
def _render_response(self, controller, response):
"""
Render response takes the dictionary returned by the
controller calls the appropriate template engine. It uses
information off of the decoration object to decide which engine
and template to use, and removes anything in the exclude_names
list from the returned dictionary.
The exclude_names functionality allows you to pass variables to
some template rendering engines, but not others. This behavior
is particularly useful for rendering engines like JSON or other
"web service" style engines which don't use and explicit
template, or use a totally generic template.
All of these values are populated into the context object by the
expose decorator.
"""
content_type, engine_name, template_name, exclude_names = \
controller.decoration.lookup_template_engine(request)
if content_type != CUSTOM_CONTENT_TYPE:
pylons.response.headers['Content-Type'] = content_type
# skip all the complicated stuff if we're don't have a response dict
# to work with.
if not isinstance(response, dict):
return response
# Save these objeccts as locals from the SOP to avoid expensive lookups
req = request._current_obj()
tmpl_context = pylons.tmpl_context._current_obj()
use_legacy_renderer = config.get("use_legacy_renderer", True)
# what causes this condition? there are no tests for it.
if template_name is None:
return response
# Prepare the engine, if it's not already been prepared.
# json is a buffet engine ATM
if use_legacy_renderer or 'json' == engine_name:
# get the buffet handler
buffet = pylons.buffet._current_obj()
if engine_name not in _configured_engines():
template_options = dict(config).get('buffet.template_options',
{})
buffet.prepare(engine_name, **template_options)
_configured_engines().add(engine_name)
# if there is an identity, push it to the pylons template context
tmpl_context.identity = req.environ.get('repoze.who.identity')
# set up the tw renderer
if config.get('use_toscawidgets',
True) and engine_name in ('genshi', 'mako'):
tw.framework.default_view = engine_name
# Setup the template namespace, removing anything that the user
# has marked to be excluded.
namespace = dict(tmpl_context=tmpl_context)
if isinstance(response, dict):
namespace.update(response)
for name in exclude_names:
namespace.pop(name)
# If we are in a test request put the namespace where it can be
# accessed directly
if req.environ.get('paste.testing'):
testing_variables = req.environ['paste.testing_variables']
testing_variables['namespace'] = namespace
testing_variables['template_name'] = template_name
testing_variables['exclude_names'] = exclude_names
testing_variables['controller_output'] = response
# Render the result.
if use_legacy_renderer or 'json' == engine_name:
result = buffet.render(engine_name=engine_name,
template_name=template_name,
include_pylons_variables=False,
namespace=namespace)
else:
result = tg_render(template_vars=namespace,
template_engine=engine_name,
template_name=template_name)
return result
def _render_response(self, controller, response):
"""
Render response takes the dictionary returned by the
controller calls the appropriate template engine. It uses
information off of the decoration object to decide which engine
and template to use, and removes anything in the exclude_names
list from the returned dictionary.
The exclude_names functionality allows you to pass variables to
some template rendering engines, but not others. This behavior
is particularly useful for rendering engines like JSON or other
"web service" style engines which don't use and explicit
template, or use a totally generic template.
All of these values are populated into the context object by the
expose decorator.
"""
content_type, engine_name, template_name, exclude_names = \
controller.decoration.lookup_template_engine(pylons.request)
if content_type is not None:
pylons.response.headers['Content-Type'] = content_type
# if it's a string return that string and skip all the stuff
if not isinstance(response, dict):
if engine_name == 'json' and isinstance(response, list):
raise JsonEncodeError('You may not expose with json a list return value. This is because'\
' it leaves your application open to CSRF attacks')
return response
"""Return a JSON string representation of a Python object."""
# Save these objeccts as locals from the SOP to avoid expensive lookups
req = pylons.request._current_obj()
tmpl_context = pylons.tmpl_context._current_obj()
use_legacy_renderer = pylons.configuration.config.get("use_legacy_renderer", True)
# what causes this condition? there are no tests for it.
# this is caused when someone specifies a content_type, but no template
# because their controller returns a string.
if template_name is None:
return response
# Prepare the engine, if it's not already been prepared.
if use_legacy_renderer == engine_name:
# get the buffet handler
buffet = pylons.buffet._current_obj()
if engine_name not in _configured_engines():
template_options = dict(config).get('buffet.template_options', {})
buffet.prepare(engine_name, **template_options)
_configured_engines().add(engine_name)
#if there is an identity, push it to the pylons template context
tmpl_context.identity = req.environ.get('repoze.who.identity')
#set up the tw renderer
if engine_name in ('genshi','mako') and config['use_toscawidgets']:
global tw
if not tw:
import tw
tw.framework.default_view = engine_name
# Setup the template namespace, removing anything that the user
# has marked to be excluded.
namespace = dict(tmpl_context=tmpl_context)
if isinstance(response, dict):
namespace.update(response)
for name in exclude_names:
namespace.pop(name)
# If we are in a test request put the namespace where it can be
# accessed directly
if req.environ.get('paste.testing'):
testing_variables = req.environ['paste.testing_variables']
testing_variables['namespace'] = namespace
testing_variables['template_name'] = template_name
testing_variables['exclude_names'] = exclude_names
testing_variables['controller_output'] = response
# Render the result.
if use_legacy_renderer == engine_name:
result = buffet.render(engine_name=engine_name,
template_name=template_name,
include_pylons_variables=False,
namespace=namespace)
else:
result = tg_render(template_vars=namespace,
template_engine=engine_name,
template_name=template_name)
if isinstance(result, unicode) and not pylons.response.charset:
pylons.response.charset = 'UTF-8'
return result
def _render_response(self, controller, response):
"""
Render response takes the dictionary returned by the
controller calls the appropriate template engine. It uses
information off of the decoration object to decide which engine
and template to use, and removes anything in the exclude_names
list from the returned dictionary.
The exclude_names functionality allows you to pass variables to
some template rendering engines, but not others. This behavior
is particularly useful for rendering engines like JSON or other
"web service" style engines which don't use and explicit
template, or use a totally generic template.
All of these values are populated into the context object by the
expose decorator.
"""
content_type, engine_name, template_name, exclude_names = \
controller.decoration.lookup_template_engine(pylons.request)
if content_type != CUSTOM_CONTENT_TYPE:
pylons.response.headers['Content-Type'] = content_type
# Save these objeccts as locals from the SOP to avoid expensive lookups
req = pylons.request._current_obj()
tmpl_context = pylons.tmpl_context._current_obj()
use_legacy_renderer = pylons.config.get("use_legacy_renderer", True)
if use_legacy_renderer:
buffet = pylons.buffet._current_obj()
if template_name is None:
return response
# Deprecation warnings if people return a widget in the dict rather
# than setting it on tmpl_context
if isinstance(response, dict):
for key, item in response.iteritems():
if isinstance(item, Widget):
msg = "Returning a widget is deprecated, set them on pylons.tmpl_context instead"
warnings.warn(msg, DeprecationWarning)
setattr(tmpl_context, key, item)
# Prepare the engine, if it's not already been prepared.
if use_legacy_renderer:
if engine_name not in _configured_engines():
from pylons import config
template_options = dict(config).get('buffet.template_options', {})
buffet.prepare(engine_name, **template_options)
_configured_engines().add(engine_name)
#if there is an identity, push it to the pylons template context
tmpl_context.identity = req.environ.get('repoze.who.identity')
# Setup the template namespace, removing anything that the user
# has marked to be excluded.
namespace = dict(tmpl_context=tmpl_context)
namespace.update(response)
if not engine_name in ['json']:
namespace.update(get_tg_vars())
for name in exclude_names:
namespace.pop(name)
# If we are in a test request put the namespace where it can be
# accessed directly
if req.environ.get('paste.testing'):
testing_variables = req.environ['paste.testing_variables']
testing_variables['namespace'] = namespace
testing_variables['template_name'] = template_name
testing_variables['exclude_names'] = exclude_names
testing_variables['controller_output'] = response
# Render the result.
if use_legacy_renderer:
result = buffet.render(engine_name=engine_name,
template_name=template_name,
include_pylons_variables=False,
namespace=namespace)
else:
result = tg_render(template_vars=namespace,
template_engine=engine_name,
template_name=template_name)
return result
def _render_response(self, controller, response):
"""
Render response takes the dictionary returned by the
controller calls the appropriate template engine. It uses
information off of the decoration object to decide which engine
and template to use, and removes anything in the exclude_names
list from the returned dictionary.
The exclude_names functionality allows you to pass variables to
some template rendering engines, but not others. This behavior
is particularly useful for rendering engines like JSON or other
"web service" style engines which don't use and explicit
template, or use a totally generic template.
All of these values are populated into the context object by the
expose decorator.
"""
req = pylons.request._current_obj()
resp = pylons.response._current_obj()
(content_type, engine_name, template_name, exclude_names, render_params
) = controller.decoration.lookup_template_engine(req)
result = dict(response=response, content_type=content_type,
engine_name=engine_name, template_name=template_name)
if content_type is not None:
resp.headers['Content-Type'] = content_type
# if it's a string return that string and skip all the stuff
if not isinstance(response, dict):
if engine_name == 'json' and isinstance(response, list):
raise JsonEncodeError(
'You may not expose with JSON a list return value because'
' it leaves your application open to CSRF attacks.')
return result
# Save these objects as locals from the SOP to avoid expensive lookups
tmpl_context = pylons.tmpl_context._current_obj()
# what causes this condition? there are no tests for it.
# this is caused when someone specifies a content_type, but no template
# because their controller returns a string.
if template_name is None:
return result
# If there is an identity, push it to the Pylons template context
tmpl_context.identity = req.environ.get('repoze.who.identity')
# Set up the ToscaWidgets renderer
if engine_name in ('genshi','mako') and config['use_toscawidgets']:
global tw
if not tw:
try:
import tw
except ImportError:
pass
if tw:
tw.framework.default_view = engine_name
# Setup the template namespace, removing anything that the user
# has marked to be excluded.
namespace = dict(tmpl_context=tmpl_context)
if isinstance(response, dict):
namespace.update(response)
for name in exclude_names:
namespace.pop(name)
# If we are in a test request put the namespace where it can be
# accessed directly
if req.environ.get('paste.testing'):
testing_variables = req.environ['paste.testing_variables']
testing_variables['namespace'] = namespace
testing_variables['template_name'] = template_name
testing_variables['exclude_names'] = exclude_names
testing_variables['render_params'] = render_params
testing_variables['controller_output'] = response
# Render the result.
rendered = tg_render(template_vars=namespace, template_engine=engine_name,
template_name=template_name, **render_params)
if isinstance(result, unicode) and not pylons.response.charset:
resp.charset = 'UTF-8'
result['response'] = rendered
return result
def _render_response(self, tgl, controller, response):
"""
Render response takes the dictionary returned by the
controller calls the appropriate template engine. It uses
information off of the decoration object to decide which engine
and template to use, and removes anything in the exclude_names
list from the returned dictionary.
The exclude_names functionality allows you to pass variables to
some template rendering engines, but not others. This behavior
is particularly useful for rendering engines like JSON or other
"web service" style engines which don't use and explicit
template, or use a totally generic template.
All of these values are populated into the context object by the
expose decorator.
"""
req = tgl.request
resp = tgl.response
(engine_content_type, engine_name, template_name,
exclude_names, render_params) = controller.decoration.lookup_template_engine(tgl)
result = dict(response=response, content_type=engine_content_type,
engine_name=engine_name, template_name=template_name)
if resp.content_type is None and engine_content_type is not None:
# User didn't set a specific content type during controller
# and template engine has a suggested one. Use template engine one.
resp.headers['Content-Type'] = engine_content_type
content_type = resp.headers['Content-Type']
if 'charset' not in content_type and (
content_type.startswith('text') or content_type in ('application/xhtml+xml',
'application/xml',
'application/json')
):
resp.content_type = content_type + '; charset=utf-8'
# if it's a string return that string and skip all the stuff
if not isinstance(response, dict):
return result
# Setup the template namespace, removing anything that the user
# has marked to be excluded.
namespace = response
for name in exclude_names:
namespace.pop(name, None)
# If we are in a test request put the namespace where it can be
# accessed directly
if 'paste.testing' in req.environ:
testing_variables = req.environ['paste.testing_variables']
testing_variables['namespace'] = namespace
testing_variables['template_name'] = template_name
testing_variables['exclude_names'] = exclude_names
testing_variables['render_params'] = render_params
testing_variables['controller_output'] = response
# Render the result.
rendered = tg_render(template_vars=namespace, template_engine=engine_name,
template_name=template_name, **render_params)
result['response'] = rendered
return result
def _render_response(self, controller, response):
"""
Render response takes the dictionary returned by the
controller calls the appropriate template engine. It uses
information off of the decoration object to decide which engine
and template to use, and removes anything in the exclude_names
list from the returned dictionary.
The exclude_names functionality allows you to pass variables to
some template rendering engines, but not others. This behavior
is particularly useful for rendering engines like JSON or other
"web service" style engines which don't use and explicit
template, or use a totally generic template.
All of these values are populated into the context object by the
expose decorator.
"""
req = pylons.request._current_obj()
resp = pylons.response._current_obj()
(content_type, engine_name, template_name, exclude_names,
render_params) = controller.decoration.lookup_template_engine(req)
result = dict(response=response,
content_type=content_type,
engine_name=engine_name,
template_name=template_name)
if content_type is not None:
resp.headers['Content-Type'] = content_type
# if it's a string return that string and skip all the stuff
if not isinstance(response, dict):
if engine_name == 'json' and isinstance(response, list):
raise JsonEncodeError(
'You may not expose with JSON a list return value because'
' it leaves your application open to CSRF attacks.')
return result
# Save these objects as locals from the SOP to avoid expensive lookups
tmpl_context = pylons.tmpl_context._current_obj()
# what causes this condition? there are no tests for it.
# this is caused when someone specifies a content_type, but no template
# because their controller returns a string.
if template_name is None:
return result
# If there is an identity, push it to the Pylons template context
tmpl_context.identity = req.environ.get('repoze.who.identity')
# Set up the ToscaWidgets renderer
if engine_name in ('genshi', 'mako') and config['use_toscawidgets']:
global tw
if not tw:
try:
import tw
except ImportError:
pass
if tw:
tw.framework.default_view = engine_name
# Setup the template namespace, removing anything that the user
# has marked to be excluded.
namespace = dict(tmpl_context=tmpl_context)
if isinstance(response, dict):
namespace.update(response)
for name in exclude_names:
namespace.pop(name)
# If we are in a test request put the namespace where it can be
# accessed directly
if req.environ.get('paste.testing'):
testing_variables = req.environ['paste.testing_variables']
testing_variables['namespace'] = namespace
testing_variables['template_name'] = template_name
testing_variables['exclude_names'] = exclude_names
testing_variables['render_params'] = render_params
testing_variables['controller_output'] = response
# Render the result.
rendered = tg_render(template_vars=namespace,
template_engine=engine_name,
template_name=template_name,
**render_params)
if isinstance(result, unicode) and not pylons.response.charset:
resp.charset = 'UTF-8'
result['response'] = rendered
return result
