Changing the way Django 5.1 generates admin list labels
I love Django’s admin feature. It’s so easy to quickly build out a complete CRUD admin for all your models, it’s truly one of Django’s strongest points. One thing that was always a bit annoying though was adding related fields to a ModelAdmin
’s list_display
.
For example let’s say your User
model has a one to one relationship with an AccountSettings
model, and in the admin’s list of users you want to show the users’ names as well as the value of AccountSettings.pace_account_id
. Until Django 5.1 you’d have to create a getter function like this:
class UserAdmin(BaseUserAdmin):
list_display = [
"name",
"pace_account_id",
]
@admin.display(ordering="account_settings__pace_account_id")
def pace_account_id(self, obj):
return obj.account_settings.pace_account_id
This works fine: the header in the table is “PACE ACCOUNT ID”, and it’s sortable:
But it’s also quite a lot of annoying boilerplate code to have to write with lots of repetition. Why can list_filter
and search_fields
work with related fields using the double underscore lookup method (account_settings__pace_account_id
), yet list_display
can not?
Good news: this has been fixed in Django 5.1! I was super excited about this feature, since it would allow me to remove a bunch of boilerplate code. Now I can just add account_settings__pace_account_id
to list_display
and it just works, sortable and all. However, I immediately noticed something quite annoying: the header in the table isn’t just “PACE ACCOUNT ID” as I would expect, but rather the full “ACCOUNT SETTINGS PACE ACCOUNT ID”. This is way too long and takes up way too much space:
After some puzzling, I found a solution. Django uses django.forms.utils.pretty_name
to generate the table headers, so we’re going to replace this with our own version.
import inspect
from django.db.models.constants import LOOKUP_SEP
from django.forms import utils
def custom_pretty_name(name):
if LOOKUP_SEP in name and inspect.stack()[1][3] == "label_for_field":
name = name.split(LOOKUP_SEP)[1]
return pretty_name(name)
pretty_name = utils.pretty_name
utils.pretty_name = custom_pretty_name
This code needs to be placed inside of manage.py
. Placing it anywhere else means that Django still uses the original version before it’s replaced with the custom one. Once you add this code to the top of manage.py
, the table headers are now nicely succinct, and by using Python’s inspect
module we only change the behavior when the function is called by Django’s own label_for_field
method.
We also defer to the original method to return the pretty name, rather than copying Django’s code into our custom function. So in the case that Django would modify their pretty_name
implementation, we automatically make use of it as well.
And with that, the table header looks great once again, without all the boilerplate code: