Django App: The Indian Bechdel Test

A Django database for applying the Bechdel Test on Indian films

This app is live at The Indian Bechdel Test

Overview

As a woman and a cinephile I have always been invested in the feminist debate around popular culture, especially Indian films. As a side project for my Graduation studies, I researched how women representation has evolved in Indian cinema.

This research resulted in interesting but overall unsurprising discovery that regional Indian cinema has always been ahead in women representation than mainstream "Bollywood" cinema (examples include Bengali, Tamil and Malayalam cinema).

It took a lot of time for Bollywood to catch up. More surprisingly, a study by Shrayana Bhattacharya revealed that women had an awful lot less talk-time now compared to Bollywood films from the 90s.

This led me to wonder, how many Indian films pass the Bechdel Test? The Bechdel Test is a measure of women's representation in media which asks 3 questions:

1. Are there at least two named women characters?

2. Do these characters talk to each other?

3. Is the conversation centered around a man?

To pass this test, a film should answer True for first two questions and False for the last one. The questions are pretty basic but a large number of films fail this test both in India and around the globe. Although there has been some research on applying the Bechdel Test on Indian (mostly Bollywood) films, there does not exist a centralised database for checking how many films pass this test. Thus began my weekend project!

The Basic Outline

Inspired by the bechdeltest.com I wanted to create a website which lists all films in its database as well as allows users to Add and Comment on a film. For this, I chose Django as my main framework. I have already worked with Django for earlier projects hence, this felt like the right choice. To keep this weekend project as simple as possible, I chose Django templates with basic HTML and CSS for the frontend.

I created a UML Diagram for the skeleton structure of the database.

The UML Diagram consisted of the bechdel_test model which contains various fields including primary key, imdb_link, movie_name, year etc. This model is linked to the language model with a Many-To-One relationship where many bechdel_test object can be linked to one language object. This is essential given the diversity of Indian languages.

For the client-side operations, I created two models add_form and contact_form. The add_form is an extension of bechdel_test where users can submit a request for adding a film in the database. The add_form object will always result False for the field approved until changed by Admin thus, establishing a checkpoint for whether users are entering incorrect or malicious data. Once approved, the submission will be visible on the front-end.

For the contact_form, the movie_id field is linked to bechdel_test models. This way, discussion or comment request submissions can only be submitted for films already approved by the admin.

Creating The Database

Implementing the above logic, I first created the desired models then established the link between each model. I also added a Meta class to declare how the objects will be visible on front-end.

Excerpt from models.py:

class Bechdel_Test(models.Model):
    id = models.AutoField(primary_key=True)
    movie_name = models.CharField(max_length=500, verbose_name="Title")
    imdb_link = models.CharField(max_length=20, verbose_name="7-8 digit IMDb link e.g. 0057277 for Mahanagar")
    language = models.ForeignKey(Language, on_delete=models.RESTRICT)
    year = models.IntegerField(default=2024, verbose_name="The release year")
    date_created = models.DateTimeField(default=timezone.now, verbose_name="Date Updated")
    has_two_named_characters = models.BooleanField(default=False, verbose_name="There are two named woman characters")
    the_characters_talk = models.BooleanField(default=False, verbose_name="The characters talk to each other...")
    not_about_a_man = models.BooleanField(default=False, verbose_name="...not about a man")
    notes = models.TextField()
    approved = models.BooleanField(default=False)

    def pass_or_fail(self):
        if self.has_two_named_characters and self.the_characters_talk and self.not_about_a_man == True:
            return "Pass"
        else:
            return "Fail"

    def __str__(self):
        return self.movie_name + " (" + str(self.year) + ")"
    
    class Meta:
        ordering = ['-id']
        verbose_name = "Bechdel Test"

Building on top of the models, I created List and Detail views for the front-end.

Excerpt from views.py:

class Bechdel_View(generic.ListView):
    paginate_by = 20
    model = Bechdel_Test
    context_object_name = 'tests'
    template_name = 'index.html'
    queryset = Bechdel_Test.objects.filter(approved=True)
    
    
# ...SNIP...

class Movie_View(generic.DetailView):
    model = Bechdel_Test
    template_name = 'movies.html'

    def get_context_data(self, **kwargs):
        context = super(Movie_View, self).get_context_data(**kwargs)
        context['movies'] = Bechdel_Test.objects.filter(pk=self.kwargs['pk'])
        context['discussions'] = Contact_Form.objects.all().filter(movie=self.kwargs['pk']).filter(approved=True)
        return context

Finally, I created the URL logic which will allow for a seamless experience for the user.

Excerpt from urls.py:

urlpatterns = [
    path('404/', handler404),
    path('', Bechdel_View.as_view(), name='index'),
    path('<int:pk>', Movie_View.as_view(), name='movies'),
    """
    other paths here
    """
]

With my backend logic created, I now move on to the frontend and create templates. I also add extra logic for a Search Bar as well as Sort by Language/Decade for the users to easily navigate the database.

movies.html:

{% extends 'base.html' %}
{% block content %}
    {% if movies %}
        {% for movie in movies %}
            <h1 class="name">{{ movie.movie_name }} ({{ movie.year }})</h1>
            <p class="status">Status: {{ movie.pass_or_fail }}</p>
            <a class="imdb" href=https://www.imdb.com/title/tt{{ movie.imdb_link}} target="_blank">IMDb Page</a>
            <p class="notes">Language: {{ movie.language }}</p>
            <p class="notes"><span style="font-weight:700;">Notes:</span> {{ movie.notes }}</p>
        {% endfor %}
    {% else %}
        <h1 class="name">No movie by that name.</h1>
    {% endif %}
        <h3 class="discusshead">Discussions:</h3>
        <section class="discussions">
        {% if discussions %}
            {% for discussion in discussions %}
                <p class="username">{{ discussion.username }}</p>
                <p class="discuss">{{ discussion.discuss }}</p>
            {% endfor %}
        {% else %}
                <p class="discuss-less">No discussions yet.</p>
        </section>
        {% endif %}
{% endblock %}

Security Considerations

Django framework provides robust security against XSS, Clickjacking as well as SQL Injections. More information can be found here. The backend accepts submissions from users other than the Administrator through the Add and Contact Form. To prevent malicious users from sending massive amount of requests, the backend prevents the users from sending more than 5 consecutive POST requests.

The emails and usernames from users for the Discussion Form are part of sensitive data as defined by GDPR (General Data Protection Regulation). Thus, I added an extra layer of security by encrypting all emails and usernames. The backend utilises symmetric encryption the moment a user submits a form with the aforementioned sensitive data. This ensures that the emails and usernames are never stored in cleartext and are always encrypted. More information can be found on the Privacy Policy page of The Indian Bechdel Test.

Future Steps

Some of the future steps include but are not limited to:

• Expanding the database

• Develop statistics based on the available data

• Connect a custom domain