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