def get_template(self, template, def_name=None):
'''Retrieve a *Django* API template object for the given template name, using the app_path and template_subdir
settings in this object. This method still uses the corresponding Mako template and engine, but it
gives a Django API wrapper around it so you can use it the same as any Django template.
If def_name is provided, template rendering will be limited to the named def/block (see Mako docs).
This method corresponds to the Django templating system API.
A Django exception is raised if the template is not found or cannot compile.
'''
try:
# wrap the mako template in an adapter that gives the Django template API
return MakoTemplateAdapter(self.get_mako_template(template), def_name)
except (TopLevelLookupException, TemplateLookupException) as e: # Mako exception raised
tdne = TemplateDoesNotExist('Template "%s" not found in search path: %s.' % (template, self.template_search_dirs))
if settings.DEBUG:
tdne.template_debug = get_template_debug(template, e)
raise tdne from e
except (CompileException, SyntaxException) as e: # Mako exception raised
tse = TemplateSyntaxError('Template "%s" raised an error: %s' % (template, e))
if settings.DEBUG:
tse.template_debug = get_template_debug(template, e)
raise tse from e
def get_template(template_name, dirs=None):
if template_name == 'example.html':
return Template("example: {{ object }}")
raise TemplateDoesNotExist(template_name)
def test_check_403(self, mock_loader):
mock_loader.side_effect = TemplateDoesNotExist("Template not found.")
self.assertRaises(ImproperlyConfigured, check_template, 'foo.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.conf import settings
# Find the app_template_dirs (moved in Django 1.8)
import django.template.loaders.app_directories as app_directories
try:
# Django >= 1.8
get_app_template_dirs = app_directories.get_app_template_dirs
app_template_dirs = get_app_template_dirs('templates')
except AttributeError:
# Django <= 1.7
app_template_dirs = app_directories.app_template_dirs
# Find the find_template_loader function, and appropriate template
# settings (changed in Django 1.8)
try:
# Django >= 1.8
find_template_loader = context.template.engine.find_template_loader
template_dirs = context.template.engine.dirs
template_loaders = context.template.engine.loaders
except AttributeError:
# Django <= 1.7
from django.template.loader import find_template_loader
template_dirs = list(settings.TEMPLATE_DIRS)
template_loaders = settings.TEMPLATE_LOADERS
# 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 = 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 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]
if not dirs:
break
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 load_template_source(self, template_name, *args, **kwargs):
if not template_name.endswith('.shpaml'):
raise TemplateDoesNotExist(template_name)
shpaml_source, template_path = super(Loader, self).load_template_source(template_name, *args, **kwargs)
html = shpaml.convert_text(shpaml_source)
return html, template_path
def get_template(template_name, globals=None):
"""Load a template."""
try:
return get_env().get_template(template_name, globals=globals)
except TemplateNotFound, e:
raise TemplateDoesNotExist(str(e))
def select_template(template_name_list, dirs=None, using=None):
if template_name_list == ['test.html']:
return engines['django'].from_string("<html>test: {{ data }}</html>")
raise TemplateDoesNotExist(template_name_list[0])
def test_template_loader(template_name, template_dirs=None):
"A custom template loader that loads templates from a dictionary."
try:
return (templates_dict[template_name], "test:%s" % template_name)
except KeyError:
raise TemplateDoesNotExist(template_name)
def load_template(self, template_name, template_dirs=None):
try:
template = self.env.get_template(template_name)
return template, template.filename
except jinja2.TemplateNotFound:
raise TemplateDoesNotExist(template_name)
def get_contents(self, origin):
try:
with open(origin.name, encoding=self.engine.file_charset) as fp:
return fp.read()
except FileNotFoundError:
raise TemplateDoesNotExist(origin)
def load_template_source(self, template_name, dirs):
global template_coverage_collection, loaded_templates
if template_coverage_collection == True:
loaded_templates.add(str(template_name))
raise TemplateDoesNotExist(template_name)
username, project, name = template_name.split(":")
if name.startswith("static/"):
name = name.replace("static/", "")
try:
file_fact = StaticfileFactory(username, project, name)
file_obj = file_fact.lookup()
file = file_obj.content
return file, template_name
except NotFound, e:
raise TemplateDoesNotExist(name)
except Exception, e:
raise e
def load_template_source(self, template_name, template_dirs=None):
logger.debug("Trying to load template %s" %
str(template_name.split(":")))
if ":" in template_name:
username, base, short_name = template_name.split(":")
try:
base_model = Base.objects.get(name=base)
f, template_name = self.get_file(template_name, short_name,
base_model)
return f, template_name
except Exception, e:
logger.info("Could not load template %s (%s)" %
(template_name, e.message),
exc_info=True)
raise e
raise TemplateDoesNotExist("Template '%s' not found" % template_name)
def test_workspace_view_handles_missing_templates(self):
url = reverse('wirecloud.workspace_view', kwargs={'owner': 'user_with_workspaces', 'name': 'ExistingWorkspace'})
# Authenticate
self.client.login(username='******', password='******')
with patch('wirecloud.platform.views.render', return_value=Mock(render=Mock(side_effect=TemplateDoesNotExist('test')))):
self.assertRaises(TemplateDoesNotExist, self.client.get, url, HTTP_ACCEPT='application/xhtml+xml')
def load_template_source(self, template_name, template_dirs=None):
try:
return self.templates_dict[template_name], template_name
except KeyError:
raise TemplateDoesNotExist(template_name)
def select_template(template_name_list, dirs=None, using=None):
if template_name_list == ['example.html']:
return Template("example: {{ object }}")
raise TemplateDoesNotExist(template_name_list[0])
response[part] = _get_node(multi_part,
render_context,
name=part)
except BlockNotFound, error:
errors[part] = error
else:
try:
html_part = get_template('%s.html' % prefixed_template_name)
except TemplateDoesNotExist:
html_part = None
try:
plain_part = get_template('%s.txt' % prefixed_template_name)
except TemplateDoesNotExist:
if not html_part:
raise TemplateDoesNotExist(full_template_name)
else:
plain_part = None
if plain_part:
response['plain'] = plain_part.render(render_context)
if html_part:
response['html'] = html_part.render(render_context)
if response == {}:
raise EmailRenderException(
"Couldn't render email parts. Errors: %s" % errors)
return response
def get_template(template_name):
if template_name == '404.html':
return Template("404: {{ detail }}")
if template_name == '403.html':
return Template("403: {{ detail }}")
raise TemplateDoesNotExist(template_name)
=======
super().__init__(engine)
>>>>>>> 37c99181c9a6b95433d60f8c8ef9af5731096435
self.dirs = dirs
def get_dirs(self):
return self.dirs if self.dirs is not None else self.engine.dirs
def get_contents(self, origin):
try:
<<<<<<< HEAD
with io.open(origin.name, encoding=self.engine.file_charset) as fp:
return fp.read()
except IOError as e:
if e.errno == errno.ENOENT:
raise TemplateDoesNotExist(origin)
raise
def get_template_sources(self, template_name, template_dirs=None):
=======
with open(origin.name, encoding=self.engine.file_charset) as fp:
return fp.read()
except FileNotFoundError:
raise TemplateDoesNotExist(origin)
def get_template_sources(self, template_name):
>>>>>>> 37c99181c9a6b95433d60f8c8ef9af5731096435
"""
Return an Origin object pointing to an absolute path in each directory
in template_dirs. For security reasons, if a path doesn't lie inside
one of the template_dirs it is excluded from the result set.
def get_contents(self, origin):
try:
return self.templates_dict[origin.name]
except KeyError:
raise TemplateDoesNotExist(origin)
def get_template(template_name, dirs=None):
if template_name == 'test.html':
return engines['django'].from_string("<html>test: {{ data }}</html>")
raise TemplateDoesNotExist(template_name)
