Lincoln Loop

Getting RequestContext in Your Templates

Lately, we’ve been taking over projects from people who began building their first site in Django, but either got in over their head or just found they didn’t have the time to continue. As I review the existing code, the first issue I typically see is using the render_to_response shortcut without including the RequestContext, preventing context processors from being used in the templates. The standard symptom is when people can’t access MEDIA_URL in their templates.

Here are a few ways to add RequestContext to your templates.

Option #1: Adding RequestContext to render_to_response

The Django documentation recommends passing RequestContext as an argument to render_to_response like this:

from django.shortcuts import render_to_response
from django.template import RequestContext

def my_view(request):
    # View code here...
    return render_to_response('my_template.html',
                              my_data_dictionary,
                              context_instance=RequestContext(request))

This works, but as you can see, it adds a fair amount of repetitive code to your views.

Option #2: Wrapper for render_to_response

Don’t repeat yourself. Create a wrapper like this, courtesy of Django Snippet #3

from django.shortcuts import render_to_response
from django.template import RequestContext

def render_response(req, *args, **kwargs):
    kwargs['context_instance'] = RequestContext(req)
    return render_to_response(*args, **kwargs)

Option #3: Use Generic Views

Django’s generic views include RequestContext by default. Although the docs show them being used in urls.py, you can just as easily use them in your views. James Bennet gave some examples of this technique on his blog back in ‘06. It looks something like this:

from django.views.generic import list_detail

def my_view(request):
    # View code here...
    return list_detail.object_list_(request,
                                    queryset=Foo.objects.all(),
                                    extra_context=some_dict)

Most views can be distilled down to either a single object or list of objects with some extra variables thrown in. When they can’t, simply use direct_to_template.

Option #4: Getting Creative with Decorators

I came across a technique I hadn’t seen before a couple of days ago when poking around django-cashflow. It monkey patches render_to_response using option #1 above, then creates uses a decorator for it. The code looks like this:

def render_to(template_name):
    def renderer(func):
        def wrapper(request, *args, **kw):
            output = func(request, *args, **kw)
            if not isinstance(output, dict):
                return output
            return render_to_response(request, template_name, output)
        return wrapper
    return renderer

@render_to('my_template.html')
def my_view(request):
    # View code here...
    return some_dict

Pretty slick.

How About You?

I use generic views for a few of reasons.

• It is less verbose than option #1
• Options 2 & 4 are clever, but I prefer to use built-ins whenever possible. One of the reasons I chose Python over Ruby is because it isn’t a TIMTOWTDI language. Wrappers and shortcuts are great, but they can also make it more difficult for someone else to jump into your code and start working. With generic views, you get sane defaults and everything is already fully documented and clear to other Django developers.
• They provide a standardized naming scheme for your templates. Again allowing other developers to jump right into your code without having to learn your style.

So how about you? What technique do you use and why?

Reader Comments

• May 10, 2008 at 3:44 p.m. #
  David, biologeek chimed in with:

  What about django.views.generic.simple.direct_to_template?

• May 10, 2008 at 3:44 p.m. #
  Matt Wilson responded:

  I’ve always used

  render_to_response(‘template’, RequestContext(request, data_dict))

  which seems to work fine, and isn’t so bad.

• May 11, 2008 at 4:01 p.m. #
  SmileyChris added:

  Like David suggested, just use the direct_to_template view as you would the render_to_response template (but passing request as the first argument).

  Easy peasy.

• May 11, 2008 at 8:33 p.m. #
  Peter Baumgartner responded:

  David, I mentioned direct_to_template in Option 3 (my personal choice), but only use it when one of the other generic views doesn’t make more sense.

• May 12, 2008 at 1:43 a.m. #
  LMZ chimed in with:

  +1 for direct_to_template! simple + beautiful and without inventing the wheel.

• May 12, 2008 at 8:40 a.m. #
  njharman chimed in with:

  I do this. I do repeat the “context = RequestContext(request)” line in (most)every view but I like being explicit like that.

  context = RequestContext(request)
  context[“somevar”] = “foo”
  context[“othervar”] = “bar”
  return render_to_response(“template.html”, context)

• May 12, 2008 at 10:40 a.m. #
  Empty responded:

  Nice writeup. Another good resource to point people to.

• May 13, 2008 at 8:50 a.m. #
  sean responded:

  thanks for your code!
  it helps me a lot in using RequestContext

• May 15, 2008 at 12:28 a.m. #
  David, biologeek piped up:

  In fact, direct_to_template is more a replacement for #1 given the fact it does exactly the same as #2, otherwise, if a generic_view already exists (#3), it’s more interesting to use it like you mention.

• May 15, 2008 at 8:12 a.m. #
  Peter Baumgartner commented:

  David, direct_to_template is a generic view.
  django.views.generic.simple.direct_to_template :)

Got something to say?