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 load_template_source(self, template_name, template_dirs=None):
tried = []
for filepath in self.get_template_sources(template_name, template_dirs):
try:
file = open(filepath)
except IOError:
tried.append(filepath)
continue
st = os.fstat(file.fileno())
cf = self.cached.get(filepath, [-1,-1, None])
try:
if cf[0] != st.st_mtime or cf[1] != st.st_size:
fdata = file.read().decode(settings.FILE_CHARSET)
origin = make_origin(filepath, self.load_template_source, template_name, template_dirs)
t = get_template_from_string(fdata, origin, template_name)
cf = [st.st_mtime, st.st_size, t, time.time()]
self.cached[filepath] = cf
if len(self.cached) > self.max_cache:
v = min(self.cached.iteritems(), lambda v: v[1][3])
del self.cached[v[0]]
return (cf[2], filepath) #template
finally:
file.close()
if tried:
error_msg = "Tried %s" % tried
else:
error_msg = "Your TEMPLATE_DIRS setting is empty. Change it to point to at least one template directory."
raise TemplateDoesNotExist(error_msg)
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_template(name, dirs=None, skip_template=None):
"""
Returns a tuple with a compiled Template object for the given template name,
and a origin object. Skipping the current template (skip_template),
this param contain the absolute path of the template.
"""
from django.template.loader import template_source_loaders
setattr(name, 'skip_template', skip_template)
needs_smart_extends = skip_template.loadname == name
found_template_loader = False
for loader in template_source_loaders:
if needs_smart_extends and not found_template_loader and not isinstance(loader, CachedLoader):
if hasattr(loader, 'load_template_source'):
if (hasattr(skip_template.loader, '__self__') and
skip_template.loader.__self__.__class__ == loader.__class__):
found_template_loader = True
else: # old way to do template loaders
found_template_loader = skip_template.loader == loader
continue
try:
source, display_name = loader(name, dirs)
return (source, make_origin(display_name, loader, name, dirs))
except TemplateDoesNotExist:
pass
raise TemplateDoesNotExist(name)
def load_template(self, template_name, template_dirs=None):
key = template_name
if template_dirs:
# If template directories were specified, use a hash to differentiate
key = '-'.join([template_name, hashlib.sha1('|'.join(template_dirs)).hexdigest()])
if settings.DEBUG or key not in self.template_cache:
if os.path.splitext(template_name)[1] in ('.jade',):
source, display_name = self.load_template_source(template_name, template_dirs)
source=process(source,filename=template_name,compiler=Compiler)
origin = make_origin(display_name, self.load_template_source, template_name, template_dirs)
template = get_template_from_string(source, origin, template_name)
else:
template, origin = self.find_template(template_name, template_dirs)
if not hasattr(template, 'render'):
try:
template = get_template_from_string(process(source,filename=template_name,compiler=Compiler), origin, template_name)
except TemplateDoesNotExist:
# If compiling the template we found raises TemplateDoesNotExist,
# back off to returning he source and display name for the template
# we were asked to load. This allows for correct identification (later)
# of the actual template that does not exist.
return template, origin
self.template_cache[key] = template
return self.template_cache[key], None
def load_template(self, template_name, template_dirs=None):
source, file_path = self.load_template_source(template_name, template_dirs)
if source.startswith("## mako\n"):
# This is a mako template
template = Template(
filename=file_path,
module_directory=self.module_directory,
input_encoding="utf-8",
output_encoding="utf-8",
uri=template_name,
)
return template, None
else:
# This is a regular template
origin = make_origin(file_path, self.load_template_source, template_name, template_dirs)
try:
template = get_template_from_string(source, origin, template_name)
return template, None
except TemplateDoesNotExist:
# If compiling the template we found raises TemplateDoesNotExist, back off to
# returning the source and display name for the template we were asked to load.
# This allows for correct identification (later) of the actual template that does
# not exist.
return source, file_path
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(self, name, dirs=None):
for loader in self.loaders:
try:
template, display_name = loader(name, dirs)
return (template, make_origin(display_name, loader, name, dirs))
except TemplateDoesNotExist:
pass
raise TemplateDoesNotExist(name)
def load_template(self, template_name, template_dirs=None):
source, display_name = self.load_template_source(template_name, template_dirs)
origin = make_origin(display_name, self.load_template_source, template_name, template_dirs)
try:
template = ReactTemplate(display_name, source, origin, template_name)
return template, None
except TemplateDoesNotExist:
return source, display_name
def find_template(self, template_name, template_dirs=None):
for loader in self.loaders:
try:
template, display_name = loader(template_name, template_dirs)
origin = make_origin(display_name, loader,
template_name, template_dirs)
return template, origin
except TemplateDoesNotExist:
pass
raise TemplateDoesNotExist(template_name)
def load_rtl_template(self, template_name, template_dirs=None):
rtl_template_name = generate_rtl_template_name(template_name)
for loader in self._loaders:
try:
template, display_name = loader(rtl_template_name,
template_dirs)
return (template, make_origin(display_name, loader,
rtl_template_name,
template_dirs))
except TemplateDoesNotExist:
try:
template, display_name = loader(template_name,
template_dirs)
return (template, make_origin(display_name, loader,
template_name,
template_dirs))
except TemplateDoesNotExist:
pass
raise TemplateDoesNotExist(template_name)
def find_template(name, dirs=None, skip_template=None):
from django.template.loader import find_template_loader
# 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 = []
template_loaders = settings.TEMPLATE_LOADERS
if isinstance(template_loaders[0], tuple):
# django.template.loaders.cached.Loader. See template caching in Django docs
template_loaders = template_loaders[0][1]
for loader_name in template_loaders:
loader = find_template_loader(loader_name)
if loader is not None:
loaders.append(loader)
template_source_loaders = tuple(loaders)
template_candidate = None
for loader in template_source_loaders:
try:
source, display_name = loader(name, dirs)
if skip_template:
extends_tags = source.nodelist[0]
if get_source(extends_tags.source).name == skip_template.name:
#print get_source(extends_tags.source).name
#print skip_template.name
#print ""
template_candidate = None
continue
if not template_candidate:
template_candidate = (source,
make_origin(display_name, loader,
name, dirs))
#print template_candidate
#print ""
else:
return (source, make_origin(display_name, loader, name, dirs))
except TemplateDoesNotExist:
pass
if not template_candidate:
raise TemplateDoesNotExist(name)
return template_candidate
def find_template(self, name, dirs=None):
"""
Find template based on flavour and fall back to
no flavoured template if not found
"""
flavoured_name = self.prepare_template_name(name)
for loader in self.loaders:
try:
template, display_name = loader(flavoured_name, dirs)
return (template, make_origin(display_name, loader, flavoured_name, dirs))
except TemplateDoesNotExist:
#if not flavoured template found, fallback to original/default
try:
template, display_name = loader(name, dirs)
return (template, make_origin(display_name, loader, name, dirs))
except TemplateDoesNotExist:
pass
raise TemplateDoesNotExist(name)
def load_template(self, template_name, template_dirs=None):
source, display_name = self.load_template_source(template_name, template_dirs)
origin = make_origin(display_name, self.load_template_source, template_name, template_dirs)
try:
return OpenOfficeTemplate(source, origin, filepath=display_name), None
except TemplateDoesNotExist:
# If compiling the template we found raises TemplateDoesNotExist, back off to
# returning the source and display name for the template we were asked to load.
# This allows for correct identification (later) of the actual template that does
# not exist.
return source, display_name
def find_template(self, name, dirs=None):
for loader in self.loaders:
try:
template, display_name = loader.load_template_source(name, dirs)
return (template, make_origin(display_name, loader.load_template_source, name, dirs))
except TemplateDoesNotExist:
pass
except NotImplementedError, e:
raise Exception('Template loader %s does not implement load_template_source. Be sure not to nest '
'loaders which return only Template objects into the template preprocessor. (We need '
'a loader which returns a template string.)' % unicode(loader))
def find_template(self, name, dirs=None):
if not name.endswith(".shpaml"):
raise TemplateDoesNotExist(name)
for loader in self.loaders:
try:
template, display_name = loader(name, dirs)
return (template, make_origin(display_name, loader, name,
dirs))
except TemplateDoesNotExist:
pass
raise TemplateDoesNotExist(name)
def load_template(self, template_name, template_dirs=None, override_level=1):
source, display_name = self.load_template_source(template_name, template_dirs, override_level)
origin = make_origin(display_name, self.load_template_source, template_name, template_dirs)
try:
template = get_template_from_string(source, origin, template_name)
return template, None
except TemplateDoesNotExist:
# If compiling the template we found raises TemplateDoesNotExist, back off to
# returning the source and display name for the template we were asked to load.
# This allows for correct identification (later) of the actual template that does
# not exist.
return source, display_name
def find_template(self, name, dirs=None):
for loader in self.loaders:
try:
if hasattr(loader, 'load_template_source'):
template, display_name = loader.load_template_source(
name, dirs)
else:
template, display_name = loader(name, dirs)
return (template, make_origin(display_name, loader, name, dirs))
except TemplateDoesNotExist:
pass
raise TemplateDoesNotExist(name)
def load_template(self, template_name, template_dirs=None):
source, display_name = self.load_template_source(template_name, template_dirs)
origin = make_origin(display_name, self.load_template_source, template_name, template_dirs)
try:
template = Template(source, origin, template_name)
return template, None
except TemplateDoesNotExist:
# If compiling the template we found raises TemplateDoesNotExist, back off to
# returning the source and display name for the template we were asked to load.
# This allows for correct identification (later) of the actual template that does
# not exist.
return source, display_name
def find_template(name, dirs=None, skip_template=None):
from django.template.loader import find_template_loader
# 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 = []
template_loaders = settings.TEMPLATE_LOADERS
if isinstance(template_loaders[0], tuple):
# django.template.loaders.cached.Loader. See template caching in Django docs
template_loaders = template_loaders[0][1]
for loader_name in template_loaders:
loader = find_template_loader(loader_name)
if loader is not None:
loaders.append(loader)
template_source_loaders = tuple(loaders)
template_candidate = None
for loader in template_source_loaders:
try:
source, display_name = loader(name, dirs)
if skip_template:
extends_tags = source.nodelist[0]
if get_source(extends_tags.source).name == skip_template.name:
#print get_source(extends_tags.source).name
#print skip_template.name
#print ""
template_candidate = None
continue
if not template_candidate:
template_candidate = (source, make_origin(display_name, loader, name, dirs))
#print template_candidate
#print ""
else:
return (source, make_origin(display_name, loader, name, dirs))
except TemplateDoesNotExist:
pass
if not template_candidate:
raise TemplateDoesNotExist(name)
return template_candidate
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(self, name, dirs=None):
for loader in self.loaders:
try:
if hasattr(loader, 'load_template_source'):
template, display_name = loader.load_template_source(
name, dirs)
else:
template, display_name = loader(name, dirs)
return (template, make_origin(display_name, loader, name,
dirs))
except TemplateDoesNotExist:
pass
raise TemplateDoesNotExist(name)
def load_template(self, template_name, template_dirs=None):
language_info = get_language_info(get_language())
if language_info['bidi']:
return self.load_rtl_template(template_name, template_dirs)
for loader in self._loaders:
try:
template, display_name = loader(template_name, template_dirs)
return (template, make_origin(display_name, loader,
template_name, template_dirs))
except TemplateDoesNotExist:
pass
raise TemplateDoesNotExist(template_name)
def load_template(self, template_name, template_dirs=None):
source, display_name = self.load_template_source(template_name, template_dirs)
origin = make_origin(display_name, self.load_template_source, template_name, template_dirs)
try:
template = PystacheTemplate(source, origin, template_name)
return template, None
except TemplateDoesNotExist:
# If compiling the template we found raises TemplateDoesNotExist,
# back off to returning the source and display name for the
# template we were asked to load.
# This allows for correct identification (later) of the actual
# template that does not exist.
return source, display_name
def load_template(self, template_name, template_dirs=None):
language_info = get_language_info(get_language())
if language_info['bidi']:
return self.load_rtl_template(template_name, template_dirs)
for loader in self._loaders:
try:
template, display_name = loader(template_name, template_dirs)
return (template,
make_origin(display_name, loader, template_name,
template_dirs))
except TemplateDoesNotExist:
pass
raise TemplateDoesNotExist(template_name)
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 load_template(self, template_name, template_dirs=None):
uuid = self.get_template_uuid()
if uuid:
# load from db only
try:
tpl = TemplateModel.objects.get(group_uuid=uuid, path=template_name)
except TemplateModel.DoesNotExist:
raise TemplateDoesNotExist(template_name)
else:
origin = make_origin(tpl.path, self, template_name,
template_dirs)
return tpl.content, origin
else:
# use normal loaders
return self.find_template(template_name, template_dirs)
def load_template(self, template_name, template_dirs=None):
if not template_name.endswith('.hisp'):
raise TemplateDoesNotExist(template_name)
source, display_name = self.load_template_source(template_name, template_dirs)
source = hisper().convert(source)
origin = make_origin(display_name, self.load_template_source, template_name, template_dirs)
try:
template = get_template_from_string(source, origin, template_name)
return template, None
except TemplateDoesNotExist:
# If compiling the template we found raises TemplateDoesNotExist, back off to
# returning the source and display name for the template we were asked to load.
# This allows for correct identification (later) of the actual template that does
# not exist.
return source, display_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 find_template(self, name, dirs=None):
for loader in self.loaders:
try:
template, display_name = loader.load_template_source(
name, dirs)
return (template,
make_origin(display_name, loader.load_template_source,
name, dirs))
except TemplateDoesNotExist:
pass
except NotImplementedError, e:
raise Exception(
'Template loader %s does not implement load_template_source. Be sure not to nest '
'loaders which return only Template objects into the template preprocessor. (We need '
'a loader which returns a template string.)' %
unicode(loader))
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 load_template(self, template_name, template_dirs=None):
source, display_name = self.load_template_source(
template_name, template_dirs)
origin = make_origin(
display_name, self.load_template_source,
template_name, template_dirs)
try:
template = get_template_from_string(source, origin, template_name)
except TemplateDoesNotExist:
# If compiling the template we found raises TemplateDoesNotExist,
# back off to returning the source and display name for the
# template we were asked to load. This allows for correct
# identification of the actual template that does not exist.
return source, display_name
else:
return template, None
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 find_template(self, name, dirs=None):
key = self.cache_key(name, dirs)
try:
result = self.find_template_cache[key]
except KeyError:
result = None
for loader in self.loaders:
try:
template, display_name = loader(name, dirs)
except TemplateDoesNotExist:
pass
else:
result = (template, make_origin(display_name, loader, name, dirs))
self.find_template_cache[key] = result
if result:
return result
else:
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(self, name, dirs=None):
key = self.cache_key(name, dirs)
try:
result = self.find_template_cache[key]
except KeyError:
result = None
for loader in self.loaders:
try:
template, display_name = loader(name, dirs)
except TemplateDoesNotExist:
pass
else:
result = (template, make_origin(display_name, loader, name, dirs))
self.find_template_cache[key] = result
if result:
return result
else:
raise TemplateDoesNotExist(name)
def find_template(self, name, dirs=None):
skip_template = getattr(name, 'skip_template', None)
needs_smart_extends = skip_template and skip_template.loadname == name
found_template_loader = False
for loader in self.loaders:
if needs_smart_extends and not found_template_loader:
if hasattr(loader, 'load_template_source'):
if (hasattr(skip_template.loader, '__self__') and
skip_template.loader.__self__.__class__ == loader.__class__):
found_template_loader = True
else: # old way to do template loaders
found_template_loader = skip_template.loader == loader
continue
try:
template, display_name = loader(name, dirs)
return (template, 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)
def __call__(self, name, dirs=None):
result = None
template = None
display_name = None
for loader in self.loaders:
try:
template, display_name = loader(name, dirs)
except TemplateDoesNotExist:
pass
else:
result = (template,
make_origin(display_name, loader, name, dirs))
break
if result is None:
raise TemplateDoesNotExist(name)
return compile_template(template), display_name
def load_template(self, template_name, template_dirs=None):
key = template_name
if template_dirs:
# If template directories were specified, use a hash to differentiate
key = '-'.join([
template_name,
hashlib.sha1('|'.join(template_dirs)).hexdigest()
])
if settings.DEBUG or key not in self.template_cache:
if os.path.splitext(template_name)[1] in ('.jade', ):
try:
source, display_name = self.load_template_source(
template_name, template_dirs)
source = process(source,
filename=template_name,
compiler=Compiler)
origin = make_origin(display_name,
self.load_template_source,
template_name, template_dirs)
template = get_template_from_string(
source, origin, template_name)
except NotImplementedError:
template, origin = self.find_template(
template_name, template_dirs)
else:
template, origin = self.find_template(template_name,
template_dirs)
if not hasattr(template, 'render'):
try:
template = get_template_from_string(
process(source,
filename=template_name,
compiler=Compiler), origin, template_name)
except TemplateDoesNotExist:
# If compiling the template we found raises TemplateDoesNotExist,
# back off to returning he source and display name for the template
# we were asked to load. This allows for correct identification (later)
# of the actual template that does not exist.
return template, origin
self.template_cache[key] = template
return self.template_cache[key], None
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)
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.
if djloader.template_source_loaders is None:
loaders = []
for loader_name in settings.TEMPLATE_LOADERS:
loader = djloader.find_template_loader(loader_name)
if loader is not None:
loaders.append(loader)
djloader.template_source_loaders = tuple(loaders)
for loader in djloader.template_source_loaders:
try:
source, display_name = loader.load_template_source(name, dirs)
origin = djloader.make_origin(display_name, loader.load_template_source, name, dirs)
return (source, origin)
except TemplateDoesNotExist as e:
pass
raise TemplateDoesNotExist(name)
def find_template(self, name, dirs=None):
skip_template = getattr(name, 'skip_template', None)
needs_smart_extends = skip_template and skip_template.loadname == name
found_template_loader = False
for loader in self.loaders:
if needs_smart_extends and not found_template_loader:
if hasattr(loader, 'load_template_source'):
if (hasattr(skip_template.loader, '__self__')
and skip_template.loader.__self__.__class__
== loader.__class__):
found_template_loader = True
else: # old way to do template loaders
found_template_loader = skip_template.loader == loader
continue
try:
template, display_name = loader(name, dirs)
return (template, make_origin(display_name, loader, name,
dirs))
except TemplateDoesNotExist:
pass
raise TemplateDoesNotExist(name)
def find_template(self, name, dirs=None):
"""
Helper method. Lookup the template :param name: in all the configured loaders
"""
key = self.cache_key(name, dirs)
try:
result = self.find_template_cache[key]
except KeyError:
result = None
for loader in self.loaders:
try:
template, display_name = loader(name, dirs)
except TemplateDoesNotExist:
pass
else:
result = (template, make_origin(display_name, loader, name, dirs))
self.find_template_cache[key] = result
if result:
return result
else:
self.template_cache[key] = TemplateDoesNotExist
raise TemplateDoesNotExist(name)
def find_template(name, dirs=None, url=None):
# url是request.path, 例如/admin/,或者/users/1/之类的字符串
global template_source_loaders
tds = settings.TEMPLATE_LOADERS
if url is not None and settings.IS_DJANGO_TEMPLATE_PATH.search(url):
tds = [t for t in tds if t.startswith('django.template.loaders.')]
else:
tds = [t for t in tds if not t.startswith('django.template.loaders.')]
if template_source_loaders is None:
loaders = []
for loader_name in tds:
loader = find_template_loader(loader_name)
if loader is not None:
loaders.append(loader)
template_source_loaders = tuple(loaders)
#print('template_source_loaders',template_source_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 load_template(self, template_name, template_dirs=None):
source, file_path = self.load_template_source(template_name, template_dirs)
if source.startswith("## mako\n"):
# This is a mako template
template = Template(filename=file_path,
module_directory=self.module_directory,
input_encoding='utf-8',
output_encoding='utf-8',
uri=template_name)
return template, None
else:
# This is a regular template
origin = make_origin(file_path, self.load_template_source, template_name, template_dirs)
try:
template = get_template_from_string(source, origin, template_name)
return template, None
except TemplateDoesNotExist:
# If compiling the template we found raises TemplateDoesNotExist, back off to
# returning the source and display name for the template we were asked to load.
# This allows for correct identification (later) of the actual template that does
# not exist.
return source, file_path
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:
try:
source, display_name = loader(name, dirs)
return (source, make_origin(display_name, loader, name, dirs))
except TemplateDoesNotExist:
pass
raise TemplateDoesNotExist(name)
