我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用django.template()。
def handle_template(self, template, subdir): """ Determines where the app or project templates are. Use django.__path__[0] as the default because we don't know into which directory Django has been installed. """ if template is None: return path.join(django.__path__[0], 'conf', subdir) else: if template.startswith('file://'): template = template[7:] expanded_template = path.expanduser(template) expanded_template = path.normpath(expanded_template) if path.isdir(expanded_template): return expanded_template if self.is_url(template): # downloads the file and returns the path absolute_path = self.download(template) else: absolute_path = path.abspath(expanded_template) if path.exists(absolute_path): return self.extract(absolute_path) raise CommandError("couldn't handle %s template %s." % (self.app_or_project, template))
def add_arguments(self, parser): parser.add_argument('name', help='Name of the application or project.') parser.add_argument('directory', nargs='?', help='Optional destination directory') parser.add_argument('--template', help='The path or URL to load the template from.') parser.add_argument( '--extension', '-e', dest='extensions', action='append', default=['py'], help='The file extension(s) to render (default: "py"). ' 'Separate multiple extensions with commas, or use ' '-e multiple times.' ) parser.add_argument( '--name', '-n', dest='files', action='append', default=[], help='The file name(s) to render. Separate multiple extensions ' 'with commas, or use -n multiple times.' )
def render(self, name, value, attrs=None): if attrs is None: attrs = {} # it's called "original" because it will be replaced by a copy attrs['class'] = 'hstore-original-textarea' # get default HTML from AdminTextareaWidget html = super(BaseAdminHStoreWidget, self).render(name, value, attrs) # prepare template context template_context = Context({ 'field_name': name, 'STATIC_URL': settings.STATIC_URL, 'use_svg': django.VERSION >= (1, 9), # use svg icons if django >= 1.9 }) # get template object template = get_template('happenings/hstore_%s_widget.html' % self.admin_style) # render additional html additional_html = template.render(template_context) # append additional HTML and mark as safe html = html + additional_html html = mark_safe(html) return html
def parse(cls, parser, token): """ Custom parsing for the ``{% ajax_comment_tags for ... %}`` tag. """ # Process the template line. tag_name, args, kwargs = parse_token_kwargs( parser, token, allowed_kwargs=cls.allowed_kwargs, compile_args=False, # Only overrule here, keep at render() phase. compile_kwargs=cls.compile_kwargs ) # remove "for" keyword, so all other args can be resolved in render(). if args[0] == 'for': args.pop(0) # And apply the compilation afterwards for i in range(len(args)): args[i] = parser.compile_filter(args[i]) cls.validate_args(tag_name, *args, **kwargs) return cls(tag_name, *args, **kwargs)
def template_render(template, context=None, request=None): """ Passing Context or RequestContext to Template.render is deprecated in 1.9+, see https://github.com/django/django/pull/3883 and https://github.com/django/django/blob/1.9/django/template/backends/django.py#L82-L84 :param template: Template instance :param context: dict :param request: Request instance :return: rendered template as SafeText instance """ if isinstance(template, Template): if request: context = RequestContext(request, context) else: context = Context(context) return template.render(context) # backends template, e.g. django.template.backends.django.Template else: return template.render(context, request=request)
def template_render(template, context=None, request=None): """ Passing Context or RequestContext to Template.render is deprecated in 1.9+, see https://github.com/django/django/pull/3883 and https://github.com/django/django/blob/1.9rc1/django/template/backends/django.py#L82-L84 :param template: Template instance :param context: dict :param request: Request instance :return: rendered template as SafeText instance """ if django.VERSION < (1, 8) or isinstance(template, Template): if request: context = RequestContext(request, context) else: context = Context(context) return template.render(context) # backends template, e.g. django.template.backends.django.Template else: return template.render(context, request=request)
def render(self, data, accepted_media_type=None, renderer_context=None): """ Renders data to HTML, using Django's standard template rendering. The template name is determined by (in order of preference): 1. An explicit .template_name set on the response. 2. An explicit .template_name set on this class. 3. The return result of calling view.get_template_names(). """ renderer_context = renderer_context or {} view = renderer_context['view'] request = renderer_context['request'] response = renderer_context['response'] if response.exception: template = self.get_exception_template(response) else: template_names = self.get_template_names(response, view) template = self.resolve_template(template_names) context = self.resolve_context(data, request, response) return template_render(template, context, request=request)
def render(self, data, accepted_media_type=None, renderer_context=None): """ Render serializer data and return an HTML form, as a string. """ renderer_context = renderer_context or {} form = data.serializer style = renderer_context.get('style', {}) if 'template_pack' not in style: style['template_pack'] = self.template_pack style['renderer'] = self template_pack = style['template_pack'].strip('/') template_name = template_pack + '/' + self.base_template template = loader.get_template(template_name) context = { 'form': form, 'style': style } return template_render(template, context)
def render(self, data, accepted_media_type=None, renderer_context=None): """ Render the HTML for the browsable API representation. """ self.accepted_media_type = accepted_media_type or '' self.renderer_context = renderer_context or {} template = loader.get_template(self.template) context = self.get_context(data, accepted_media_type, renderer_context) ret = template_render(template, context, request=renderer_context['request']) # Munge DELETE Response code to allow us to return content # (Do this *after* we've rendered the template so that we include # the normal deletion response code in the output) response = renderer_context['response'] if response.status_code == status.HTTP_204_NO_CONTENT: response.status_code = status.HTTP_200_OK return ret
def list_template_files(): """ Return list of template files everywhere Django looks for them. """ engines = django.template.engines template_dirs = [] # 'engines' is not a dictionary, it just behaves like one in some ways for engine_name in engines: engine = engines[engine_name] if isinstance(engine, DjangoTemplates): # We only handle Django templates template_dirs.extend(engine.template_dirs) template_list = [] for each in template_dirs: for dir, dirnames, filenames in os.walk(each): for filename in filenames: template_list.append(os.path.join(dir, filename)) return template_list
def get_loaders(self): template_source_loaders = [] for e in engines.all(): if hasattr(e, 'engine'): template_source_loaders.extend( e.engine.get_template_loaders(e.engine.loaders)) loaders = [] # If template loader is CachedTemplateLoader, return the loaders # that it wraps around. So if we have # TEMPLATE_LOADERS = ( # ('django.template.loaders.cached.Loader', ( # 'django.template.loaders.filesystem.Loader', # 'django.template.loaders.app_directories.Loader', # )), # ) # The loaders will return django.template.loaders.filesystem.Loader # and django.template.loaders.app_directories.Loader # The cached Loader and similar ones include a 'loaders' attribute # so we look for that. for loader in template_source_loaders: if hasattr(loader, 'loaders'): loaders.extend(loader.loaders) else: loaders.append(loader) return loaders
def resolve_context(self, data, request, _response): """Populate the context used for rendering the template :type request: rest_framework.request.Request :type _response: rest_framework.request.Response :param dict data: The serialized alert """ if not 'id' in data: return RequestContext(request, data) # Put the alert object in the context data['alert'] = event.AlertHistory.objects.get(pk=data['id']) netboxid = data.get('netbox') if netboxid: # Replace netbox (the netboxid) with netbox (the object) data.update({ 'netbox': manage.Netbox.objects.get(pk=netboxid) }) return RequestContext(request, data)
def get_template_names(self): """Get the template name based on the alerthist object""" alert = self.get_object() template_names = [] try: template_names.append( 'alertmsg/{a.event_type}/{a.alert_type.name}.html'.format( a=alert)) except AttributeError: pass template_names.extend([ 'alertmsg/{a.event_type}/base.html'.format(a=alert), 'alertmsg/base.html' ]) return template_names
def test_invalid_unicode_characters(self): # Adds a BooleanField that uses non valid unicode characters "ñ" form_helper = FormHelper() form_helper.add_layout( Layout( 'españa' ) ) template = loader.get_template_from_string(u""" {% load crispy_forms_tags %} {% crispy form form_helper %} """) c = Context({'form': TestForm(), 'form_helper': form_helper}) settings.CRISPY_FAIL_SILENTLY = False self.assertRaises(Exception, lambda: template.render(c)) del settings.CRISPY_FAIL_SILENTLY
def test_meta_extra_fields_with_missing_fields(self): class FormWithMeta(TestForm): class Meta: fields = ('email', 'first_name', 'last_name') form = FormWithMeta() # We remove email field on the go del form.fields['email'] form_helper = FormHelper() form_helper.layout = Layout( 'first_name', ) template = loader.get_template_from_string(u""" {% load crispy_forms_tags %} {% crispy form form_helper %} """) c = Context({'form': form, 'form_helper': form_helper}) html = template.render(c) self.assertFalse('email' in html)
def test_layout_unresolved_field(self): form_helper = FormHelper() form_helper.add_layout( Layout( 'typo' ) ) template = loader.get_template_from_string(u""" {% load crispy_forms_tags %} {% crispy form form_helper %} """) c = Context({'form': TestForm(), 'form_helper': form_helper}) settings.CRISPY_FAIL_SILENTLY = False self.assertRaises(Exception, lambda:template.render(c)) del settings.CRISPY_FAIL_SILENTLY
def test_double_rendered_field(self): form_helper = FormHelper() form_helper.add_layout( Layout( 'is_company', 'is_company', ) ) template = loader.get_template_from_string(u""" {% load crispy_forms_tags %} {% crispy form form_helper %} """) c = Context({'form': TestForm(), 'form_helper': form_helper}) settings.CRISPY_FAIL_SILENTLY = False self.assertRaises(Exception, lambda:template.render(c)) del settings.CRISPY_FAIL_SILENTLY
