Render this collected content to a response.

        :param request: the request
        :param parent: the parent collection
        :param args:
        :param kwargs:
        :return:
493139
def get_response(self, request, parent, *args, **kwargs):
        
        context = {
            'page': self,
        }
        try:
            return TemplateResponse(
                request,
                self.get_layout_template_name(),
                context
            )
        except AttributeError:
            raise AttributeError("You need to define "
                 "`get_layout_template_name()` on your `%s` model, "
                 "or override `get_response()`" % type(self).__name__)
1018132
def render(self, context):
        
        try:
            args, ctx = self.get_resolved_arguments(context)
            target = args[0]
            if not target:
                return ''
            ctx['content'] = target
        except VariableDoesNotExist:
            return ''

        emitter = context.get('emitter')
        t_name = emitter.get_template_path(target)
        t = get_template(t_name)
        context.dicts.append(ctx)
        response = t.nodelist.render(context)
        context.pop()
        return response
863488
def server(request):
    
    return render_to_response(
        'server/index.html', {
            'user_url': getViewURL(request, idPage),
            'server_xrds_url': getViewURL(request, idpXrds),
        },
        context_instance=RequestContext(request))
270806
public void renderView(HttpServerRequest request, JsonObject params) {
		renderView(request, params, null, null, 200);
	}
249205
def render_to_response(self, context, **response_kwargs):
        
        serializer = GeoJSONSerializer()
        response = self.response_class(**response_kwargs)
        queryset = self.get_queryset()

        options = dict(properties=self.properties,
                       precision=self.precision,
                       simplify=self.simplify,
                       srid=self.srid,
                       geometry_field=self.geometry_field,
                       force2d=self.force2d,
                       bbox=self.bbox,
                       bbox_auto=self.bbox_auto,
                       use_natural_keys=self.use_natural_keys,
                       with_modelname=self.with_modelname)
        serializer.serialize(queryset, stream=response, ensure_ascii=False,
                             **options)
        return response
494218
def _maintain_parent(self, request, response):
        
        location = response._headers.get("location")
        parent = request.GET.get("parent")
        if parent and location and "?" not in location[1]:
            url = "%s?parent=%s" % (location[1], parent)
            return HttpResponseRedirect(url)
        return response
903831
def post(self, request, *args, **kwargs):
        
        queryset = self.get_selected(request)

        if request.POST.get('modify'):
            response = self.process_action(request, queryset)
            if not response:
                url = self.get_done_url()
                return self.render(request, redirect_url=url)
            else:
                return response
        else:
            return self.render(request, redirect_url=request.build_absolute_uri())
93122
def render_html(self, request, instance, context):
        
        render_template = self.get_render_template(request, instance, email_format='html')
        if not render_template:
            return str(u"{No HTML rendering defined for class '%s'}" % self.__class__.__name__)

        instance_context = self.get_context(request, instance, email_format='html', parent_context=context)
        instance_context['email_format'] = 'html'

        html = self.render_to_string(request, render_template, instance_context)
        if self.render_replace_context_fields:
            html = replace_fields(html, instance_context)  # pass safe-string
        return html
1301501
def response_add(self, request, obj):
        
        response = super(PageAdmin, self).response_add(request, obj)
        return self._maintain_parent(request, response)
1365176
def render_POST(self, request):
        
        from twisted.internet.defer import maybeDeferred
        
        chain = self.factory.newInstance()
        data = request.content.read()
        
        d = maybeDeferred(chain.processRequest, data, request=request, resource=self)
        d.addCallback(chain.processResponse, request=request, resource=self)
        d.addCallback(self._writeResponse, request)
        d.addErrback(self._writeFault, request)
        
        return NOT_DONE_YET
15140
def render_to_response(self, context):
        
        self.setup_forms()
        return TemplateResponse(
            self.request, self.form_template,
            context, current_app=self.admin_site.name)
597004
def render(self, request, context, status=codes.ok, content_type=None,
            args=None, kwargs=None):
        ""

        if isinstance(self.template_name, (list, tuple)):
            template = loader.select_template(self.template_name)
        elif self.template_name:
            template = loader.get_template(self.template_name)
        else:
            template = loader.Template(self.template_string)

        context = RequestContext(request, context)
        content = template.render(context)

        return HttpResponse(content, status=status, content_type=content_type)
632670
def displayResponse(request, openid_response):
    
    s = getServer(request)

    # Encode the response into something that is renderable.
    try:
        webresponse = s.encodeResponse(openid_response)
    except EncodingError as why:
        # If it couldn't be encoded, display an error.
        text = why.response.encodeToKVForm()
        return render_to_response(
            'server/endpoint.html', {'error': cgi.escape(text)},
            context_instance=RequestContext(request))

    # Construct the appropriate django framework response.
    r = http.HttpResponse(webresponse.body)
    r.status_code = webresponse.code

    for header, value in webresponse.headers.items():
        r[header] = value

    return r
221796
def render_to_response(self, template_name, __data,
                           content_type="text/html"):
        ''''''
        resp = self.render(template_name, __data)
        return Response(resp,
                        content_type=content_type)
730773
def loaded(self, request, *args, **kwargs):
        
        serializer = self.get_serializer(list(Pack.objects.all()),
                                         many=True)
        return Response(serializer.data)
1182969
def render(self, data, accepted_media_type=None, renderer_context=None):
        
        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
968467
def render(self, form, form_style, context):
        
        return render_to_string(self.template, Context({'input': self}))