def render(self, context): # our main context storage = Context() # stash the whole context if needed if getattr(settings, 'PHASED_KEEP_CONTEXT', False): storage.update(flatten_context(context)) # but check if there are variables specifically wanted for var_name in self.var_names: if var_name[0] in ('"', "'") and var_name[-1] == var_name[0]: var_name = var_name[1:-1] try: storage[var_name] = Variable(var_name).resolve(context) except VariableDoesNotExist: raise TemplateSyntaxError( '"phased" tag got an unknown variable: %r' % var_name) storage = backup_csrf_token(context, storage) # lastly return the pre phased template part return u'%(delimiter)s%(content)s%(pickled)s%(delimiter)s' % { 'content': self.content, 'delimiter': settings.PHASED_SECRET_DELIMITER, 'pickled': pickle_context(storage), }
def get_context(): if engines is not None: context = Context() context.template = Template('') return context else: return Context()
def test_include_error08(self): t = get_template('include-error08') if settings.TEMPLATE_DEBUG: with self.assertRaises(TemplateSyntaxError): t.render(Context()) else: self.assertEqual(t.render(Context()), '')
def test_include04(self): template = get_template('include04') if settings.TEMPLATE_DEBUG: with self.assertRaises(TemplateDoesNotExist): template.render(Context({})) else: output = template.render(Context({})) self.assertEqual(output, "ab")
def test_cached(): """ Test that the template still works when the cached loader is being used. """ c = Context() t = Template('{% extends "admin:admin/base.html" %}') t.render(c)
def test_render(): """ Test-drive the apptemplate code base by rendering a template. """ c = Context() t = Template('{% extends "admin:admin/base.html" %}') t.render(c)
def render(template_name, context=None): if context is None: context = {} t = get_template(template_name) with translation.override(context.get('LANGUAGE_CODE', 'en-us')): return t.render(Context(context))
def api_contact_send(request): if request.is_ajax() or request.method == 'POST': contact_form = ContactForm(data=request.POST) if contact_form.is_valid(): email_to = config.EMAIL email_from = settings.DEFAULT_FROM_EMAIL message = contact_form.cleaned_data['message'] name = contact_form.cleaned_data['name'] email_or_phone = contact_form.cleaned_data['email_or_phone'] email_subject = force_text(strings.CONTACT_EMAIL_SUBJECT % {'person_name': name}) email = EmailMultiAlternatives( email_subject, Template(strings.CONTACT_EMAIL_BODY).render( Context({ 'name': name, 'email': email_or_phone, 'message': message, })), email_from, [email_to], None, None, None, None, None, None) email.send() return render(request, 'contact/contact_response.html', {}) else: return render(request, 'contact/contact.html', {'contact_form': contact_form})
def render_to_string(template_name, dictionary=None, context_instance=None, dirs=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. """ if isinstance(template_name, (list, tuple)): t = select_template(template_name, dirs) else: t = get_template(template_name, dirs) if not context_instance: # Django < 1.8 accepted a Context in `dictionary` even though that's # unintended. Preserve this ability but don't rewrap `dictionary`. if isinstance(dictionary, Context): return t.render(dictionary) else: return t.render(Context(dictionary)) if not dictionary: return t.render(context_instance) # Add the dictionary to the context stack, ensuring it gets removed again # to keep the context_instance in the same state it started in. with context_instance.push(dictionary): return t.render(context_instance)
def test_custom_bound_field(): from django.forms.boundfield import BoundField extra = 'xyxyxyxyxyx' class CustomBoundField(BoundField): @property def auto_id(self): return extra class MyCharField(forms.CharField): def get_bound_field(self, form, field_name): return CustomBoundField(form, self, field_name) class MyForm(forms.Form): f = MyCharField() def __init__(self, *args, **kwargs): super(MyForm, self).__init__(*args, **kwargs) self.helper = FormHelper() self.helper.layout = Layout('f') template = Template('{% load crispy_forms_tags %}\n{% crispy form "bootstrap3" %}') rendered = template.render(Context({'form': MyForm(data={'f': 'something'})})) assert extra in rendered
def form_valid(self, form): form.save() messages.success(self.request, _('Successfully saved changes.')) if form.cleaned_data['send_login_data']: t = template.loader.get_template( 'booktypecontrol/password_changed_email.html') content = t.render( Context({ "username": self.object.username, "password": form.cleaned_data['password2'], "short_message": form.cleaned_data['short_message'] })) msg = EmailMultiAlternatives(_('Your password was changed'), content, settings.DEFAULT_FROM_EMAIL, [self.object.email]) msg.attach_alternative(content, "text/html") try: msg.send(fail_silently=False) except Exception as e: logger.error( '[CCENTER] Unable to send email to %s after password was changed, msg: %s' % (self.object.email, e)) return super(FormView, self).form_valid(form)
def test_basic_syntax20b(self): """ Don't silence a TypeError if it was raised inside a callable. """ template = self.engine.get_template('basic-syntax20b') with self.assertRaises(TypeError): template.render(Context({'var': SomeClass()}))
def render(self, context): values = dict([(key, val.resolve(context)) for key, val in self.extra_context.iteritems()]) if self.isolated_context: return self.nodelist.render(Context(values)) context.update(values) output = self.nodelist.render(context) context.pop() return output
def setUp(self): # Every test needs access to the request factory. factory = RequestFactory() self.context = Context({ 'request': factory.get('/data/test'), 'var1': 1, 'var2': 2 })
def render_error(self, package_type, package_name, e): return render_to_string( 'pipeline/compile_error.html', Context({ 'package_type': package_type, 'package_name': package_name, 'command': subprocess.list2cmdline(e.command), 'errors': e.error_output, }))
def setUp(self): # Every test needs access to the request factory. factory = RequestFactory() self.context = Context({ "request": factory.get("/data/test"), "var1": 1, "var2": 2 })
def test_include_error10(self): c = Context({'failed_include': 'include-fail2'}) t = get_template('include-error10') if settings.TEMPLATE_DEBUG: with self.assertRaises(TemplateSyntaxError): t.render(c) else: self.assertEqual(t.render(c), '')
def test_include_error09(self): c = Context({'failed_include': 'include-fail1'}) t = get_template('include-error09') if settings.TEMPLATE_DEBUG: with self.assertRaises(RuntimeError): t.render(c) else: self.assertEqual(t.render(c), '')
def process_template_response(self, string_template, user=None): request = HttpRequest() request.user = user context = Context({'request': request}) template = BackendTemplate(Template(string_template).render(context)) response = SimpleTemplateResponse(template, context) response.content = string_template mw = ToolbarMiddleware() return mw.process_response(request, response).render()
def loremi(count, method, random=False): from django.template.base import Context, Token, Parser, TOKEN_TEXT from django.template.defaulttags import lorem c = Context() lorem_str = "lorem %s %s" % (count, method) if random: lorem_str += " random" t = Token(TOKEN_TEXT, lorem_str) p = Parser(t) return lorem(p, t).render(c)
def process_template_response(self, string_template): settings.TOOLBAR_INSTANT_UPDATE = False request = HttpRequest() context = Context({'request': request}) node = Template(string_template).render(context) template = BackendTemplate(node) response = SimpleTemplateResponse(template, context) response.content = node mw = TextMiddleware() return mw.process_response(request, response).render()
def test_load_template(self): app_namespace_loader = Loader(Engine()) app_directory_loader = app_directories.Loader(Engine()) template_directory = app_directory_loader.load_template( 'admin/base.html')[0] template_namespace = app_namespace_loader.load_template( 'admin:admin/base.html')[0] context = Context({}) self.assertEquals(template_directory.render(context), template_namespace.render(context))
def multiple_extend_empty_namespace(self): context = Context({}) template = Template(self.template_extend % { 'app': 'top-level' }).render(context) previous_app = '' for test_app in ['top-level'] + self.apps: self.assertTrue(test_app in template) if previous_app: self.assertTrue( template.index(test_app) > template.index(previous_app)) previous_app = test_app
def test_extend_empty_namespace(self): """ Test that a ":" prefix (empty namespace) gets handled. """ context = Context({}) mark = 'Django administration' mark_title = '<title>APP NAMESPACE</title>' template_namespace = Template( '{% extends ":admin/base_site.html" %}' '{% block title %}APP NAMESPACE{% endblock %}').render(context) self.assertTrue(mark in template_namespace) self.assertTrue(mark_title in template_namespace)
def multiple_extend_empty_namespace(self): with self.settings(INSTALLED_APPS=self.apps + ['django.contrib.admin']): # Django 1.4 Fix context = Context({}) template = Template(self.template_extend % { 'app': 'top-level' }).render(context) previous_app = '' for test_app in ['top-level'] + self.apps: self.assertTrue(test_app in template) if previous_app: self.assertTrue( template.index(test_app) > template.index(previous_app) ) previous_app = test_app
def render(self, field, context): """ Renders ``field`` using ``context``. """ template_string = getattr(self, field) or '' if settings.TEMPLATE_TRANSLATE: template_string = _(template_string) if settings.TEMPLATE_CHECK: vars = re.findall(r'{{ ?([^\.}]+)[^}]*}}', template_string) for var in vars: if context.get(var) is None: raise MissingContextVariableError(field, var) return Template(template_string).render(Context(context))
def multiple_extend_empty_namespace(self, apps=None): if apps is None: apps = self.apps with self.settings(INSTALLED_APPS=apps): context = Context({}) template = Template(self.template_extend % { 'app': 'top-level' }).render(context) previous_app = '' for test_app in ['top-level'] + self.apps: self.assertTrue(test_app in template) if previous_app: self.assertTrue( template.index(test_app) > template.index(previous_app) ) previous_app = test_app
def as_html(self, request=None, type=None): """ Returns the address as html. """ templates = ["lfs/addresses/address_view.html"] if type: templates.insert(0, "lfs/addresses/%s_address_view.html" % type) if request: return render_to_string(templates, RequestContext(request, { "address": self, })) else: return render_to_string(templates, Context({ "address": self, }))
def _write_style(self, book): """Creates style file. Style file will include default styling, theme styling and custom styling provided by the user. Created style file will be used by booktype2mpdf.php script to create final PDF file. :Args: - book: EPUB Book object """ if 'settings' not in self.config: return css_style = create_default_style(self.config, self.name, self.get_extra_style(book)) theme_style = u'' if self.theme_name != '': theme_style = read_theme_style(self.theme_name, self.name) try: if self.theme_name == 'custom': custom = self.config['theme'].pop('custom', '{}') custom = json.loads(custom.encode('utf-8')) self.config.update(custom) tmpl = Template(theme_style) ctx = Context(self.config) _style = tmpl.render(ctx) theme_style = _style except: logger.exception("Writing styles failed for `%s` theme." % self.theme_name) custom_style = self.config.get('settings', {}).get('styling', u'') # add css for fpi css_style += self._full_page_images_css f = codecs.open('{}/style.css'.format(self.sandbox_path), 'wt', 'utf8') f.write(css_style) f.write(theme_style) f.write(custom_style) f.close()
def test_extend_and_override(self): """ Here we simulate the existence of a template named admin/base_site.html on the filesystem overriding the title markup of the template. In this test we can view the advantage of using the app_namespace template loader. """ context = Context({}) mark = 'Django administration' mark_title = '<title>APP NAMESPACE</title>' template_directory = Template( '{% extends "admin/base.html" %}' '{% block title %}APP NAMESPACE{% endblock %}' ).render(context) template_namespace = Template( '{% extends "admin:admin/base_site.html" %}' '{% block title %}APP NAMESPACE{% endblock %}' ).render(context) self.assertTrue(mark in template_namespace) self.assertTrue(mark_title in template_namespace) self.assertTrue(mark not in template_directory) self.assertTrue(mark_title in template_directory) template_directory = Template( '{% extends "admin/base.html" %}' '{% load i18n %}' '{% block title %}APP NAMESPACE{% endblock %}' '{% block branding %}' '<h1 id="site-name">{% trans \'Django administration\' %}</h1>' '{% endblock %}' '{% block nav-global %}{% endblock %}' ).render(context) try: self.assertHTMLEqual(template_directory, template_namespace) except AssertionError: # This test will fail under Python > 2.7.3 and Django 1.4 # - https://code.djangoproject.com/ticket/18027 # - http://hg.python.org/cpython/rev/333e3acf2008/ pass self.assertTrue(mark in template_directory) self.assertTrue(mark_title in template_directory)
def get_context(): context = Context() context.template = Template('') return context