def compile_template(template_string, using=None):
"""
Load and return a template for the given string.
"""
engines = _engine_list(using)
for engine in engines:
return engine.from_string(template_string)
def select_template(template_name_list,
using=None,
app_label=None,
model_name=None):
"""
Loads and returns a template for one of the given names.
Tries names in order and returns the first template found.
Raises TemplateDoesNotExist if no such template exists.
Hard override accepts app_label and model_name
"""
if isinstance(template_name_list, six.string_types):
raise TypeError(
'select_template() takes an iterable of template names but got a '
'string: %r. Use get_template() if you want to load a single '
'template by name.' % template_name_list)
chain = []
engines = _engine_list(using)
for template_name in template_name_list:
for engine in engines:
try:
return engine.get_template(template_name,
app_label=app_label,
model_name=model_name)
except TemplateDoesNotExist as e:
chain.append(e)
if template_name_list:
raise TemplateDoesNotExist(', '.join(template_name_list), chain=chain)
else:
raise TemplateDoesNotExist("No template names provided")
def test_call(self, template_on_disk, template_view, local_tz):
"""Assert that TemplateLastModified returns the last modified timestamp of the template"""
path = Path(template_on_disk)
last_modified = datetime.fromtimestamp(path.stat().st_mtime,
tz=local_tz)
assert last_modified == TemplateLastModified()(template_view())
# Modify the file
path.touch()
# This line is required to force django.template.loaders.filesystem.Loader to
# reload the template.
_engine_list()[0].engine.template_loaders[0].reset()
last_modified2 = datetime.fromtimestamp(path.stat().st_mtime,
tz=local_tz)
assert last_modified != last_modified2
assert last_modified2 == TemplateLastModified()(template_view())
def get_jinja_engine(self):
engines = _engine_list()
found_engine = None
for engine in engines:
if isinstance(engine, self.jinja_engine_classes):
if found_engine is None:
found_engine = engine
else:
raise ValueError('Multiple Jinja2 backends found.')
if found_engine is None:
raise ValueError('Cannot find django Jinja2 backend.')
return found_engine
def resolve_template(self, template_string):
"""
Load and return a template for the given name.
Raise TemplateDoesNotExist if no such template exists.
"""
chain = []
engines = _engine_list()
for engine in engines:
try:
return engine.from_string(template_string)
except Exception as e:
chain.append(e)
raise TemplateDoesNotExist(template_string, chain=chain)
def JINJA2_GET_ENVIRONMENT():
alias = 'Jinja2'
try:
from django.template.loader import _engine_list
engines = _engine_list(alias)
if engines:
engine = engines[0]
return engine.env
except InvalidTemplateEngineError:
raise InvalidTemplateEngineError(
"Could not find config for '{}' "
"in settings.TEMPLATES. "
"COMPRESS_JINJA2_GET_ENVIRONMENT() may "
"need to be defined in settings".format(alias))
except ImportError:
return None
def get_template(template_name, using=None, app_label=None, model_name=None):
"""
Loads and returns a template for the given name.
Raises TemplateDoesNotExist if no such template exists.
Hard override accepts app_label and model_name
"""
chain = []
engines = _engine_list(using)
for engine in engines:
try:
return engine.get_template(template_name,
app_label=app_label,
model_name=model_name)
except TemplateDoesNotExist as e:
chain.append(e)
raise TemplateDoesNotExist(template_name, chain=chain)
def get_loaders():
if VERSION[:2] < (1, 8):
from django.template.loader import template_source_loaders
if template_source_loaders is None:
try:
from django.template.loader import find_template as finder
except ImportError:
from django.template.loader import find_template_source as finder # noqa
try:
source, name = finder('test')
except TemplateDoesNotExist:
pass
from django.template.loader import template_source_loaders
return template_source_loaders or []
else:
from django.template.loader import _engine_list
loaders = []
for engine in _engine_list():
loaders.extend(engine.engine.template_loaders)
return loaders
def check_template(template_source, using=None):
"""
Loads and returns a template for the given name.
Raises TemplateDoesNotExist if no such template exists.
"""
errs = {}
engines = _engine_list(using)
# We should find at least one engine that does not raise an error.
for engine in engines:
try:
try:
return engine.from_string(template_source)
except jinja2.TemplateSyntaxError as exc:
new = TemplateSyntaxError(exc.args)
new.template_debug = get_exception_info(exc)
six.reraise(TemplateSyntaxError, new, sys.exc_info()[2])
except TemplateSyntaxError as err:
errs.update({engine: err})
if errs:
raise TemplateSyntaxError(errs)
def get_loaders():
loaders = []
try:
from django.template.loader import _engine_list
engines = _engine_list()
for engine in engines:
try:
loaders += engine.engine.template_loaders
except AttributeError:
pass
try:
loaders += engine.template_loaders
except AttributeError:
pass
except ImportError:# django < 1.8
from django.template.loader import find_template_loader
for loader_name in django_settings.TEMPLATE_LOADERS:
template_loader = find_template_loader(loader_name)
if template_loader is not None:
loaders.append(template_loader)
return loaders
def check_xss_vulnerabilities(self, xss_warnings_are_silenced,
suppression_path, rule_path):
engine_obj = engine_loader._engine_list()[0]
template_loader = template_dir_loader.Loader(engine_obj)
template_directories = template_loader.get_dirs()
user_template_directory = template_directories[0]
template_paths = glob.glob(
os.path.join(user_template_directory, "*.html"))
xssdetector = XSSDetector(template_paths, suppression_path, rule_path)
xssdetector.check()
num_errors = xssdetector.get_num_errors()
messages = xssdetector.get_error_messages()
if num_errors > 0:
if not xss_warnings_are_silenced:
self.stdout.write(
str(num_errors) +
" potential XSS vulnerabilities were found:\n")
self.stdout.write(messages)
else:
self.stdout.write(
"Potential XSS vulnerabilities were found (%s silenced).\n"
% str(num_errors))
else:
self.stdout.write("No XSS threats detected (0 silenced).")
import os
from django.contrib.sites.models import Site
from django.core.management.base import CommandError, BaseCommand
from django.template.utils import get_app_template_dirs
from django.template.loader import _engine_list
try:
from django.utils.six import input as raw_input
except ImportError:
pass
from dbtemplates.models import Template
ALWAYS_ASK, FILES_TO_DATABASE, DATABASE_TO_FILES = ('0', '1', '2')
DIRS = []
for engine in _engine_list():
DIRS.extend(engine.dirs)
app_template_dirs = get_app_template_dirs('templates')
class Command(BaseCommand):
help = "Syncs file system templates with the database bidirectionally."
def add_arguments(self, parser):
parser.add_argument("-e",
"--ext",
dest="ext",
action="store",
default="html",
help="extension of the files you want to "
"sync with the database [default: %default]")
def template_from_string(template_string, using=None):
"""
Creates and returns a template for the given string.
"""
engine = _engine_list(using)[0]
return engine.from_string(template_string)
try:
from threading import local
except ImportError:
#pylint: disable=import-error,no-name-in-module
from django.utils._threading_local import local
_thread_locals = local() #pylint: disable=invalid-name
LOGGER = logging.getLogger(__name__)
# signals hook for Django Templates. Jinja2 templates are done through
# a custom Environment.
#pylint:disable=protected-access
for engine in loader._engine_list():
if isinstance(engine, DjangoTemplates):
#pylint:disable=comparison-with-callable
if Template._render != instrumented_test_render:
Template.original_render = Template._render
Template._render = instrumented_test_render
break
def _add_editable_styles_context(context=None, less_variables=None):
if context is None:
context = {}
if 'editable_styles' not in context:
if less_variables is None:
less_variables = {}
styles_context = copy.deepcopy(settings.BOOTSTRAP_EDITABLE_VARIABLES)
for _, section_attributes in styles_context:
def get_loaders():
from django.template.loader import _engine_list
loaders = []
for engine in _engine_list():
loaders.extend(engine.engine.template_loaders)
return loaders
def get_jinja_engine(self):
engines = _engine_list()
for engine in engines:
if isinstance(engine, backend.Jinja2):
return engine
raise ValueError('Cannot find django_jinja.backend.Jinja2')
