What is context proccesor in Django and how to use it?

When developing web applications using Django, we often encounter situations where we want to pass dynamic data to our HTML templates. This data can come from a database, configuration files, environment variables or other sources. In case we only need such data in one particular view, we can pass it through a context, which is a dictionary containing key-value pairs. Unfortunately, using this approach, we only access this data in a specific template.

However, there may be cases where we want access to certain variables across the entire project. In such a situation, it is worth using a Context Processor, which is a special function that we have access to regardless of the template in which we find ourselves. This function takes an HttpRequest object as an argument and returns a dictionary that is added to the template context.

"A context processor has a simple interface: It’s a Python function that takes one argument, an HttpRequest object, and returns a dictionary that gets added to the template context."

Django docoks

In this article, we will discuss how to create your own Context Processors in Django and how to use them in practice to make our lives easier and increase the flexibility of our applications.

Example of a View with Limited Data Access

Let's start by analyzing a situation where we have limited access to data in our views. Let's consider an application that allows for browsing and managing book categories. In our simplified example, the view 'categories_list' allows us to display all the categories stored in our database:

def categories_list(request):      
    all_categories = Category.objects.all()
            
    context = {
        'all_categories':all_categories,
    }

    return render(request, 'categories/categories_view.html', context)

Access to the variable 'all_categories' is only available in the 'categories_view.html' template. While this solution is correct, it can become burdensome if we wanted to display the same data in other parts of our application. It might seem that the simplest way to solve this problem is to duplicate part of the code and place it directly in each view. However, we can do this much more effectively by using Context Processors.

When to Use Context Processors?

Context Processors should be considered when you want to access certain data throughout your entire application or in multiple views. For instance, imagine wanting to access 'all_categories' in the navigation bar, which is displayed on every page of our project. This is probably one of the most common use cases for a dedicated Context Processor, but it's equally well-suited if you want to use it for a sidebar or footer.

Besides, Context Processors can also be used to convey global settings, such as site information, user data, or statistical data. This way, we can organize our code and avoid repeating the same code snippets in different places.

Context Processor Implementation

In the official documentation you can find information that the code of our custom context processor can be placed anywhere without specific restrictions.

Custom context processors can live anywhere in your code base. All Django cares about is that your custom context processors are pointed to by the 'context_processors' option in your TEMPLATES setting 

However, for consistency, I recommend creating a context_processors.py file and placing it inside the pile of which it will apply. In my case it will be:

APPS\categories\context_processors.py

Then, being already inside the file, we import the Model and create the function:

from .models import Category

def categories_context(request):         
    all_categories = Category.objects.all()
            
    return{'all_categories':all_categories}

It is worth noting that despite the similarities to the classic view in this case, the return call only returns us a dictionary containing all_categories

At this stage, our custom context_processors is theoretically ready, but in order to use it, you also need to add it to TEMPLATES inside the settings.py file

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [ BASE_DIR / 'templates'],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',


                # our new custom context processor:
                'APPS.Books.context_processors.categories_context',
            ],
        },
    },
]

Now that we have everything prepared we can display all_categories in any part of our application using the code {% category_list %} . In my case it will be a header.html file using Bootstrap.

Using the Context Processor in an HTML template

From this we can use our dynamic variable in any template. In our case, we would like to add a list of categories to the navigation bar (navigation bar) using the Bootstrap framework.

In the header.html file, we can add the following code:

<header class="section-header">
    <nav class="navbar navbar-expand-lg navbar-light bg-light">
        <a class="navbar-brand" href="#">Navbar</a>

        <div class="collapse navbar-collapse" id="navbarNav">
            <ul class="navbar-nav">
                <li class="nav-item active">
                    <a class="nav-link" href="#">Home</a>
                </li>

                <li class="nav-item dropdown">
                    <a class="nav-link dropdown-toggle" href="#" id="navbarDropdown" role="button"
                        data-toggle="dropdown" aria-haspopup="true" aria-expanded="false">
                        Categories
                    </a>

                    <div class="dropdown-menu" aria-labelledby="navbarDropdown">

                        # using our new context proccesor

                        {% for category in category_list %}
                            <a class="dropdown-item" href="{{category.get_absolute_url}}"> 
                                {{category.category_name}}
                            </a>
                        {% endfor %}

                    </div>
                </li>

            </ul>
        </div>
    </nav>
</header> <!-- section-header.// -->

In the HTML code snippet above, we use our Context Processor to iterate through all the book categories (all_categories) and display them in a drop-down list in the navigation bar. This way, the list of categories will be available on every subpage of our project.

Our new Context Processor can also be used in any other template in the same way as we presented above.

Summary

In this article, we discussed what the Context Processor is in Django and how to use it in practice. Let's take another look at the key elements we discussed:

1. Introduction to Context Processors in Django - we introduced the concept of Context Processors as tools that allow you to access variables in different templates across your project.

2. Example of a view with limited access to data - we have shown how the classical approach to views limits access to data only to a specific template.

3. When to use Context Processor? - We explained that it is useful to use Context Processor when you want to access selected data within the whole application or in several views.

4. Context Processor Implementation - we have shown step-by-step how to implement your own Context Processor, from creating the file context_processors.py, through creating the function and adding it to the TEMPLATES settings.

5. Using the Context Processor in an HTML template with Bootstrap - we showed how to use our Context Processor in practice, adding a list of categories to the navigation bar in an HTML template with Bootstrap.

Now that you know the advantages of using Context Processors in Django, you can successfully apply these techniques to your projects to make sure your applications are more flexible, readable and maintainable.