Avoid the need to call get_context_data() in TemplateView subclasses

[James Pic]

Currently, TemplateView inherits render_to_response(context) from TemplateResponseMixin which requires a context argument.

This means that when your TemplateView subclass wants to return the TemplateResponse with the default context, you still have to create and pass the default context:

class YourView(TemplateView):
    def post(self, request, *a, **k):
        if not self.dostuff():
            return http.HttpResponseBadRequest()

        context = self.get_context_data(*k)
        return self.render_to_response(context)

The reason for this is that ContentMixin defines get_context_data(), and TemplateResponseMixin defines render_to_response(context, ...), TemplateResponse mixes the two in get():

class TemplateView(TemplateResponseMixin, ContextMixin, View):
    """
    Render a template. Pass keyword arguments from the URLconf to the context.
    """
    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)
        return self.render_to_response(context)

I think it would be more usable as such:

class TemplateView(TemplateResponseMixin, ContextMixin, View):
    """
    Render a template. Pass keyword arguments from the URLconf to the context.
    """
    def get(self, request, *args, **kwargs):
        return self.render_to_response(**kwargs)

    def render_to_response(self, context=None, **kwargs):
        context = context or self.get_context_data(**kwargs)
        return self.render_to_response(context)

Then, users could call render_to_response() in their code without dealing with a context they don't override because they are satisfied with the default (which adds view=self in the context), ie:

class YourView(TemplateView):
    def get(self, request, *a, **k):
        self.token = self.generatetoken()
        return self.render_to_response(**k)

    def post(self, request, *a, **k):
        if not self.dostuff():
            return http.HttpResponseBadRequest()
        return self.render_to_response(**k)

[Tim Graham]

The ticket summary is cryptic. Please describe the use case in more detail. I don't see an indication of where TemplateResponse.get(self, request, *args, **kwargs) lives.

[James Pic]

Thanks for your feedback, I rewrote the issue, does it make any sense now ?

[Tim Graham]

Is there a reason to duplicate the render_to_response() call in post()? I didn't test it, but I believe you could write both examples as:

class YourView(TemplateView):
    def post(self, request, *a, **k):
        if not self.dostuff():
            return http.HttpResponseBadRequest()

        return super().get(request, *a, **k)

[James Pic]

Of course, that works, unless you've overridden get() to do things that you don't want to happen on post.

In post, i would like to render to template again, not run get() ;)

[Tim Graham]

Unless I missed something, super().get() will call the TemplateView implementation, even if you override get() in a subclass.

[James Pic]

Yes, returning super().get() allows to bypass the last level of get() override. I try to demonstrate the issue with this script, perhaps it will make more sense.

class TemplateView(object):
    def get(self):
        print('render to response()')


class YourBaseView(TemplateView):
    def get(self):
        print('generate token()')
        return super().get()


class YourView(YourBaseView):
    def post(self):
        # if not dosomething(): return bad request
        return super().get()


YourView().post()

This will print both 'generate token()' and 'render to response()'. If I only want to print 'render to response()', then this works:

class YourView(YourBaseView):
    def post(self):
        # if not dosomething(): return bad request
        return TemplateView.get(self)

But probably it would make sense to just move the render to response outside get() as such:

class TemplateView(object):
    def render_to_response(self):
        print('render to response()')

    def get(self):
        return self.render_to_response()


class YourBaseView(TemplateView):
    def get(self):
        print('generate token()')
        return super().get()


class YourView(YourBaseView):
    def post(self):
        # if not dosomething(): return bad request
        return self.render_to_response()

I thought it would be better that TemplateView add a new method to render a response with a context, and use that in its get(), so TemplateView logic could be more reusable.

[James Pic]

But after considering every option it seems like adding a comment in code would be even useless for this I think an interresting story brought this issue but there's nothing to fix in django so TemplateView.get works for me very well by the way that's actually what i already have actually, sry for the noise <3