+
−# Wrapper for loading templates from storage of some sort (e.g. filesystem, database).
+
−#
+
−# This uses the TEMPLATE_LOADERS setting, which is a list of loaders to use.
+
−# Each loader is expected to have this interface:
+
−#
+
−#    callable(name, dirs=[])
+
−#
+
−# name is the template name.
+
−# dirs is an optional list of directories to search instead of TEMPLATE_DIRS.
+
−#
+
−# The loader should return a tuple of (template_source, path). The path returned
+
−# might be shown to the user for debugging purposes, so it should identify where
+
−# the template was loaded from.
+
−#
+
−# Each loader should have an "is_usable" attribute set. This is a boolean that
+
−# specifies whether the loader can be used in this Python installation. Each
+
−# loader is responsible for setting this when it's initialized.
+
−#
+
−# For example, the eggs loader (which is capable of loading templates from
+
−# Python eggs) sets is_usable to False if the "pkg_resources" module isn't
+
−# installed, because pkg_resources is necessary to read eggs.
+
−
+
−from django.core.exceptions import ImproperlyConfigured
+
−from django.template import Origin, Template, Context, TemplateDoesNotExist, add_to_builtins
+
−from django.conf import settings
+
−
+
−template_source_loaders = None
+
−
+
−class LoaderOrigin(Origin):
+
−    def __init__(self, display_name, loader, name, dirs):
+
−        super(LoaderOrigin, self).__init__(display_name)
+
−        self.loader, self.loadname, self.dirs = loader, name, dirs
+
−
+
−    def reload(self):
+
−        return self.loader(self.loadname, self.dirs)[0]
+
−
+
−def make_origin(display_name, loader, name, dirs):
+
−    if settings.TEMPLATE_DEBUG:
+
−        return LoaderOrigin(display_name, loader, name, dirs)
+
−    else:
+
−        return None
+
−
+
−def find_template_source(name, dirs=None):
+
−    # Calculate template_source_loaders the first time the function is executed
+
−    # because putting this logic in the module-level namespace may cause
+
−    # circular import errors. See Django ticket #1292.
+
−    global template_source_loaders
+
−    if template_source_loaders is None:
+
−        loaders = []
+
−        for path in settings.TEMPLATE_LOADERS:
+
−            i = path.rfind('.')
+
−            module, attr = path[:i], path[i+1:]
+
−            try:
+
−                mod = __import__(module, globals(), locals(), [attr])
+
−            except ImportError, e:
+
−                raise ImproperlyConfigured, 'Error importing template source loader %s: "%s"' % (module, e)
+
−            try:
+
−                func = getattr(mod, attr)
+
−            except AttributeError:
+
−                raise ImproperlyConfigured, 'Module "%s" does not define a "%s" callable template source loader' % (module, attr)
+
−            if not func.is_usable:
+
−                import warnings
+
−                warnings.warn("Your TEMPLATE_LOADERS setting includes %r, but your Python installation doesn't support that type of template loading. Consider removing that line from TEMPLATE_LOADERS." % path)
+
−            else:
+
−                loaders.append(func)
+
−        template_source_loaders = tuple(loaders)
+
−    for loader in template_source_loaders:
+
−        try:
+
−            source, display_name = loader(name, dirs)
+
−            return (source, make_origin(display_name, loader, name, dirs))
+
−        except TemplateDoesNotExist:
+
−            pass
+
−    raise TemplateDoesNotExist, name
+
−
+
−def get_template(template_name):
+
−    """
+
−    Returns a compiled Template object for the given template name,
+
−    handling template inheritance recursively.
+
−    """
+
−    source, origin = find_template_source(template_name)
+
−    template = get_template_from_string(source, origin, template_name)
+
−    return template
+
−
+
−def get_template_from_string(source, origin=None, name=None):
+
−    """
+
−    Returns a compiled Template object for the given template code,
+
−    handling template inheritance recursively.
+
−    """
+
−    return Template(source, origin, name)
+
−
+
−def render_to_string(template_name, dictionary=None, context_instance=None):
+
−    """
+
−    Loads the given template_name and renders it with the given dictionary as
+
−    context. The template_name may be a string to load a single template using
+
−    get_template, or it may be a tuple to use select_template to find one of
+
−    the templates in the list. Returns a string.
+
−    """
+
−    dictionary = dictionary or {}
+
−    if isinstance(template_name, (list, tuple)):
+
−        t = select_template(template_name)
+
−    else:
+
−        t = get_template(template_name)
+
−    if context_instance:
+
−        context_instance.update(dictionary)
+
−    else:
+
−        context_instance = Context(dictionary)
+
−    return t.render(context_instance)
+
−
+
−def select_template(template_name_list):
+
−    "Given a list of template names, returns the first that can be loaded."
+
−    for template_name in template_name_list:
+
−        try:
+
−            return get_template(template_name)
+
−        except TemplateDoesNotExist:
+
−            continue
+
−    # If we get here, none of the templates could be loaded
+
−    raise TemplateDoesNotExist, ', '.join(template_name_list)
+
−
+
−add_to_builtins('django.template.loader_tags')