def render_template():
        globs = extra_vars or {}
        globs.update(pylons_globals())

        # Using pylons.url() directly destroys the localisation stuff so
        # we remove it so any bad templates crash and burn
        del globs["url"]

        try:
            template_path, template_type = render_.template_info(template_name)
        except render_.TemplateNotFound:
            raise

        log.debug("rendering %s [%s]" % (template_path, template_type))
        if config.get("debug"):
            context_vars = globs.get("c")
            if context_vars:
                context_vars = dir(context_vars)
            debug_info = {
                "template_name": template_name,
                "template_path": template_path,
                "template_type": template_type,
                "vars": globs,
                "c_vars": context_vars,
                "renderer": renderer,
            }
            if "CKAN_DEBUG_INFO" not in request.environ:
                request.environ["CKAN_DEBUG_INFO"] = []
            request.environ["CKAN_DEBUG_INFO"].append(debug_info)

        del globs["config"]
        return render_jinja2(template_name, globs)

    def render_template():
        globs = extra_vars or {}
        globs.update(pylons_globals())

        # Using pylons.url() directly destroys the localisation stuff so
        # we remove it so any bad templates crash and burn
        del globs['url']

        try:
            template_path, template_type = render_.template_info(template_name)
        except render_.TemplateNotFound:
            raise

        log.debug('rendering %s [%s]' % (template_path, template_type))
        if config.get('debug'):
            context_vars = globs.get('c')
            if context_vars:
                context_vars = dir(context_vars)
            debug_info = {'template_name': template_name,
                          'template_path': template_path,
                          'template_type': template_type,
                          'vars': globs,
                          'c_vars': context_vars,
                          'renderer': renderer}
            if 'CKAN_DEBUG_INFO' not in request.environ:
                request.environ['CKAN_DEBUG_INFO'] = []
            request.environ['CKAN_DEBUG_INFO'].append(debug_info)

        del globs['config']
        return render_jinja2(template_name, globs)

def render(template_name,
           extra_vars=None,
           form_fill=None, form_errors={},
           suppress_cache=True,
           method='xhtml'):

    if suppress_cache:
        response.headers['Cache-Control'] = 'no-cache, no-store, must-revalidate'
        response.headers['Pragma'] = 'no-cache'
        response.headers['Expires'] = '0'

    # Pull in extra vars if needed
    globs = extra_vars or {}

    # Second, get the globals
    globs.update(pylons_globals())
    globs['g'] = app_globals
    globs['can'] = can
    globs['_form_errors'] = form_errors

    # Grab a template reference
    template = globs['app_globals'].genshi_loader.load(template_name)

    stream = template.generate(**globs)

    if form_fill is not None:
        filler = HTMLFormFiller(data=form_fill)
        stream = stream | filler

    for item in PluginImplementations(IGenshiStreamFilter):
        stream = item.filter(stream)

    return literal(stream.render(method=method, encoding=None))

def render(template_name, extra_vars=None, form_fill=None, form_errors={}, suppress_cache=True, method="xhtml"):

    if suppress_cache:
        response.headers["Cache-Control"] = "no-cache, no-store, must-revalidate"
        response.headers["Pragma"] = "no-cache"
        response.headers["Expires"] = "0"

    # Pull in extra vars if needed
    globs = extra_vars or {}

    # Second, get the globals
    globs.update(pylons_globals())
    globs["g"] = app_globals
    globs["can"] = can
    globs["_form_errors"] = form_errors

    # Grab a template reference
    template = globs["app_globals"].genshi_loader.load(template_name)

    stream = template.generate(**globs)

    if form_fill is not None:
        filler = HTMLFormFiller(data=form_fill)
        stream = stream | filler

    return literal(stream.render(method=method, encoding=None))

def render(
    template_name,
    extra_vars=None,
    form_fill=None,
    form_errors={},
    cache_expire=3600,
    cache_private=False,
    method="xhtml",
):

    _setup_cache(cache_expire, cache_private)

    # Pull in extra vars if needed
    globs = extra_vars or {}

    # Second, get the globals
    globs.update(pylons_globals())
    globs["g"] = app_globals
    globs["_form_errors"] = form_errors

    # Grab a template reference
    template = globs["app_globals"].genshi_loader.load(template_name)

    stream = template.generate(**globs)

    if form_fill is not None:
        filler = HTMLFormFiller(data=form_fill)
        stream = stream | filler

    for item in PluginImplementations(IGenshiStreamFilter):
        stream = item.filter(stream)

    return literal(stream.render(method=method, encoding=None))

    def render_template():
        globs = extra_vars or {}
        globs.update(pylons_globals())
        globs['actions'] = model.Action

        # Using pylons.url() directly destroys the localisation stuff so
        # we remove it so any bad templates crash and burn
        del globs['url']

        try:
            template_path, template_type = render_.template_info(template_name)
        except render_.TemplateNotFound:
            template_type = 'genshi'
            template_path = ''

        # snippets should not pass the context
        # but allow for legacy genshi templates
        if renderer == 'snippet' and template_type != 'genshi':
            del globs['c']
            del globs['tmpl_context']

        log.debug('rendering %s [%s]' % (template_path, template_type))
        if config.get('debug'):
            context_vars = globs.get('c')
            if context_vars:
                context_vars = dir(context_vars)
            debug_info = {'template_name': template_name,
                          'template_path': template_path,
                          'template_type': template_type,
                          'vars': globs,
                          'c_vars': context_vars,
                          'renderer': renderer}
            if 'CKAN_DEBUG_INFO' not in request.environ:
                request.environ['CKAN_DEBUG_INFO'] = []
            request.environ['CKAN_DEBUG_INFO'].append(debug_info)

        # Jinja2 templates
        if template_type == 'jinja2':
            # We don't want to have the config in templates it should be
            # accessed via g (app_globals) as this gives us flexability such
            # as changing via database settings.
            del globs['config']
            # TODO should we raise error if genshi filters??
            return render_jinja2(template_name, globs)

        # Genshi templates
        template = globs['app_globals'].genshi_loader.load(
            template_name.encode('utf-8'), cls=loader_class
        )
        stream = template.generate(**globs)

        for item in p.PluginImplementations(p.IGenshiStreamFilter):
            stream = item.filter(stream)

        if loader_class == NewTextTemplate:
            return literal(stream.render(method="text", encoding=None))

        return literal(stream.render(method=method, encoding=None,
                                     strip_whitespace=True))

 def render_template():
     # First, get the globals
     globs = pylons_globals()
     
     # Grab a template reference
     template = genshi_loader.load(template_name)
     
     return template.generate(**globs).render()

    def render_template():
        globs = extra_vars or {}
        globs.update(pylons_globals())
        globs["actions"] = model.Action

        # Using pylons.url() directly destroys the localisation stuff so
        # we remove it so any bad templates crash and burn
        del globs["url"]

        try:
            template_path, template_type = lib.render.template_info(template_name)
        except lib.render.TemplateNotFound:
            template_type = "genshi"
            template_path = ""

        # snippets should not pass the context
        # but allow for legacy genshi templates
        if renderer == "snippet" and template_type != "genshi":
            del globs["c"]
            del globs["tmpl_context"]

        log.debug("rendering %s [%s]" % (template_path, template_type))
        if config.get("debug"):
            context_vars = globs.get("c")
            if context_vars:
                context_vars = dir(context_vars)
            debug_info = {
                "template_name": template_name,
                "template_path": template_path,
                "template_type": template_type,
                "vars": globs,
                "c_vars": context_vars,
                "renderer": renderer,
            }
            if "CKAN_DEBUG_INFO" not in request.environ:
                request.environ["CKAN_DEBUG_INFO"] = []
            request.environ["CKAN_DEBUG_INFO"].append(debug_info)

        # Jinja2 templates
        if template_type == "jinja2":
            # We don't want to have the config in templates it should be
            # accessed via g (app_globals) as this gives us flexability such
            # as changing via database settings.
            del globs["config"]
            # TODO should we raise error if genshi filters??
            return render_jinja2(template_name, globs)

        # Genshi templates
        template = globs["app_globals"].genshi_loader.load(template_name, cls=loader_class)
        stream = template.generate(**globs)

        for item in PluginImplementations(IGenshiStreamFilter):
            stream = item.filter(stream)

        if loader_class == NewTextTemplate:
            return literal(stream.render(method="text", encoding=None))

        return literal(stream.render(method=method, encoding=None, strip_whitespace=True))

 def display(self, *args, **kw):
     # TODO: See if this is still necessary. Furthermore, find out which variables it actually adds.
     # Update the kwargs with the same values that are included in main templates
     # this allows us to access the following objects in widget templates:
     # ['tmpl_context', 'translator', 'session', 'ungettext', 'response', '_',
     #  'c', 'app_globals', 'g', 'url', 'h', 'request', 'helpers', 'N_', 'tg',
     #  'config']
     kw.update(pylons_globals())
     return forms.Widget.display(self, *args, **kw)

 def display(self, *args, **kw):
     # Update the kwargs with the same values that are included in main templates
     # this allows us to access the following objects in widget templates:
     # ['tmpl_context', 'translator', 'session', 'ungettext', 'response', '_',
     #  'c', 'app_globals', 'g', 'url', 'h', 'request', 'helpers', 'N_', 'tg',
     #  'config']
     kw.update(_get_tg_vars())
     kw.update(pylons_globals())
     return forms.Widget.display(self, *args, **kw)

def render_def(template_name, name, **kwargs):
    globs = pylons_globals()
 
    if kwargs:
        globs = globs.copy()
        globs.update(kwargs)
 
    template = globs['app_globals'].mako_lookup.get_template(template_name).get_def(name)
    return literal(template.render_unicode(**globs))

    def render_template():
        # Pull in extra vars if needed
        globs = extra_vars or {}

        # Second, get the globals
        globs.update(templating.pylons_globals())

        # Grab a template reference
        template = globs['app_globals'].kajiki_loader.load(template_name)

        return literal(template(globs).render())

 def render_template():
     # Pull in extra vars if needed
     globs = {}
     
     # Second, get the globals
     globs.update(pylons_globals())
     
     # Grab a template reference
     template = \
         getattr(globs['app_globals'].jinja2_env.get_template(template_name).make_module(vars=globs), name)(**kwargs)
     return template        

    def render_template():
        # Pull in extra vars if needed
        globs = extra_vars or {}

        # Second, get the globals
        globs.update(pylons_globals())

        # Grab a template reference
        template = \
            globs['app_globals'].pytiles_container.get_template(template_name)

        return literal(template.render(**globs))

 def render_template():
     globs = extra_vars or {}
     globs.update(pylons_globals())
     globs['actions'] = model.Action
     template = globs['app_globals'].genshi_loader.load(template_name,
         cls=loader_class)
     stream = template.generate(**globs)
     
     for item in PluginImplementations(IGenshiStreamFilter):
         stream = item.filter(stream)
     
     return literal(stream.render(method=method, encoding=None))

def render(template_name, tmpl_params=None, loader=None, fragment=False):
    if tmpl_params is None:
        tmpl_params = {}

    g = pylons_globals()
    tmpl_params.update(g)

    try:
        opts = g['app_globals'].breve_opts
    except AttributeError:
        opts = {}

    t = Template(tags, **opts)
    return t.render(template_name, params=tmpl_params, loader=loader, fragment=fragment)

 def render_template():
     # Get the globals
     # Note: when running in restricted mode which of these globals are
     # to be exposed should be a lot more selective. 
     pg = pylons_globals()
     
     # Update any extra vars if needed
     if extra_vars:
         pg.update(extra_vars)
     
     # Grab a template reference
     template = pg['app_globals'].evoque_domain.get_template(
         template_name, collection=collection, raw=raw, quoting=quoting)
     return template.evoque(pg, raw=raw, quoting=quoting)

 def content(self, path):
     """Handles returning "content" files: static content shoved more or
     less verbatim into the wrapper.
     """
     # Static files need to go through Mako to e.g. set their titles and
     # generate links, but TemplateLookup will not fetch templates outside
     # its known template directories.
     # Instead, load the template manually, and use the same lookup object
     # as everything else so references to other templates can still work
     # XXX when there's a real cache mechanism, this should use it!
     lookup = config['pylons.app_globals'].mako_lookup
     template = Template(filename=path, lookup=lookup,
                         **lookup.template_args)
     return template.render_unicode(**pylons_globals())

    def render_template():
        # Pull in extra vars if needed
        globs = extra_vars or {}

        # Second, get the globals
        globs.update(pylons_globals())
        globs['g'] = app_globals
        globs['_form_errors'] = form_errors

        # Grab a template reference
        template = globs['app_globals'].genshi_loader.load(template_name)
        stream = template.generate(**globs)
        if form_fill is not None:
            filler = HTMLFormFiller(data=form_fill)
            stream = stream | filler

        return literal(stream.render(method=method, encoding=None))

    def render_template():
        globs = extra_vars or {}
        globs.update(pylons_globals())
        globs['actions'] = model.Action

        # Using pylons.url() or pylons.url_for() directly destroys the
        # localisation stuff so we remove it so any bad templates crash
        # and burn
        del globs['url']

        template = globs['app_globals'].genshi_loader.load(template_name,
            cls=loader_class)
        stream = template.generate(**globs)
        
        for item in PluginImplementations(IGenshiStreamFilter):
            stream = item.filter(stream)
        
        return literal(stream.render(method=method, encoding=None, strip_whitespace=False))