def test_get_template_loaders(self):
tloaders, tdirs = get_template_loaders_dirs()
fs_loader = find_template_loader(
'django.template.loaders.filesystem.Loader')
app_loader = find_template_loader(
'django.template.loaders.app_directories.Loader')
self.assertEqual(tloaders[0].__class__, fs_loader.__class__)
self.assertEqual(tloaders[1].__class__, app_loader.__class__)
def get_template_loaders_dirs():
fs_loader_module = 'django.template.loaders.filesystem.Loader'
app_loader_module = 'django.template.loaders.app_directories.Loader'
loader_configs = set(flatten(settings.TEMPLATE_LOADERS))
dirs = ()
loaders = []
if fs_loader_module in loader_configs:
dirs += settings.TEMPLATE_DIRS
loaders.append(find_template_loader(fs_loader_module))
if app_loader_module in loader_configs:
dirs += app_template_dirs
loaders.append(find_template_loader(app_loader_module))
return loaders, dirs
def get_template_loaders_dirs():
fs_loader_module = 'django.template.loaders.filesystem.Loader'
app_loader_module = 'django.template.loaders.app_directories.Loader'
loader_configs = set(flatten(settings.TEMPLATE_LOADERS))
dirs = ()
loaders = []
if fs_loader_module in loader_configs:
dirs += settings.TEMPLATE_DIRS
loaders.append(find_template_loader(fs_loader_module))
if app_loader_module in loader_configs:
dirs += app_template_dirs
loaders.append(find_template_loader(app_loader_module))
return loaders, dirs
def find_template_and_decorate(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.
from django.template.loader import find_template_loader, make_origin
from django.template import TemplateDoesNotExist
global template_source_loaders
if template_source_loaders is None:
loaders = []
for loader_name in settings.TEMPLATE_LOADERS:
loader = find_template_loader(loader_name)
if loader is not None:
loaders.append(loader)
template_source_loaders = tuple(loaders)
for loader in template_source_loaders:
try:
source, display_name = loader(name, dirs)
# see if this template has a render method, and if so
# decorate it to emit signals when rendering happens
if hasattr(source, 'render'):
if not hasattr(source.render, 'decorated'):
# this class has not been decorated yet...
source.__class__.render = render_decorator(
source.__class__.render)
return (source, make_origin(display_name, loader, name, dirs))
except TemplateDoesNotExist:
pass
raise TemplateDoesNotExist(name)
def find_template(name, dirs=None, override_level=1):
# 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.
from django.template.loader import template_source_loaders
origin_override_level = override_level
if template_source_loaders is None:
loaders = []
for loader_name in settings.TEMPLATE_LOADERS:
loader = find_template_loader(loader_name)
if loader is not None:
loaders.append(loader)
template_source_loaders = tuple(loaders)
for loader in template_source_loaders:
try:
times = 1
while True:
source, display_name = loader(name, dirs, override_level=times)
if override_level == 1:
return (source, make_origin(display_name, loader, name, dirs))
else:
override_level -= 1
times += 1
except TemplateDoesNotExist:
pass
if origin_override_level > 1:
raise OverrideError("Cannot find the override template")
else:
raise TemplateDoesNotExist(name)
def find_default_template(name, dirs=None):
"""
Exclude the theme.template_loader
So we can properly get the templates not part of any theme.
"""
# 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 non_theme_source_loaders
if non_theme_source_loaders is None:
loaders = []
for loader_name in settings.TEMPLATE_LOADERS:
if loader_name != 'theme.template_loaders.load_template_source':
loader = find_template_loader(loader_name)
if loader is not None:
loaders.append(loader)
non_theme_source_loaders = tuple(loaders)
for loader in non_theme_source_loaders[-1:]:
try:
source, display_name = loader(name, dirs)
return (source, make_origin(display_name, loader, name, dirs))
except TemplateDoesNotExist:
pass
raise TemplateDoesNotExist(name)
def find_default_template(name, dirs=None):
"""
Exclude the theme.template_loader
So we can properly get the templates not part of any theme.
"""
# 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 non_theme_source_loaders
if non_theme_source_loaders is None:
loaders = []
for loader_name in settings.TEMPLATE_LOADERS:
if loader_name != 'theme.template_loaders.load_template_source':
loader = find_template_loader(loader_name)
if loader is not None:
loaders.append(loader)
non_theme_source_loaders = tuple(loaders)
for loader in non_theme_source_loaders[-1:]:
try:
source, display_name = loader(name, dirs)
return (source, make_origin(display_name, loader, name, dirs))
except TemplateDoesNotExist:
pass
raise TemplateDoesNotExist(name)
def setup_jinja_environment():
"""
Load jinja environment based on active django template loaders or
settings.JINJA2_TEMPLATE_LOADERS override.
Populate jinja global context with settings.JINJA2_GLOBAL_CONTEXT
"""
template_dirs = []
for loader_string in jinja2_settings.JINJA2_TEMPLATE_LOADERS:
[
template_dirs.append(x) for x in loader.find_template_loader(
loader_string).get_template_sources('')
]
kwargs = jinja2_settings.JINJA2_ENVIRONMENT_KWARGS.copy()
kwargs.update({
'loader': jinja2.FileSystemLoader(template_dirs),
'extensions': jinja2_settings.JINJA2_EXTENSIONS,
})
env = jinja2.Environment(**kwargs)
env.template_class = jinja2_settings.Jinja2DjangoTemplate
try:
for key, value in jinja2_settings.JINJA2_GLOBAL_CONTEXT.items():
env.globals[key] = value
except (ValueError, AttributeError), e:
raise Exception(
"Trouble applying setting 'JINJA2_GLOBALS': {0}".format(e))
def load_template(content = 'plain', type = 'content'):
template_dir = getattr(settings, "ADMIN_SUBSCRIBE_TEMPLATE_DIR", "email")
template = None
if type == 'content':
if content == 'plain':
template_name = '{0}.{1}'.format(type,'txt')
else:
template_name = '{0}.{1}'.format(type,'html')
template_path = template_dir + "/" + template_name
loaders = []
for loader_name in settings.TEMPLATE_LOADERS:
try:
loader = find_template_loader(loader_name)
except :
pass
else:
if loader is not None:
loaders.append(loader)
template_source_loaders = tuple(loaders)
for loader in template_source_loaders:
try:
template = loader.load_template_source(template_path)
return template[0]
except TemplateDoesNotExist:
pass
else:
if content == 'plain':
template = '{0}.{1}'.format(type,'txt')
else:
template = '{0}.{1}'.format(type,'html')
return template
def loaders(self):
if not self._cached_loaders:
self._cached_loaders = [
find_template_loader(loader) for loader in self._loaders
]
return self._cached_loaders
def setup_jinja_environment():
"""
Load jinja environment based on active django template loaders or
settings.JINJA2_TEMPLATE_LOADERS override.
Populate jinja global context with settings.JINJA2_GLOBAL_CONTEXT
"""
template_dirs = []
for loader_string in jinja2_settings.JINJA2_TEMPLATE_LOADERS:
[template_dirs.append(x) for x in loader.find_template_loader(loader_string).get_template_sources('')]
kwargs = jinja2_settings.JINJA2_ENVIRONMENT_KWARGS.copy()
kwargs.update({
'loader': jinja2.FileSystemLoader(template_dirs),
'extensions': jinja2_settings.JINJA2_EXTENSIONS,
})
env = jinja2.Environment(**kwargs)
env.template_class = jinja2_settings.Jinja2DjangoTemplate
try:
for key, value in jinja2_settings.JINJA2_GLOBAL_CONTEXT.items():
env.globals[key] = value
except (ValueError, AttributeError), e:
raise Exception("Trouble applying setting 'JINJA2_GLOBALS': {0}".format(e))
def loaders(self):
# Resolve loaders on demand to avoid circular imports
cached_loaders = [
find_template_loader(loader) for loader in self._loaders
]
# Return cached_loaders to be stored atomically. Otherwise, another thread
# could see an incomplete list. See #17303.
return cached_loaders
def loaders(self):
# Resolve loaders on demand to avoid circular imports
if not self._cached_loaders:
cached_loaders = []
for loader in self._loaders:
cached_loaders.append(find_template_loader(loader))
self._cached_loaders = cached_loaders
return self._cached_loaders
def loaders(self):
if not self._cached_loaders:
self._cached_loaders = [
find_template_loader(loader)
for loader in self._loaders
]
return self._cached_loaders
def __init__(self, *args, **kwargs):
loaders = []
for loader_name in settings.FLAVOURS_TEMPLATE_LOADERS:
loader = find_template_loader(loader_name)
if loader is not None:
loaders.append(loader)
self.template_source_loaders = tuple(loaders)
super(BaseLoader, self).__init__(*args, **kwargs)
def test_missing_template_is_cached(self):
"Check that the missing template is cached."
template_loader = loader.find_template_loader(settings.TEMPLATE_LOADERS[0])
# Empty cache, which may be filled from previous tests.
template_loader.reset()
# Check that 'missing.html' isn't already in cache before 'missing.html' is loaed
self.assertRaises(KeyError, lambda: template_loader.template_cache["missing.html"])
self.assertRaises(TemplateDoesNotExist, template_loader.load_template, "missing.html")
def initialize_type(cls, TEMPLATE_LOADERS=DEFAULT_TEMPLATE_LOADERS):
cls.template_loaders = [
find_template_loader(loader)
for loader in TEMPLATE_LOADERS if loader]
cls.add_to_class('filename', models.CharField(
_('template'), max_length=100,
choices=TemplateChoices(cls.template_loaders)))
def loaders(self): # Resolve loaders on demand to avoid circular imports if not self._cached_loaders: cached_loaders = [] for loader in self._loaders: cached_loaders.append(find_template_loader(loader)) self._cached_loaders = cached_loaders return self._cached_loaders
def __init__(self, *args, **kwargs):
loaders = []
for loader_name in settings.FLAVOURS_TEMPLATE_LOADERS:
loader = find_template_loader(loader_name)
if loader is not None:
loaders.append(loader)
self.template_source_loaders = tuple(loaders)
super(BaseLoader, self).__init__(*args, **kwargs)
def template_source(request):
"""
Return the source of a template, syntax-highlighted by Pygments if
it's available.
"""
from django.template import TemplateDoesNotExist
from django.utils.safestring import mark_safe
from django.conf import settings
template_name = request.GET.get('template', None)
if template_name is None:
return HttpResponseBadRequest('"template" key is required')
try: # Django 1.2 ...
from django.template.loader import find_template_loader, make_origin
loaders = []
for loader_name in settings.TEMPLATE_LOADERS:
loader = find_template_loader(loader_name)
if loader is not None:
loaders.append(loader)
for loader in loaders:
try:
source, display_name = loader.load_template_source(
template_name)
origin = make_origin(display_name, loader, template_name,
settings.TEMPLATE_DIRS)
break
except TemplateDoesNotExist:
source = "Template Does Not Exist: %s" % (template_name, )
except (ImportError, AttributeError): # Django 1.1 ...
from django.template.loader import find_template_source
source, origin = find_template_source(template_name)
# Allow downloading of template if 'download' GET arg is present.
if request.GET.get('download', None):
httpresp = HttpResponse(
content=source,
content_type="text/plain",
)
httpresp["Content-Disposition"] = 'attachment; filename={}'.format(
os.path.split(template_name)[-1])
return httpresp
try:
from pygments import highlight
from pygments.lexers import HtmlDjangoLexer
from pygments.formatters import HtmlFormatter
source = highlight(source, HtmlDjangoLexer(), HtmlFormatter())
source = mark_safe(source)
source.pygmentized = True
except ImportError:
pass
return render_to_response('debug_toolbar/panels/template_source.html', {
'source': source,
'template_name': template_name
})
def __init__(self, *args, **kwargs):
loaders = []
for loader_name in settings.TEMPLATE_LOADERS:
if loader_name != 'cadocms.loaders.flavour.Loader':
loader = find_template_loader(loader_name)
if loader is not None:
loaders.append(loader)
self.loaders = tuple(loaders)
super(BaseLoader, self).__init__(*args, **kwargs)
def loaders(self):
# Resolve loaders on demand to avoid circular imports
if not self._cached_loaders:
for loader in self._loaders:
if isinstance(loader, BaseLoader):
self._cached_loaders.append(loader)
else:
self._cached_loaders.append(find_template_loader(loader))
return self._cached_loaders
def __init__(self, *args, **kwargs):
loaders = []
for loader_name in settings.TEMPLATE_LOADERS:
if loader_name != 'cadocms.loaders.flavour.Loader':
loader = find_template_loader(loader_name)
if loader is not None:
loaders.append(loader)
self.loaders = tuple(loaders)
super(BaseLoader, self).__init__(*args, **kwargs)
def get_template_source_loaders():
global template_source_loaders
if template_source_loaders is None:
loaders = []
for loader_name in settings.TEMPLATE_LOADERS:
loader = find_template_loader(loader_name)
if loader is not None:
loaders.append(loader)
template_source_loaders = tuple(loaders)
return template_source_loaders
def __init__(self, *args, **kwargs):
loaders = []
for loader_name in settings.TEMPLATE_LOADERS:
if loader_name == 'mfw.template.loaders.flavour.Loader':
continue
loader = find_template_loader(loader_name)
if loader is not None:
loaders.append(loader)
self.template_source_loaders = tuple(loaders)
super(Loader, self).__init__(*args, **kwargs)
def loaders(self):
# Resolve loaders on demand to avoid circular imports
if not self._cached_loaders:
# Set self._cached_loaders atomically. Otherwise, another thread
# could see an incomplete list. See #17303.
cached_loaders = []
for loader in self._loaders:
cached_loaders.append(find_template_loader(loader))
self._cached_loaders = cached_loaders
return self._cached_loaders
def loaders(self):
# Resolve loaders on demand to avoid circular imports
if not self._cached_loaders:
# Set self._cached_loaders atomically. Otherwise, another thread
# could see an incomplete list. See #17303.
cached_loaders = []
for loader in self._loaders:
cached_loaders.append(find_template_loader(loader))
self._cached_loaders = cached_loaders
return self._cached_loaders
def test_missing_template_is_cached(self):
"Check that the missing template is cached."
template_loader = loader.find_template_loader(
settings.TEMPLATE_LOADERS[0])
# Empty cache, which may be filled from previous tests.
template_loader.reset()
# Check that 'missing.html' isn't already in cache before 'missing.html' is loaed
self.assertRaises(
KeyError, lambda: template_loader.template_cache["missing.html"])
self.assertRaises(TemplateDoesNotExist, template_loader.load_template,
"missing.html")
def find_template(self, name, context, peeking=False):
"""
Replacement for Django's ``find_template`` that uses the current
template context to keep track of which template directories it
has used when finding a template. This allows multiple templates
with the same relative name/path to be discovered, so that
circular template inheritance can occur.
"""
# These imports want settings, which aren't available when this
# module is imported to ``add_to_builtins``, so do them here.
from django.template.loaders.app_directories import app_template_dirs
from django.conf import settings
# Store a dictionary in the template context mapping template
# names to the lists of template directories available to
# search for that template. Each time a template is loaded, its
# origin directory is removed from its directories list.
context_name = "OVEREXTENDS_DIRS"
if context_name not in context:
context[context_name] = {}
if name not in context[context_name]:
all_dirs = list(settings.TEMPLATE_DIRS) + list(app_template_dirs)
# os.path.abspath is needed under uWSGI, and also ensures we
# have consistent path separators across different OSes.
context[context_name][name] = list(map(os.path.abspath, all_dirs))
# Build a list of template loaders to use. For loaders that wrap
# other loaders like the ``cached`` template loader, unwind its
# internal loaders and add those instead.
loaders = []
for loader_name in settings.TEMPLATE_LOADERS:
loader = find_template_loader(loader_name)
loaders.extend(getattr(loader, "loaders", [loader]))
# Go through the loaders and try to find the template. When
# found, removed its absolute path from the context dict so
# that it won't be used again when the same relative name/path
# is requested.
for loader in loaders:
dirs = context[context_name][name]
try:
source, path = loader.load_template_source(name, dirs)
except TemplateDoesNotExist:
pass
else:
# Only remove the absolute path for the initial call in
# get_parent, and not when we're peeking during the
# second call.
if not peeking:
remove_path = os.path.abspath(path[:-len(name) - 1])
context[context_name][name].remove(remove_path)
return Template(source)
raise TemplateDoesNotExist(name)
def find_template(self, name, context, peeking=False):
"""
Replacement for Django's ``find_template`` that uses the current
template context to keep track of which template directories it
has used when finding a template. This allows multiple templates
with the same relative name/path to be discovered, so that
circular template inheritance can occur.
"""
# These imports want settings, which aren't available when this
# module is imported to ``add_to_builtins``, so do them here.
from django.template.loaders.app_directories import app_template_dirs
from django.conf import settings
# Store a dictionary in the template context mapping template
# names to the lists of template directories available to
# search for that template. Each time a template is loaded, its
# origin directory is removed from its directories list.
context_name = "OVEREXTENDS_DIRS"
if context_name not in context:
context[context_name] = {}
if name not in context[context_name]:
all_dirs = list(settings.TEMPLATE_DIRS) + list(app_template_dirs)
# os.path.abspath is needed under uWSGI, and also ensures we
# have consistent path separators across different OSes.
context[context_name][name] = map(os.path.abspath, all_dirs)
# Build a list of template loaders to use. For loaders that wrap
# other loaders like the ``cached`` template loader, unwind its
# internal loaders and add those instead.
loaders = []
for loader_name in settings.TEMPLATE_LOADERS:
loader = find_template_loader(loader_name)
loaders.extend(getattr(loader, "loaders", [loader]))
# Go through the loaders and try to find the template. When
# found, removed its absolute path from the context dict so
# that it won't be used again when the same relative name/path
# is requested.
for loader in loaders:
dirs = context[context_name][name]
try:
source, path = loader.load_template_source(name, dirs)
except TemplateDoesNotExist:
pass
else:
# Only remove the absolute path for the initial call in
# get_parent, and not when we're peeking during the
# second call.
if not peeking:
remove_path = os.path.abspath(path[:-len(name) - 1])
context[context_name][name].remove(remove_path)
return Template(source)
raise TemplateDoesNotExist(name)
def get_template_loaders():
"""Compatibility method to fetch the template loaders."""
if Engine:
try:
engine = Engine.get_default()
except ImproperlyConfigured:
loaders = []
else:
loaders = engine.template_loaders
else: # Django < 1.8
loaders = [find_template_loader(loader_name) for loader_name in settings.TEMPLATE_LOADERS]
return loaders
def get_template_loaders():
"""Compatibility method to fetch the template loaders."""
if Engine:
try:
engine = Engine.get_default()
except ImproperlyConfigured:
loaders = []
else:
loaders = engine.template_loaders
else: # Django < 1.8
loaders = [find_template_loader(loader_name) for loader_name in settings.TEMPLATE_LOADERS]
return loaders
def template_source(request):
"""
Return the source of a template, syntax-highlighted by Pygments if
it's available.
"""
from django.template import TemplateDoesNotExist
from django.utils.safestring import mark_safe
from django.conf import settings
template_name = request.GET.get('template', None)
if template_name is None:
return HttpResponseBadRequest('"template" key is required')
try: # Django 1.2 ...
from django.template.loader import find_template_loader, make_origin
loaders = []
for loader_name in settings.TEMPLATE_LOADERS:
loader = find_template_loader(loader_name)
if loader is not None:
loaders.append(loader)
for loader in loaders:
try:
source, display_name = loader.load_template_source(template_name)
origin = make_origin(display_name, loader, template_name, settings.TEMPLATE_DIRS)
break
except TemplateDoesNotExist:
source = "Template Does Not Exist: %s" % (template_name,)
except (ImportError, AttributeError): # Django 1.1 ...
from django.template.loader import find_template_source
source, origin = find_template_source(template_name)
# Allow downloading of template if 'download' GET arg is present.
if request.GET.get('download', None):
httpresp = HttpResponse(content=source, content_type="text/plain", )
httpresp["Content-Disposition"] = 'attachment; filename={}'.format(os.path.split(template_name)[-1])
return httpresp
try:
from pygments import highlight
from pygments.lexers import HtmlDjangoLexer
from pygments.formatters import HtmlFormatter
source = highlight(source, HtmlDjangoLexer(), HtmlFormatter())
source = mark_safe(source)
source.pygmentized = True
except ImportError:
pass
return render_to_response('debug_toolbar/panels/template_source.html', {
'source': source,
'template_name': template_name
})
def find_template_source(name):
"""
Load the source code and origin of the first template that matches the
given name.
"""
for loader_path in settings.TEMPLATE_LOADERS:
template_loader = loader.find_template_loader(loader_path)
try:
source, origin = template_loader.load_template_source(name)
except TemplateDoesNotExist:
continue
break
return source, origin
def get_raw_template(name):
"""
Uses Django's template loaders to find and return the
raw template source.
"""
for loader_name in settings.TEMPLATE_LOADERS:
loader = find_template_loader(loader_name)
if loader is not None:
try:
return loader.load_template_source(name)[0]
except TemplateDoesNotExist:
pass
raise TemplateDoesNotExist(name)
def get_raw_template(name):
"""
Uses Django's template loaders to find and return the
raw template source.
"""
for loader_name in settings.TEMPLATE_LOADERS:
loader = find_template_loader(loader_name)
if loader is not None:
try:
return loader.load_template_source(name)[0]
except TemplateDoesNotExist:
pass
raise TemplateDoesNotExist(name)
def test_missing_template_is_cached(self):
"#19949 -- Check that the missing template is cached."
template_loader = loader.find_template_loader(settings.TEMPLATE_LOADERS[0])
# Empty cache, which may be filled from previous tests.
template_loader.reset()
# Check that 'missing.html' isn't already in cache before 'missing.html' is loaded
self.assertRaises(KeyError, lambda: template_loader.template_cache["missing.html"])
# Try to load it, it should fail
self.assertRaises(TemplateDoesNotExist, template_loader.load_template, "missing.html")
# Verify that the fact that the missing template, which hasn't been found, has actually
# been cached:
self.assertEqual(template_loader.template_cache.get("missing.html"),
TemplateDoesNotExist,
"Cached template loader doesn't cache file lookup misses. It should.")
def get_template(template_name):
loaders = []
for loader_name in settings.TEMPLATE_LOADERS:
loader = find_template_loader(loader_name)
if loader is not None:
loaders.append(loader)
template_source_loaders = tuple(loaders)
for loader in template_source_loaders:
try:
return loader.load_template_source(template_name)
except TemplateDoesNotExist:
pass
return ["", ""]
def loaders(self):
# Resolve loaders on demand to avoid circular imports
if not self._cached_loaders:
for loader in self._loaders:
loader = find_template_loader(loader)
class InnerLoader(loader.__class__):
is_usable = True
def load_template_source(self, *args, **kwargs):
src = super(InnerLoader, self).load_template_source(*args, **kwargs)
return (shpaml.convert_text(src[0]), src[1])
self._cached_loaders.append(InnerLoader())
return self._cached_loaders
def test_missing_template_is_cached(self):
"#19949 -- Check that the missing template is cached."
template_loader = loader.find_template_loader(settings.TEMPLATE_LOADERS[0])
# Empty cache, which may be filled from previous tests.
template_loader.reset()
# Check that 'missing.html' isn't already in cache before 'missing.html' is loaded
self.assertRaises(KeyError, lambda: template_loader.template_cache["missing.html"])
# Try to load it, it should fail
self.assertRaises(TemplateDoesNotExist, template_loader.load_template, "missing.html")
# Verify that the fact that the missing template, which hasn't been found, has actually
# been cached:
self.assertEqual(template_loader.template_cache.get("missing.html"),
TemplateDoesNotExist,
"Cached template loader doesn't cache file lookup misses. It should.")
def find_template_source(name, dirs=None):
"""Custom version of find_template_source for Django >= 1.3, since
find_template now always returns a compiled Template instance."""
loaders = []
for loader_name in settings.TEMPLATE_LOADERS:
loader = find_template_loader(loader_name)
if loader is not None:
loaders.append(loader)
for loader in loaders:
try:
source, display_name = loader.load_template_source(name, dirs)
return (source, make_origin(display_name, loader, name, dirs))
except TemplateDoesNotExist:
pass
raise TemplateDoesNotExist(name)
def find_template(name, dirs=None):
if django_template_loader.template_source_loaders is None:
loaders = []
for loader_name in settings.TEMPLATE_LOADERS:
loader = django_template_loader.find_template_loader(loader_name)
if loader is not None:
loaders.append(loader)
django_template_loader.template_source_loaders = tuple(loaders)
for loader in django_template_loader.template_source_loaders:
try:
source, display_name = loader.load_template_source(name, dirs)
return source, display_name
except django_template_loader.TemplateDoesNotExist:
pass
raise django_template_loader.TemplateDoesNotExist(name)
def fetch_template_source_loaders(self):
"""
Reads Django's TEMPLATE_LOADERS setting and fetches each
template loader.
"""
# grab Django's settings and the template loader loader
from django.conf import settings
from django.template.loader import find_template_loader
# fetch template source loaders
loaders = []
for loader_name in settings.TEMPLATE_LOADERS:
loader = find_template_loader(loader_name)
if loader is not None:
loaders.append(loader)
return tuple(loaders)
def get_template_source(template_name):
"""
Return the source code of a template (not a compiled version)
FIXME: Is there no django API for this?
"""
for loader_name in settings.TEMPLATE_LOADERS:
loader = find_template_loader(loader_name)
if loader is None:
continue
try:
template_source = loader.load_template_source(template_name)[0]
except TemplateDoesNotExist:
continue
else:
return template_source
raise TemplateDoesNotExist(template_name)
def loaders(self):
# Resolve loaders on demand to avoid circular imports
if not self._cached_loaders:
for loader in self._loaders:
loader = find_template_loader(loader)
class InnerLoader(loader.__class__):
is_usable = True
def load_template_source(self, *args, **kwargs):
src = super(InnerLoader, self).load_template_source(
*args, **kwargs)
return (shpaml.convert_text(src[0]), src[1])
self._cached_loaders.append(InnerLoader())
return self._cached_loaders
def get_template_source(template_name):
"""
Return the source code of a template (not a compiled version)
FIXME: Is there no django API for this?
"""
for loader_name in settings.TEMPLATE_LOADERS:
loader = find_template_loader(loader_name)
if loader is None:
continue
try:
template_source = loader.load_template_source(template_name)[0]
except TemplateDoesNotExist:
continue
else:
return template_source
raise TemplateDoesNotExist(template_name)
def build_loaders():
'''
Subclass existing loaders but modify to output uncompiled templates
'''
new_loaders = []
for loader in settings.TEMPLATE_LOADERS:
loader_cls = find_template_loader(loader)
class SourceLoader(loader_cls.__class__):
def load_template(self, template_name, template_dirs=None):
source, display_name = self.load_template_source(
template_name, template_dirs
)
return source, display_name
new_loaders.append(SourceLoader())
return new_loaders
def template_source(request):
"""
Return the source of a template, syntax-highlighted by Pygments if
it's available.
"""
from django.template import TemplateDoesNotExist
from django.utils.safestring import mark_safe
from django.conf import settings
template_name = request.GET.get('template', None)
if template_name is None:
return HttpResponseBadRequest('"template" key is required')
try: # Django 1.2 ...
from django.template.loader import find_template_loader, make_origin
loaders = []
for loader_name in settings.TEMPLATE_LOADERS:
loader = find_template_loader(loader_name)
if loader is not None:
loaders.append(loader)
for loader in loaders:
try:
source, display_name = loader.load_template_source(
template_name)
origin = make_origin(display_name, loader, template_name,
settings.TEMPLATE_DIRS)
except TemplateDoesNotExist:
source = "Template Does Not Exist: %s" % (template_name, )
except ImportError: # Django 1.1 ...
from django.template.loader import find_template_source
source, origin = find_template_source(template_name)
try:
from pygments import highlight
from pygments.lexers import HtmlDjangoLexer
from pygments.formatters import HtmlFormatter
source = highlight(source, HtmlDjangoLexer(), HtmlFormatter())
source = mark_safe(source)
source.pygmentized = True
except ImportError:
pass
return render_to_response('debug_toolbar/panels/template_source.html', {
'source': source,
'template_name': template_name
})
def template_source(request):
"""
Return the source of a template, syntax-highlighted by Pygments if
it's available.
"""
template_origin_name = request.GET.get("template_origin", None)
if template_origin_name is None:
return HttpResponseBadRequest('"template_origin" key is required')
try:
template_origin_name = signing.loads(template_origin_name)
except Exception:
return HttpResponseBadRequest('"template_origin" is invalid')
template_name = request.GET.get("template", template_origin_name)
final_loaders = []
for loader_name in settings.TEMPLATE_LOADERS:
loader = find_template_loader(loader_name)
if loader is not None:
final_loaders.append(loader)
for loader in final_loaders:
origin = Origin(template_origin_name)
try:
source = loader.get_contents(origin)
break
except TemplateDoesNotExist:
pass
else:
source = "Template Does Not Exist: %s" % (template_origin_name,)
try:
from pygments import highlight
from pygments.lexers import HtmlDjangoLexer
from pygments.formatters import HtmlFormatter
source = highlight(source, HtmlDjangoLexer(), HtmlFormatter())
source = mark_safe(source)
source.pygmentized = True
except ImportError:
pass
# Using SimpleTemplateResponse avoids running global context processors.
return SimpleTemplateResponse(
"debug_toolbar/panels/template_source.html",
{"source": source, "template_name": template_name},
)
def template_source(request):
"""
Return the source of a template, syntax-highlighted by Pygments if
it's available.
"""
from django.template import TemplateDoesNotExist
from django.utils.safestring import mark_safe
from django.conf import settings
template_name = request.GET.get("template", None)
if template_name is None:
return HttpResponseBadRequest('"template" key is required')
try: # Django 1.2 ...
from django.template.loader import find_template_loader, make_origin
loaders = []
for loader_name in settings.TEMPLATE_LOADERS:
loader = find_template_loader(loader_name)
if loader is not None:
loaders.append(loader)
for loader in loaders:
try:
source, display_name = loader.load_template_source(template_name)
origin = make_origin(display_name, loader, template_name, settings.TEMPLATE_DIRS)
break
except TemplateDoesNotExist:
source = "Template Does Not Exist: %s" % (template_name,)
except (ImportError, AttributeError): # Django 1.1 ...
from django.template.loader import find_template_source
source, origin = find_template_source(template_name)
try:
from pygments import highlight
from pygments.lexers import HtmlDjangoLexer
from pygments.formatters import HtmlFormatter
source = highlight(source, HtmlDjangoLexer(), HtmlFormatter())
source = mark_safe(source)
source.pygmentized = True
except ImportError:
pass
return render_to_response(
"debug_toolbar/panels/template_source.html", {"source": source, "template_name": template_name}
)
def get_django_template(name, dirs=None):
global django_template_source_loaders
if django_template_source_loaders is None:
loaders = []
for loader_name in settings.JINJA2_TEMPLATE_LOADERS:
loader = find_template_loader(loader_name)
if loader is not None:
loaders.append(loader)
django_template_source_loaders = tuple(loaders)
for loader in django_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_django_template(name, dirs=None):
global django_template_source_loaders
if django_template_source_loaders is None:
loaders = []
for loader_name in settings.JINJA2_TEMPLATE_LOADERS:
loader = find_template_loader(loader_name)
if loader is not None:
loaders.append(loader)
django_template_source_loaders = tuple(loaders)
for loader in django_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_django_template(self, name, dirs=None):
""" load a template using django instead of jinja2.
"""
if self._django_template_source_loaders is None:
loaders = []
for loader_name in settings.JINJA2_TEMPLATE_LOADERS:
loader = find_template_loader(loader_name)
if loader is not None:
loaders.append(loader)
self._django_template_source_loaders = tuple(loaders)
for loader in self._django_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 find_template(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 loader_name in settings.HANDLEBARS_LOADERS:
loader = find_template_loader(loader_name)
if loader is not None:
loaders.append(loader)
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)