# dokumentasi Django 2.0.8

# Kode sumber untuk django.template.response

    from django.http import HttpResponse

    from .loader import get_template, select_template

    class ContentNotRenderedError(Exception):
        pass

    class SimpleTemplateResponse(HttpResponse):
        rendering_attrs = ['template_name', 'context_data', '_post_render_callbacks']

        def __init__(self, template, context=None, content_type=None, status=None,
                     charset=None, using=None):
            # It would seem obvious to call these next two members 'template' and
            # 'context', but those names are reserved as part of the test Client
            # API. To avoid the name collision, we use different names.
            self.template_name = template
            self.context_data = context

            self.using = using

            self._post_render_callbacks = []

            # _request stores the current request object in subclasses that know
            # about requests, like TemplateResponse. It's defined in the base class
            # to minimize code duplication.
            # It's called self._request because self.request gets overwritten by
            # django.test.client.Client. Unlike template_name and context_data,
            # _request should not be considered part of the public API.
            self._request = None

            # content argument doesn't make sense here because it will be replaced
            # with rendered template so we always pass empty string in order to
            # prevent errors and provide shorter signature.
            super().__init__('', content_type, status, charset=charset)

            # _is_rendered tracks whether the template and context has been baked
            # into a final response.
            # Super __init__ doesn't know any better than to set self.content to
            # the empty string we just gave it, which wrongly sets _is_rendered
            # True, so we initialize it to False after the call to super __init__.
            self._is_rendered = False

        def __getstate__(self):
            """
            Raise an exception if trying to pickle an unrendered response. Pickle
            only rendered data, not the data used to construct the response.
            """
            obj_dict = self.__dict__.copy()
            if not self._is_rendered:
                raise ContentNotRenderedError('The response content must be '
                                              'rendered before it can be pickled.')
            for attr in self.rendering_attrs:
                if attr in obj_dict:
                    del obj_dict[attr]

            return obj_dict

        def resolve_template(self, template):
            """Accept a template object, path-to-template, or list of paths."""
            if isinstance(template, (list, tuple)):
                return select_template(template, using=self.using)
            elif isinstance(template, str):
                return get_template(template, using=self.using)
            else:
                return template

        def resolve_context(self, context):
            return context

        @property
        def rendered_content(self):
            """Return the freshly rendered content for the template and context
            described by the TemplateResponse.

            This *does not* set the final content of the response. To set the
            response content, you must either call render(), or set the
            content explicitly using the value of this property.
            """
            template = self.resolve_template(self.template_name)
            context = self.resolve_context(self.context_data)
            content = template.render(context, self._request)
            return content

        def add_post_render_callback(self, callback):
            """Add a new post-rendering callback.

            If the response has already been rendered,
            invoke the callback immediately.
            """
            if self._is_rendered:
                callback(self)
            else:
                self._post_render_callbacks.append(callback)

        def render(self):
            """Render (thereby finalizing) the content of the response.

            If the content has already been rendered, this is a no-op.

            Return the baked response instance.
            """
            retval = self
            if not self._is_rendered:
                self.content = self.rendered_content
                for post_callback in self._post_render_callbacks:
                    newretval = post_callback(retval)
                    if newretval is not None:
                        retval = newretval
            return retval

        @property
        def is_rendered(self):
            return self._is_rendered

        def __iter__(self):
            if not self._is_rendered:
                raise ContentNotRenderedError(
                    'The response content must be rendered before it can be iterated over.'
                )
            return super().__iter__()

        @property
        def content(self):
            if not self._is_rendered:
                raise ContentNotRenderedError(
                    'The response content must be rendered before it can be accessed.'
                )
            return super().content

        @content.setter
        def content(self, value):
            """Set the content for the response."""
            HttpResponse.content.fset(self, value)
            self._is_rendered = True

    class TemplateResponse(SimpleTemplateResponse):
        rendering_attrs = SimpleTemplateResponse.rendering_attrs + ['_request']

        def __init__(self, request, template, context=None, content_type=None,
                     status=None, charset=None, using=None):
            super().__init__(template, context, content_type, status, charset, using)
            self._request = request