python类Template()的实例源码

def load_template(self, template_name, template_dirs=None):
        warnings.warn(
            'The load_template() method is deprecated. Use get_template() '
            'instead.', RemovedInDjango20Warning,
        )
        key = self.cache_key(template_name, template_dirs)
        template_tuple = self.template_cache.get(key)
        # A cached previous failure:
        if template_tuple is TemplateDoesNotExist:
            raise TemplateDoesNotExist(template_name)
        elif template_tuple is None:
            template, origin = self.find_template(template_name, template_dirs)
            if not hasattr(template, 'render'):
                try:
                    template = Template(template, origin, template_name, self.engine)
                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.
                    self.template_cache[key] = (template, origin)
            self.template_cache[key] = (template, None)
        return self.template_cache[key]

def load_template(self, template_name, template_dirs=None):
        warnings.warn(
            'The load_template() method is deprecated. Use get_template() '
            'instead.', RemovedInDjango20Warning,
        )
        source, display_name = self.load_template_source(
            template_name, template_dirs,
        )
        origin = Origin(
            name=display_name,
            template_name=template_name,
            loader=self,
        )
        try:
            template = Template(source, origin, template_name, self.engine)
        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 test_send_email_message(self, get_template, send_mail):
        # send_email_message comes up with the expected template names
        # and calls send_mail with the expected arguments
        test_template = Template("test template")
        get_template.return_value = test_template

        context = {'a': 1, 'b': 2}
        send_email_message("TESTNAME", "from_address", [1, 2], [], context)

        args, kwargs = get_template.call_args_list[0]
        expected_template_name = "tutorials/email/TESTNAME/subject.txt"
        self.assertEqual(expected_template_name, args[0])

        args, kwargs = get_template.call_args_list[1]
        expected_template_name = "tutorials/email/TESTNAME/body.txt"
        self.assertEqual(expected_template_name, args[0])

        self.assertEqual(1, send_mail.call_count)

def get(self, request, object_id):
        model_fields = [f.name for f in self.opts.fields]
        fields = [f for f in request.GET['fields'].split(',') if f in model_fields]
        defaults = {
            "form": self.form,
            "fields": fields,
            "formfield_callback": self.formfield_for_dbfield,
        }
        form_class = modelform_factory(self.model, **defaults)
        form = form_class(instance=self.org_obj)

        helper = FormHelper()
        helper.form_tag = False
        helper.include_media = False
        form.helper = helper

        s = '{% load i18n crispy_forms_tags %}<form method="post" action="{{action_url}}">{% crispy form %}' + \
            '<button type="submit" class="btn btn-success btn-block btn-sm">{% trans "Apply" %}</button></form>'
        t = template.Template(s)
        c = template.Context({'form': form, 'action_url': self.model_admin_url('patch', self.org_obj.pk)})

        return HttpResponse(t.render(c))

def test_simple(self):
        tpl = Template("""
<div class="echoices">
{{ echoices }}
</div>
<div class="echoices.FIELD1">
{{ echoices.FIELD1 }}
</div>
<div class="echoices.FIELD1.value">
{{ echoices.FIELD1.value }}
</div>
<div class="echoices.FIELD1.label">
{{ echoices.FIELD1.label }}
</div>
""")
        ctx = Context(dict(echoices=ETestCharChoices))
        rendered = tpl.render(ctx)
        rendered = str(rendered.strip())
        self.assertIn(ETestCharChoices.FIELD1.name, rendered)
        self.assertIn(ETestCharChoices.FIELD1.value, rendered)
        self.assertIn(ETestCharChoices.FIELD1.label, rendered)

def test_iteration(self):
        tpl = Template("""
{% for e in echoices %}
    <div class="e">
    {{ e }}
    </div>
    <div class="e.value">
    {{ e.value }}
    </div>
    <div class="e.label">
    {{ e.label }}
    </div>
{% endfor %}
""")
        ctx = Context(dict(echoices=ETestCharChoices))
        rendered = tpl.render(ctx)
        rendered = str(rendered.strip())
        for e in ETestCharChoices:
            self.assertIn(e.name, rendered)
            self.assertIn(e.value, rendered)
            self.assertIn(e.label, rendered)

def test_preferences_cp(self):
        request = RequestFactory().get('/')
        context = context_processors.preferences_cp(request)

        # context should have preferences.
        my_preferences = context['preferences']

        # preferences should have test MyPreferences object member.
        my_preferences = my_preferences.MyPreferences
        self.failUnless(isinstance(my_preferences, MyPreferences),
                        "%s should be instance of MyPreferences." % my_preferences)

        # With preferences_cp is loaded as a TEMPLATE_CONTEXT_PROCESSORS
        # templates should have access to preferences object.
        context_instance = RequestContext(request)
        t = Template("{% if preferences %}{{ preferences }}{% endif %}")
        self.failUnless(t.render(context_instance), "preferences should be \
available in template context.")

        t = Template("{% if preferences.MyPreferences %}{{ \
preferences.MyPreferences }}{% endif %}")
        self.failUnless(t.render(context_instance), "MyPreferences should be \
available as part of preferences var in template context.")

def get(self, request, object_id):
        model_fields = [f.name for f in self.opts.fields]
        fields = [f for f in request.GET['fields'].split(',') if f in model_fields]
        defaults = {
            "form": self.form,
            "fields": fields,
            "formfield_callback": self.formfield_for_dbfield,
        }
        form_class = modelform_factory(self.model, **defaults)
        form = form_class(instance=self.org_obj)

        helper = FormHelper()
        helper.form_tag = False
        helper.include_media = False
        form.helper = helper

        s = '{% load i18n crispy_forms_tags %}<form method="post" action="{{action_url}}">{% crispy form %}' + \
            '<button type="submit" class="btn btn-success btn-block btn-sm">{% trans "Apply" %}</button></form>'
        t = template.Template(s)
        c = template.Context({'form': form, 'action_url': self.model_admin_url('patch', self.org_obj.pk)})

        return HttpResponse(t.render(c))

def inclusion_tag(file_name, context_class=Context, takes_context=False):
    def wrap(func):
        @functools.wraps(func)
        def method(self, context, nodes, *arg, **kwargs):
            _dict = func(self, context, nodes, *arg, **kwargs)
            from django.template.loader import get_template, select_template
            if isinstance(file_name, Template):
                t = file_name
            elif not isinstance(file_name, basestring) and is_iterable(file_name):
                t = select_template(file_name)
            else:
                t = get_template(file_name)

            _dict['autoescape'] = context.autoescape
            _dict['use_l10n'] = context.use_l10n
            _dict['use_tz'] = context.use_tz
            _dict['admin_view'] = context['admin_view']

            csrf_token = context.get('csrf_token', None)
            if csrf_token is not None:
                _dict['csrf_token'] = csrf_token
            nodes.append(t.render(_dict))

        return method
    return wrap

def get(self, request, object_id):
        model_fields = [f.name for f in self.opts.fields]
        fields = [f for f in request.GET['fields'].split(',') if f in model_fields]
        defaults = {
            "form": self.form,
            "fields": fields,
            "formfield_callback": self.formfield_for_dbfield,
        }
        form_class = modelform_factory(self.model, **defaults)
        form = form_class(instance=self.org_obj)

        helper = FormHelper()
        helper.form_tag = False
        helper.include_media = False
        form.helper = helper

        s = '{% load i18n crispy_forms_tags %}<form method="post" action="{{action_url}}">{% crispy form %}' + \
            '<button type="submit" class="btn btn-success btn-block btn-sm">{% trans "Apply" %}</button></form>'
        t = template.Template(s)
        c = template.Context({'form': form, 'action_url': self.model_admin_url('patch', self.org_obj.pk)})

        return HttpResponse(t.render(c))

def raise_no_permission_exception(self, instance=None):
        from django.template import Context, Template
        t = Template("""
            <!DOCTYPE HTML>
            <html lang="en">
            <head>
                <meta charset="UTF-8">
                <title></title>
            </head>
            <body>
                No permission to perform this action
                {% if instance %}
                    <br/>
                    <a href="{% url 'wf_detail' instance.pk %}"> View this process </a>
                {% endif %}
            </body>
            </html>
            """)
        http_response = HttpResponse(
            t.render(Context({"instance": instance})), content_type='text/html', status=403)
        raise HttpResponseException(http_response)

def get(self, request, object_id):
        model_fields = [f.name for f in self.opts.fields]
        fields = [f for f in request.GET['fields'].split(',') if f in model_fields]
        defaults = {
            "form": self.form,
            "fields": fields,
            "formfield_callback": self.formfield_for_dbfield,
        }
        form_class = modelform_factory(self.model, **defaults)
        form = form_class(instance=self.org_obj)

        helper = FormHelper()
        helper.form_tag = False
        helper.include_media = False
        form.helper = helper

        s = '{% load i18n crispy_forms_tags %}<form method="post" action="{{action_url}}">{% crispy form %}' + \
            '<button type="submit" class="btn btn-success btn-block btn-sm">{% trans "Apply" %}</button></form>'
        t = template.Template(s)
        c = template.Context({'form': form, 'action_url': self.model_admin_url('patch', self.org_obj.pk)})

        return HttpResponse(t.render(c))

def get(self, request, object_id):
        model_fields = [f.name for f in self.opts.fields]
        fields = [f for f in request.GET['fields'].split(',') if f in model_fields]
        defaults = {
            "form": self.form,
            "fields": fields,
            "formfield_callback": self.formfield_for_dbfield,
        }
        form_class = modelform_factory(self.model, **defaults)
        form = form_class(instance=self.org_obj)

        helper = FormHelper()
        helper.form_tag = False
        helper.include_media = False
        form.helper = helper

        s = '{% load i18n crispy_forms_tags %}<form method="post" action="{{action_url}}">{% crispy form %}' + \
            '<button type="submit" class="btn btn-success btn-block btn-sm">{% trans "Apply" %}</button></form>'
        t = template.Template(s)
        c = template.Context({'form': form, 'action_url': self.model_admin_url('patch', self.org_obj.pk)})

        return HttpResponse(t.render(c))

def echarts_js_dependencies(context, *args):
    dependencies = []

    def _add(_x):
        if _x not in dependencies:
            dependencies.append(_x)

    for a in args:
        if hasattr(a, 'js_dependencies'):
            for d in a.js_dependencies:
                _add(d)
        elif isinstance(a, six.text_type):
            _add(a)
    if len(dependencies) > 1:
        dependencies.remove('echarts')
        dependencies = ['echarts'] + list(dependencies)
    links = map(DJANGO_ECHARTS_SETTINGS.host_store.generate_js_link, dependencies)

    return template.Template(
        '<br/>'.join(['<script src="{link}"></script>'.format(link=l) for l in links])
    ).render(context)

def test_template(self):
        # prepare a base template using the default engine
        template = Template("Hello {{name}}!")
        ctx = Context({'name': 'Django'})

        # (trace) the template rendering
        start = time.time()
        eq_(template.render(ctx), 'Hello Django!')
        end = time.time()

        # tests
        spans = self.tracer.writer.pop()
        assert spans, spans
        eq_(len(spans), 1)

        span = spans[0]
        eq_(span.span_type, 'template')
        eq_(span.name, 'django.template')
        eq_(span.get_tag('django.template_name'), 'unknown')
        assert start < span.start < span.start + span.duration < end

def test_render_recursetree(db):
    a = MyTree.objects.create(label='a')
    MyTree.objects.create(label='ab', parent=a)

    t = Template(
        "{% load mpathy %}{% recursetree nodes %}"
        "{% for node in nodes %}\n"
        "    <li>{{ node.label }}<ul>{% recurse node.get_children %}</ul></li>"
        "{% endfor %}"
        "{% endrecursetree %}"
    )

    context = Context({
        'nodes': MyTree.objects.all(),
    })
    rendered = t.render(context)

    assert rendered == (
        '\n'
        '    <li>a<ul>\n'
        '    <li>ab<ul></ul></li></ul></li>'
    )

def build_messages(self, data):
        """
        Build email and SMS messages using the custom templates and webhook 
        data.
        """

        messages = {}

        if self.text_message:
            messages['text'] = Template(self.text_message).render(Context(data))

        if self.html_message:
            messages['html'] = Template(self.html_message).render(Context(data))

        if self.sms_message:
            messages['sms'] = Template(self.sms_message).render(Context(data))

        return messages

def inclusion_tag(file_name, context_class=Context, takes_context=False):
    def wrap(func):
        @functools.wraps(func)
        def method(self, context, nodes, *arg, **kwargs):
            _dict = func(self, context, nodes, *arg, **kwargs)
            from django.template.loader import get_template, select_template
            if isinstance(file_name, Template):
                t = file_name
            elif not isinstance(file_name, basestring) and is_iterable(file_name):
                t = select_template(file_name)
            else:
                t = get_template(file_name)

            _dict['autoescape'] = context.autoescape
            _dict['use_l10n'] = context.use_l10n
            _dict['use_tz'] = context.use_tz
            _dict['admin_view'] = context['admin_view']

            csrf_token = context.get('csrf_token', None)
            if csrf_token is not None:
                _dict['csrf_token'] = csrf_token
            nodes.append(t.render(_dict))

        return method
    return wrap

def get(self, request, object_id):
        model_fields = [f.name for f in self.opts.fields]
        fields = [f for f in request.GET['fields'].split(',') if f in model_fields]
        defaults = {
            "form": self.form,
            "fields": fields,
            "formfield_callback": self.formfield_for_dbfield,
        }
        form_class = modelform_factory(self.model, **defaults)
        form = form_class(instance=self.org_obj)

        helper = FormHelper()
        helper.form_tag = False
        helper.include_media = False
        form.helper = helper

        s = '{% load i18n crispy_forms_tags %}<form method="post" action="{{action_url}}">{% crispy form %}' + \
            '<button type="submit" class="btn btn-success btn-block btn-sm">{% trans "Apply" %}</button></form>'
        t = template.Template(s)
        c = template.Context({'form': form, 'action_url': self.model_admin_url('patch', self.org_obj.pk)})

        return HttpResponse(t.render(c))

def get_context_data(self,**kwargs):
        context = super(GiftCertificatePDFView,self).get_context_data(**kwargs)

        template = getConstant('vouchers__giftCertPDFTemplate')

        # For security reasons, the following tags are removed from the template before parsing:
        # {% extends %}{% load %}{% debug %}{% include %}{% ssi %}
        content = re.sub('\{%\s*((extends)|(load)|(debug)|(include)|(ssi))\s+.*?\s*%\}','',template.content)

        t = Template(content)

        rendered_content = t.render(Context(context))

        context.update({
            'header': template.subject,
            'content': rendered_content
        })

        return context

def get_dynamic_desc(self, language):
        if language == "en":
            template = Template(self.description_en)
        else:
            template = Template(self.description_de)
        context = Context({
            "advisor": self.advisor,
            "afterparty_location": self.afterparty_time,
            "afterparty_time": self.afterparty_time,
            "appetizer_time": self.appetizer_time,
            "event_date": self.date,
            "dessert_time": self.dessert_time,
            "end_registration": self.end_registration,
            "event_name": self.name,
            "event_semester": self.semester,
            "main_course_time": self.main_course_time,
        })
        dyn_desc = template.render(context)
        return dyn_desc

def render_string(self, template_name, **kwargs):
        #template_path = self.get_template_path()
        #if not template_path:
            #frame = sys._getframe(0)
            #web_file = frame.f_code.co_filename
            #while frame.f_code.co_filename == web_file:
                #frame = frame.f_back
            #template_path = os.path.dirname(frame.f_code.co_filename)
        #with RequestHandler._template_loader_lock:
            #if template_path not in RequestHandler._template_loaders:
                #loader = self.create_template_loader(template_path)
                #RequestHandler._template_loaders[template_path] = loader
            #else:
                #loader = RequestHandler._template_loaders[template_path]
        #t = loader.load(template_name)
        #namespace = self.get_template_namespace()
        #namespace.update(kwargs)
        #return t.generate(**namespace)
        with io.open(template_name, mode='r',encoding='UTF-8') as f:
            html = f.read()
        template_strings = Template(html)
        return template_strings.render(context=Context(dict_=kwargs))

def get(self, request, object_id):
        model_fields = [f.name for f in self.opts.fields]
        fields = [f for f in request.GET['fields'].split(',') if f in model_fields]
        defaults = {
            "form": forms.ModelForm,
            "fields": fields,
            "formfield_callback": self.formfield_for_dbfield,
        }
        form_class = modelform_factory(self.model, **defaults)
        form = form_class(instance=self.org_obj)

        helper = FormHelper()
        helper.form_tag = False
        form.helper = helper

        s = '{% load i18n crispy_forms_tags %}<form method="post" action="{{action_url}}">{% crispy form %}'+ \
            '<button type="submit" class="btn btn-success btn-block btn-sm">{% trans "Apply" %}</button></form>'
        t = template.Template(s)
        c = template.Context({'form':form, 'action_url': self.model_admin_url('patch', self.org_obj.pk)})

        return HttpResponse(t.render(c))

def get_initial(self, *args, **kwargs):
        event = Event.objects.get(pk=self.kwargs['pk'])

        event_data = dict(event.__dict__)

        if not event_data.get('creator_name', None):
            event_data['creator_name'] = " ".join([event.creator_cons.firstname, event.creator_cons.lastname])

        return {
                    'event': event,
                    'volunteer_count': 4000 if event.capacity == 0 else event.capacity * 40,
                    'subject': "Please come to my %s event" % event.event_type.name,
                    'message': Template("""Hello --

I'm hoping to get more attendees at my event, {{ event.name }}! Can you make it? We're almost across the finish line and we need to keep up the momentum.


Thanks!


{{ event.creator_cons.firstname }}""").render(Context({'event': event}))
                }

def test_pagenav_tag(self):
        """Pagenav tag returns page navigation widget"""
        # prepare paginator
        paginator = Paginator([1, 2, 3, 4], 1)
        my_list = paginator.page('1')
        test_url = 'test/'

        # render template with pagenav tag
        out = Template(
            "{% load pagenav %}"
            "{% pagenav object_list base_url order_by reverse cur_month is_paginated paginator %}"
        ).render(Context({
            'object_list': my_list, 'base_url': test_url, 'order_by': None, 'reverse': None, 'cur_month': None, 'is_paginated': True, 'paginator': paginator
        }))

        # paginator should create 4 pages
        self.assertIn('<nav>', out)
        self.assertIn('<a href="test/?page=1" class="content-link">1</a>', out)
        self.assertIn('<a href="test/?page=2" class="content-link">2</a>', out)
        self.assertIn('<a href="test/?page=3" class="content-link">3</a>', out)
        self.assertIn('<a href="test/?page=4" class="content-link">4</a>', out)

def test_str2int(self):
        """Test str2int template filter"""
        out = Template(
            "{% load str2int %}"
            "{% if 36 == '36'|str2int %}"
            "it works"
            "{% endif %}"
        ).render(Context({}))

        # check for our addition operation result
        self.assertIn("it works", out)

        out = Template(
            "{% load str2int %}"
            "{% if 0 == 'Zero'|str2int %}"
            "it works"
            "{% endif %}"
        ).render(Context({}))

        # check for our addition operation result
        self.assertIn("it works", out)

def get_embed_code(self, size='double'):
        """Return the embed code for the chart."""
        def simple_string(split_string):
            """Return a string stripped of extra whitespace."""
            return ' '.join(split_string.split())

        template_object = template.Template(app_settings.EMBED_TEMPLATE)
        template_context_object = app_settings.EMBED_TEMPLATE_CONTEXT(self)
        template_context_object.update({
            'size': size,
            'id': self.slug,
            'dimensions': json.dumps(self.embed_data).replace('"', '"'),
        })
        return simple_string(
            template_object.render(template.Context(
                template_context_object
            ))
        )

def load_template(self, template_name, template_dirs=None):
        warnings.warn(
            'The load_template() method is deprecated. Use get_template() '
            'instead.', RemovedInDjango20Warning,
        )
        key = self.cache_key(template_name, template_dirs)
        template_tuple = self.template_cache.get(key)
        # A cached previous failure:
        if template_tuple is TemplateDoesNotExist:
            raise TemplateDoesNotExist(template_name)
        elif template_tuple is None:
            template, origin = self.find_template(template_name, template_dirs)
            if not hasattr(template, 'render'):
                try:
                    template = Template(template, origin, template_name, self.engine)
                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.
                    self.template_cache[key] = (template, origin)
            self.template_cache[key] = (template, None)
        return self.template_cache[key]

def load_template(self, template_name, template_dirs=None):
        warnings.warn(
            'The load_template() method is deprecated. Use get_template() '
            'instead.', RemovedInDjango20Warning,
        )
        source, display_name = self.load_template_source(
            template_name, template_dirs,
        )
        origin = Origin(
            name=display_name,
            template_name=template_name,
            loader=self,
        )
        try:
            template = Template(source, origin, template_name, self.engine)
        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 inclusion_tag(file_name, context_class=Context, takes_context=False):
    def wrap(func):
        @functools.wraps(func)
        def method(self, context, nodes, *arg, **kwargs):
            _dict = func(self, context, nodes, *arg, **kwargs)
            from django.template.loader import get_template, select_template
            if isinstance(file_name, Template):
                t = file_name
            elif not isinstance(file_name, basestring) and is_iterable(file_name):
                t = select_template(file_name)
            else:
                t = get_template(file_name)

            _dict['autoescape'] = context.autoescape
            _dict['use_l10n'] = context.use_l10n
            _dict['use_tz'] = context.use_tz
            _dict['admin_view'] = context['admin_view']

            csrf_token = context.get('csrf_token', None)
            if csrf_token is not None:
                _dict['csrf_token'] = csrf_token
            nodes.append(t.render(_dict))

        return method
    return wrap