After some trial and error, I have code completion working in my project.

Here is what I've figured out:

PyCharm code completion for context variables in Django templates works under the following conditions:

1. When using render() in the corresponding view
2. When passing the template name as a string literal to the render() function

As far as I can tell, it will not work when using either TemplateResponse() or HttpResponse() (along with the django.template.loader module) instead of render(). It will also not work when the template path is passed to render() as a variable instead of as a string literal.

For example, code completion works when the view is written like this:

def detail(request, question_id):
    question = get_object_or_404(Question, pk=question_id)
    return render(request, "polls/detail.html", {"question": question})

It's also fine to pass the context as a variable, so this works, too:

def detail(request, question_id):
    question = get_object_or_404(Question, pk=question_id)
    context = {"question": question}
    return render(request, "polls/detail.html", context)

However, code completion fails when the view is written in any of the following ways:

e.g., when passing the template_name as a variable to render() instead of as a string literal:

def detail(request, question_id):
    question = get_object_or_404(Question, pk=question_id)
    template_name = "polls/detail.html"
    return render(request, template_name, {"question": question})

e.g., when using TemplateResponse() instead of render():

def detail(request, question_id):
    question = get_object_or_404(Question, pk=question_id)
    return TemplateResponse(request, "polls/detail.html", {"question": question})

e.g., when using HttpResponse() like this:

def detail(request, question_id):
    question = get_object_or_404(Question, pk=question_id)
    template = loader.get_template('polls/detail.html')
    return HttpResponse(template.render({"question": question}, request))

But why?

I assume that the code completion failure with TemplateResponse() might have something to do with how it implements delayed rendering. Maybe the failure when using HttpResponse() (along with the django.template.loader module) happens for similar reasons.

I'm not sure why code completion fails unless the template_name is provided directly to render as a string literal. It seems that static code analysis should be able to figure it out if it's passed as a variable that's defined using a string literal in the same view.

Caveats

There are a couple of things to watch out for if you have at least two views using the same template:

1. Code completion will work even if only one of the views uses render() (and also uses a string literal for template_name within render()). This is confusing, because the other view(s) could use TemplateResponse(), for example, and code completion of context variables would still appear to work correctly in the corresponding template.

2. If the views using the same template have different context variables, PyCharm will offer to code complete all of them in the template. This could cause problems, for example, if one of the views passes an error_message variable within its context but another view does not. PyCharm will offer to autocomplete the error_message variable in the template without warning that some views don't pass this variable in the context.

Epilogue

I didn't change anything about my project structure other than changing the views to use render() (from django.shortcuts), and making sure that string literals are used for the template_name within render().

I'm still not convinced that PyCharm shouldn't be able to do code completion of context variables within templates unless this magic formula is followed. I'm not sure if this is a bug, or maybe just something I don't understand about PyCharm.