Refs #33476 -- Reformatted code with Black.

2 files changed, 585 insertions, 472 deletions

diff --git a/tests/admin_filters/models.py b/tests/admin_filters/models.py
index 90b9cab2ac..53b471dd90 100644
--- a/tests/admin_filters/models.py
+++ b/tests/admin_filters/models.py
@@ -1,7 +1,5 @@
 from django.contrib.auth.models import User
-from django.contrib.contenttypes.fields import (
-    GenericForeignKey, GenericRelation,
-)
+from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
 from django.contrib.contenttypes.models import ContentType
 from django.db import models
 
@@ -13,30 +11,35 @@ class Book(models.Model):
         User,
         models.SET_NULL,
         verbose_name="Verbose Author",
-        related_name='books_authored',
-        blank=True, null=True,
+        related_name="books_authored",
+        blank=True,
+        null=True,
     )
     contributors = models.ManyToManyField(
         User,
         verbose_name="Verbose Contributors",
-        related_name='books_contributed',
+        related_name="books_contributed",
         blank=True,
     )
     employee = models.ForeignKey(
-        'Employee',
+        "Employee",
         models.SET_NULL,
-        verbose_name='Employee',
-        blank=True, null=True,
+        verbose_name="Employee",
+        blank=True,
+        null=True,
     )
     is_best_seller = models.BooleanField(default=0, null=True)
     date_registered = models.DateField(null=True)
-    availability = models.BooleanField(choices=(
-        (False, 'Paid'),
-        (True, 'Free'),
-        (None, 'Obscure'),
-    ), null=True)
+    availability = models.BooleanField(
+        choices=(
+            (False, "Paid"),
+            (True, "Free"),
+            (None, "Obscure"),
+        ),
+        null=True,
+    )
     # This field name is intentionally 2 characters long (#16080).
-    no = models.IntegerField(verbose_name='number', blank=True, null=True)
+    no = models.IntegerField(verbose_name="number", blank=True, null=True)
 
     def __str__(self):
         return self.title
@@ -64,9 +67,11 @@ class Employee(models.Model):
 
 class TaggedItem(models.Model):
     tag = models.SlugField()
-    content_type = models.ForeignKey(ContentType, models.CASCADE, related_name='tagged_items')
+    content_type = models.ForeignKey(
+        ContentType, models.CASCADE, related_name="tagged_items"
+    )
     object_id = models.PositiveIntegerField()
-    content_object = GenericForeignKey('content_type', 'object_id')
+    content_object = GenericForeignKey("content_type", "object_id")
 
     def __str__(self):
         return self.tag
@@ -77,11 +82,13 @@ class Bookmark(models.Model):
     tags = GenericRelation(TaggedItem)
 
     CHOICES = [
-        ('a', 'A'),
-        (None, 'None'),
-        ('', '-'),
+        ("a", "A"),
+        (None, "None"),
+        ("", "-"),
     ]
-    none_or_null = models.CharField(max_length=20, choices=CHOICES, blank=True, null=True)
+    none_or_null = models.CharField(
+        max_length=20, choices=CHOICES, blank=True, null=True
+    )
 
     def __str__(self):
         return self.url
diff --git a/tests/admin_filters/tests.py b/tests/admin_filters/tests.py
index 4f1ff26048..14cfb757b5 100644
--- a/tests/admin_filters/tests.py
+++ b/tests/admin_filters/tests.py
@@ -3,8 +3,13 @@ import sys
 import unittest
 
 from django.contrib.admin import (
-    AllValuesFieldListFilter, BooleanFieldListFilter, EmptyFieldListFilter,
-    FieldListFilter, ModelAdmin, RelatedOnlyFieldListFilter, SimpleListFilter,
+    AllValuesFieldListFilter,
+    BooleanFieldListFilter,
+    EmptyFieldListFilter,
+    FieldListFilter,
+    ModelAdmin,
+    RelatedOnlyFieldListFilter,
+    SimpleListFilter,
     site,
 )
 from django.contrib.admin.options import IncorrectLookupParameters
@@ -13,9 +18,7 @@ from django.contrib.auth.models import User
 from django.core.exceptions import ImproperlyConfigured
 from django.test import RequestFactory, TestCase, override_settings
 
-from .models import (
-    Book, Bookmark, Department, Employee, ImprovedBook, TaggedItem,
-)
+from .models import Book, Bookmark, Department, Employee, ImprovedBook, TaggedItem
 
 
 def select_by(dictlist, key, value):
@@ -23,22 +26,21 @@ def select_by(dictlist, key, value):
 
 
 class DecadeListFilter(SimpleListFilter):
-
     def lookups(self, request, model_admin):
         return (
-            ('the 80s', "the 1980's"),
-            ('the 90s', "the 1990's"),
-            ('the 00s', "the 2000's"),
-            ('other', "other decades"),
+            ("the 80s", "the 1980's"),
+            ("the 90s", "the 1990's"),
+            ("the 00s", "the 2000's"),
+            ("other", "other decades"),
         )
 
     def queryset(self, request, queryset):
         decade = self.value()
-        if decade == 'the 80s':
+        if decade == "the 80s":
             return queryset.filter(year__gte=1980, year__lte=1989)
-        if decade == 'the 90s':
+        if decade == "the 90s":
             return queryset.filter(year__gte=1990, year__lte=1999)
-        if decade == 'the 00s':
+        if decade == "the 00s":
             return queryset.filter(year__gte=2000, year__lte=2009)
 
 
@@ -47,100 +49,103 @@ class NotNinetiesListFilter(SimpleListFilter):
     parameter_name = "book_year"
 
     def lookups(self, request, model_admin):
-        return (
-            ('the 90s', "the 1990's"),
-        )
+        return (("the 90s", "the 1990's"),)
 
     def queryset(self, request, queryset):
-        if self.value() == 'the 90s':
+        if self.value() == "the 90s":
             return queryset.filter(year__gte=1990, year__lte=1999)
         else:
             return queryset.exclude(year__gte=1990, year__lte=1999)
 
 
 class DecadeListFilterWithTitleAndParameter(DecadeListFilter):
-    title = 'publication decade'
-    parameter_name = 'publication-decade'
+    title = "publication decade"
+    parameter_name = "publication-decade"
 
 
 class DecadeListFilterWithoutTitle(DecadeListFilter):
-    parameter_name = 'publication-decade'
+    parameter_name = "publication-decade"
 
 
 class DecadeListFilterWithoutParameter(DecadeListFilter):
-    title = 'publication decade'
+    title = "publication decade"
 
 
 class DecadeListFilterWithNoneReturningLookups(DecadeListFilterWithTitleAndParameter):
-
     def lookups(self, request, model_admin):
         pass
 
 
 class DecadeListFilterWithFailingQueryset(DecadeListFilterWithTitleAndParameter):
-
     def queryset(self, request, queryset):
         raise 1 / 0
 
 
 class DecadeListFilterWithQuerysetBasedLookups(DecadeListFilterWithTitleAndParameter):
-
     def lookups(self, request, model_admin):
         qs = model_admin.get_queryset(request)
         if qs.filter(year__gte=1980, year__lte=1989).exists():
-            yield ('the 80s', "the 1980's")
+            yield ("the 80s", "the 1980's")
         if qs.filter(year__gte=1990, year__lte=1999).exists():
-            yield ('the 90s', "the 1990's")
+            yield ("the 90s", "the 1990's")
         if qs.filter(year__gte=2000, year__lte=2009).exists():
-            yield ('the 00s', "the 2000's")
+            yield ("the 00s", "the 2000's")
 
 
 class DecadeListFilterParameterEndsWith__In(DecadeListFilter):
-    title = 'publication decade'
-    parameter_name = 'decade__in'  # Ends with '__in"
+    title = "publication decade"
+    parameter_name = "decade__in"  # Ends with '__in"
 
 
 class DecadeListFilterParameterEndsWith__Isnull(DecadeListFilter):
-    title = 'publication decade'
-    parameter_name = 'decade__isnull'  # Ends with '__isnull"
+    title = "publication decade"
+    parameter_name = "decade__isnull"  # Ends with '__isnull"
 
 
 class DepartmentListFilterLookupWithNonStringValue(SimpleListFilter):
-    title = 'department'
-    parameter_name = 'department'
+    title = "department"
+    parameter_name = "department"
 
     def lookups(self, request, model_admin):
-        return sorted({
-            (employee.department.id,  # Intentionally not a string (Refs #19318)
-             employee.department.code)
-            for employee in model_admin.get_queryset(request).all()
-        })
+        return sorted(
+            {
+                (
+                    employee.department.id,  # Intentionally not a string (Refs #19318)
+                    employee.department.code,
+                )
+                for employee in model_admin.get_queryset(request).all()
+            }
+        )
 
     def queryset(self, request, queryset):
         if self.value():
             return queryset.filter(department__id=self.value())
 
 
-class DepartmentListFilterLookupWithUnderscoredParameter(DepartmentListFilterLookupWithNonStringValue):
-    parameter_name = 'department__whatever'
+class DepartmentListFilterLookupWithUnderscoredParameter(
+    DepartmentListFilterLookupWithNonStringValue
+):
+    parameter_name = "department__whatever"
 
 
 class DepartmentListFilterLookupWithDynamicValue(DecadeListFilterWithTitleAndParameter):
-
     def lookups(self, request, model_admin):
-        if self.value() == 'the 80s':
-            return (('the 90s', "the 1990's"),)
-        elif self.value() == 'the 90s':
-            return (('the 80s', "the 1980's"),)
+        if self.value() == "the 80s":
+            return (("the 90s", "the 1990's"),)
+        elif self.value() == "the 90s":
+            return (("the 80s", "the 1980's"),)
         else:
-            return (('the 80s', "the 1980's"), ('the 90s', "the 1990's"),)
+            return (
+                ("the 80s", "the 1980's"),
+                ("the 90s", "the 1990's"),
+            )
 
 
 class EmployeeNameCustomDividerFilter(FieldListFilter):
-    list_separator = '|'
+    list_separator = "|"
 
     def __init__(self, field, request, params, model, model_admin, field_path):
-        self.lookup_kwarg = '%s__in' % field_path
+        self.lookup_kwarg = "%s__in" % field_path
         super().__init__(field, request, params, model, model_admin, field_path)
 
     def expected_parameters(self):
@@ -148,44 +153,51 @@ class EmployeeNameCustomDividerFilter(FieldListFilter):
 
 
 class CustomUserAdmin(UserAdmin):
-    list_filter = ('books_authored', 'books_contributed')
+    list_filter = ("books_authored", "books_contributed")
 
 
 class BookAdmin(ModelAdmin):
-    list_filter = ('year', 'author', 'contributors', 'is_best_seller', 'date_registered', 'no', 'availability')
-    ordering = ('-id',)
+    list_filter = (
+        "year",
+        "author",
+        "contributors",
+        "is_best_seller",
+        "date_registered",
+        "no",
+        "availability",
+    )
+    ordering = ("-id",)
 
 
 class BookAdminWithTupleBooleanFilter(BookAdmin):
     list_filter = (
-        'year',
-        'author',
-        'contributors',
-        ('is_best_seller', BooleanFieldListFilter),
-        'date_registered',
-        'no',
-        ('availability', BooleanFieldListFilter),
+        "year",
+        "author",
+        "contributors",
+        ("is_best_seller", BooleanFieldListFilter),
+        "date_registered",
+        "no",
+        ("availability", BooleanFieldListFilter),
     )
 
 
 class BookAdminWithUnderscoreLookupAndTuple(BookAdmin):
     list_filter = (
-        'year',
-        ('author__email', AllValuesFieldListFilter),
-        'contributors',
-        'is_best_seller',
-        'date_registered',
-        'no',
+        "year",
+        ("author__email", AllValuesFieldListFilter),
+        "contributors",
+        "is_best_seller",
+        "date_registered",
+        "no",
     )
 
 
 class BookAdminWithCustomQueryset(ModelAdmin):
-
     def __init__(self, user, *args, **kwargs):
         self.user = user
         super().__init__(*args, **kwargs)
 
-    list_filter = ('year',)
+    list_filter = ("year",)
 
     def get_queryset(self, request):
         return super().get_queryset(request).filter(author=self.user)
@@ -193,17 +205,20 @@ class BookAdminWithCustomQueryset(ModelAdmin):
 
 class BookAdminRelatedOnlyFilter(ModelAdmin):
     list_filter = (
-        'year', 'is_best_seller', 'date_registered', 'no',
-        ('author', RelatedOnlyFieldListFilter),
-        ('contributors', RelatedOnlyFieldListFilter),
-        ('employee__department', RelatedOnlyFieldListFilter),
+        "year",
+        "is_best_seller",
+        "date_registered",
+        "no",
+        ("author", RelatedOnlyFieldListFilter),
+        ("contributors", RelatedOnlyFieldListFilter),
+        ("employee__department", RelatedOnlyFieldListFilter),
     )
-    ordering = ('-id',)
+    ordering = ("-id",)
 
 
 class DecadeFilterBookAdmin(ModelAdmin):
-    list_filter = ('author', DecadeListFilterWithTitleAndParameter)
-    ordering = ('-id',)
+    list_filter = ("author", DecadeListFilterWithTitleAndParameter)
+    ordering = ("-id",)
 
 
 class NotNinetiesListFilterAdmin(ModelAdmin):
@@ -239,13 +254,13 @@ class DecadeFilterBookAdminParameterEndsWith__Isnull(ModelAdmin):
 
 
 class EmployeeAdmin(ModelAdmin):
-    list_display = ['name', 'department']
-    list_filter = ['department']
+    list_display = ["name", "department"]
+    list_filter = ["department"]
 
 
 class EmployeeCustomDividerFilterAdmin(EmployeeAdmin):
     list_filter = [
-        ('name', EmployeeNameCustomDividerFilter),
+        ("name", EmployeeNameCustomDividerFilter),
     ]
 
 
@@ -262,21 +277,21 @@ class DepartmentFilterDynamicValueBookAdmin(EmployeeAdmin):
 
 
 class BookmarkAdminGenericRelation(ModelAdmin):
-    list_filter = ['tags__tag']
+    list_filter = ["tags__tag"]
 
 
 class BookAdminWithEmptyFieldListFilter(ModelAdmin):
     list_filter = [
-        ('author', EmptyFieldListFilter),
-        ('title', EmptyFieldListFilter),
-        ('improvedbook', EmptyFieldListFilter),
+        ("author", EmptyFieldListFilter),
+        ("title", EmptyFieldListFilter),
+        ("improvedbook", EmptyFieldListFilter),
     ]
 
 
 class DepartmentAdminWithEmptyFieldListFilter(ModelAdmin):
     list_filter = [
-        ('description', EmptyFieldListFilter),
-        ('employee', EmptyFieldListFilter),
+        ("description", EmptyFieldListFilter),
+        ("employee", EmptyFieldListFilter),
     ]
 
 
@@ -295,68 +310,83 @@ class ListFiltersTests(TestCase):
         cls.next_year = cls.today.replace(year=cls.today.year + 1, month=1, day=1)
 
         # Users
-        cls.alfred = User.objects.create_superuser('alfred', 'alfred@example.com', 'password')
-        cls.bob = User.objects.create_user('bob', 'bob@example.com')
-        cls.lisa = User.objects.create_user('lisa', 'lisa@example.com')
+        cls.alfred = User.objects.create_superuser(
+            "alfred", "alfred@example.com", "password"
+        )
+        cls.bob = User.objects.create_user("bob", "bob@example.com")
+        cls.lisa = User.objects.create_user("lisa", "lisa@example.com")
 
         # Books
         cls.djangonaut_book = Book.objects.create(
-            title='Djangonaut: an art of living', year=2009,
-            author=cls.alfred, is_best_seller=True, date_registered=cls.today,
+            title="Djangonaut: an art of living",
+            year=2009,
+            author=cls.alfred,
+            is_best_seller=True,
+            date_registered=cls.today,
             availability=True,
         )
         cls.bio_book = Book.objects.create(
-            title='Django: a biography', year=1999, author=cls.alfred,
-            is_best_seller=False, no=207,
+            title="Django: a biography",
+            year=1999,
+            author=cls.alfred,
+            is_best_seller=False,
+            no=207,
             availability=False,
         )
         cls.django_book = Book.objects.create(
-            title='The Django Book', year=None, author=cls.bob,
-            is_best_seller=None, date_registered=cls.today, no=103,
+            title="The Django Book",
+            year=None,
+            author=cls.bob,
+            is_best_seller=None,
+            date_registered=cls.today,
+            no=103,
             availability=True,
         )
         cls.guitar_book = Book.objects.create(
-            title='Guitar for dummies', year=2002, is_best_seller=True,
+            title="Guitar for dummies",
+            year=2002,
+            is_best_seller=True,
             date_registered=cls.one_week_ago,
             availability=None,
         )
         cls.guitar_book.contributors.set([cls.bob, cls.lisa])
 
         # Departments
-        cls.dev = Department.objects.create(code='DEV', description='Development')
-        cls.design = Department.objects.create(code='DSN', description='Design')
+        cls.dev = Department.objects.create(code="DEV", description="Development")
+        cls.design = Department.objects.create(code="DSN", description="Design")
 
         # Employees
-        cls.john = Employee.objects.create(name='John Blue', department=cls.dev)
-        cls.jack = Employee.objects.create(name='Jack Red', department=cls.design)
+        cls.john = Employee.objects.create(name="John Blue", department=cls.dev)
+        cls.jack = Employee.objects.create(name="Jack Red", department=cls.design)
 
     def test_choicesfieldlistfilter_has_none_choice(self):
         """
         The last choice is for the None value.
         """
+
         class BookmarkChoicesAdmin(ModelAdmin):
-            list_display = ['none_or_null']
-            list_filter = ['none_or_null']
+            list_display = ["none_or_null"]
+            list_filter = ["none_or_null"]
 
         modeladmin = BookmarkChoicesAdmin(Bookmark, site)
-        request = self.request_factory.get('/', {})
+        request = self.request_factory.get("/", {})
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
         filterspec = changelist.get_filters(request)[0][0]
         choices = list(filterspec.choices(changelist))
-        self.assertEqual(choices[-1]['display'], 'None')
-        self.assertEqual(choices[-1]['query_string'], '?none_or_null__isnull=True')
+        self.assertEqual(choices[-1]["display"], "None")
+        self.assertEqual(choices[-1]["query_string"], "?none_or_null__isnull=True")
 
     def test_datefieldlistfilter(self):
         modeladmin = BookAdmin(Book, site)
 
-        request = self.request_factory.get('/')
+        request = self.request_factory.get("/")
         request.user = self.alfred
         changelist = modeladmin.get_changelist(request)
 
-        request = self.request_factory.get('/', {
-            'date_registered__gte': self.today,
-            'date_registered__lt': self.tomorrow},
+        request = self.request_factory.get(
+            "/",
+            {"date_registered__gte": self.today, "date_registered__lt": self.tomorrow},
         )
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
@@ -367,48 +397,62 @@ class ListFiltersTests(TestCase):
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][4]
-        self.assertEqual(filterspec.title, 'date registered')
+        self.assertEqual(filterspec.title, "date registered")
         choice = select_by(filterspec.choices(changelist), "display", "Today")
-        self.assertIs(choice['selected'], True)
+        self.assertIs(choice["selected"], True)
         self.assertEqual(
-            choice['query_string'],
-            '?date_registered__gte=%s&date_registered__lt=%s' % (
+            choice["query_string"],
+            "?date_registered__gte=%s&date_registered__lt=%s"
+            % (
                 self.today,
                 self.tomorrow,
-            )
+            ),
         )
 
-        request = self.request_factory.get('/', {
-            'date_registered__gte': self.today.replace(day=1),
-            'date_registered__lt': self.next_month},
+        request = self.request_factory.get(
+            "/",
+            {
+                "date_registered__gte": self.today.replace(day=1),
+                "date_registered__lt": self.next_month,
+            },
         )
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
         # Make sure the correct queryset is returned
         queryset = changelist.get_queryset(request)
-        if (self.today.year, self.today.month) == (self.one_week_ago.year, self.one_week_ago.month):
+        if (self.today.year, self.today.month) == (
+            self.one_week_ago.year,
+            self.one_week_ago.month,
+        ):
             # In case one week ago is in the same month.
-            self.assertEqual(list(queryset), [self.guitar_book, self.django_book, self.djangonaut_book])
+            self.assertEqual(
+                list(queryset),
+                [self.guitar_book, self.django_book, self.djangonaut_book],
+            )
         else:
             self.assertEqual(list(queryset), [self.django_book, self.djangonaut_book])
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][4]
-        self.assertEqual(filterspec.title, 'date registered')
+        self.assertEqual(filterspec.title, "date registered")
         choice = select_by(filterspec.choices(changelist), "display", "This month")
-        self.assertIs(choice['selected'], True)
+        self.assertIs(choice["selected"], True)
         self.assertEqual(
-            choice['query_string'],
-            '?date_registered__gte=%s&date_registered__lt=%s' % (
+            choice["query_string"],
+            "?date_registered__gte=%s&date_registered__lt=%s"
+            % (
                 self.today.replace(day=1),
                 self.next_month,
-            )
+            ),
         )
 
-        request = self.request_factory.get('/', {
-            'date_registered__gte': self.today.replace(month=1, day=1),
-            'date_registered__lt': self.next_year},
+        request = self.request_factory.get(
+            "/",
+            {
+                "date_registered__gte": self.today.replace(month=1, day=1),
+                "date_registered__lt": self.next_year,
+            },
         )
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
@@ -417,49 +461,59 @@ class ListFiltersTests(TestCase):
         queryset = changelist.get_queryset(request)
         if self.today.year == self.one_week_ago.year:
             # In case one week ago is in the same year.
-            self.assertEqual(list(queryset), [self.guitar_book, self.django_book, self.djangonaut_book])
+            self.assertEqual(
+                list(queryset),
+                [self.guitar_book, self.django_book, self.djangonaut_book],
+            )
         else:
             self.assertEqual(list(queryset), [self.django_book, self.djangonaut_book])
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][4]
-        self.assertEqual(filterspec.title, 'date registered')
+        self.assertEqual(filterspec.title, "date registered")
         choice = select_by(filterspec.choices(changelist), "display", "This year")
-        self.assertIs(choice['selected'], True)
+        self.assertIs(choice["selected"], True)
         self.assertEqual(
-            choice['query_string'],
-            '?date_registered__gte=%s&date_registered__lt=%s' % (
+            choice["query_string"],
+            "?date_registered__gte=%s&date_registered__lt=%s"
+            % (
                 self.today.replace(month=1, day=1),
                 self.next_year,
-            )
+            ),
         )
 
-        request = self.request_factory.get('/', {
-            'date_registered__gte': str(self.one_week_ago),
-            'date_registered__lt': str(self.tomorrow),
-        })
+        request = self.request_factory.get(
+            "/",
+            {
+                "date_registered__gte": str(self.one_week_ago),
+                "date_registered__lt": str(self.tomorrow),
+            },
+        )
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
         # Make sure the correct queryset is returned
         queryset = changelist.get_queryset(request)
-        self.assertEqual(list(queryset), [self.guitar_book, self.django_book, self.djangonaut_book])
+        self.assertEqual(
+            list(queryset), [self.guitar_book, self.django_book, self.djangonaut_book]
+        )
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][4]
-        self.assertEqual(filterspec.title, 'date registered')
+        self.assertEqual(filterspec.title, "date registered")
         choice = select_by(filterspec.choices(changelist), "display", "Past 7 days")
-        self.assertIs(choice['selected'], True)
+        self.assertIs(choice["selected"], True)
         self.assertEqual(
-            choice['query_string'],
-            '?date_registered__gte=%s&date_registered__lt=%s' % (
+            choice["query_string"],
+            "?date_registered__gte=%s&date_registered__lt=%s"
+            % (
                 str(self.one_week_ago),
                 str(self.tomorrow),
-            )
+            ),
         )
 
         # Null/not null queries
-        request = self.request_factory.get('/', {'date_registered__isnull': 'True'})
+        request = self.request_factory.get("/", {"date_registered__isnull": "True"})
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
@@ -470,31 +524,33 @@ class ListFiltersTests(TestCase):
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][4]
-        self.assertEqual(filterspec.title, 'date registered')
-        choice = select_by(filterspec.choices(changelist), 'display', 'No date')
-        self.assertIs(choice['selected'], True)
-        self.assertEqual(choice['query_string'], '?date_registered__isnull=True')
+        self.assertEqual(filterspec.title, "date registered")
+        choice = select_by(filterspec.choices(changelist), "display", "No date")
+        self.assertIs(choice["selected"], True)
+        self.assertEqual(choice["query_string"], "?date_registered__isnull=True")
 
-        request = self.request_factory.get('/', {'date_registered__isnull': 'False'})
+        request = self.request_factory.get("/", {"date_registered__isnull": "False"})
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
         # Make sure the correct queryset is returned
         queryset = changelist.get_queryset(request)
         self.assertEqual(queryset.count(), 3)
-        self.assertEqual(list(queryset), [self.guitar_book, self.django_book, self.djangonaut_book])
+        self.assertEqual(
+            list(queryset), [self.guitar_book, self.django_book, self.djangonaut_book]
+        )
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][4]
-        self.assertEqual(filterspec.title, 'date registered')
-        choice = select_by(filterspec.choices(changelist), 'display', 'Has date')
-        self.assertIs(choice['selected'], True)
-        self.assertEqual(choice['query_string'], '?date_registered__isnull=False')
+        self.assertEqual(filterspec.title, "date registered")
+        choice = select_by(filterspec.choices(changelist), "display", "Has date")
+        self.assertIs(choice["selected"], True)
+        self.assertEqual(choice["query_string"], "?date_registered__isnull=False")
 
     @unittest.skipIf(
-        sys.platform == 'win32',
+        sys.platform == "win32",
         "Windows doesn't support setting a timezone that differs from the "
-        "system timezone."
+        "system timezone.",
     )
     @override_settings(USE_TZ=True)
     def test_datefieldlistfilter_with_time_zone_support(self):
@@ -504,7 +560,7 @@ class ListFiltersTests(TestCase):
     def test_allvaluesfieldlistfilter(self):
         modeladmin = BookAdmin(Book, site)
 
-        request = self.request_factory.get('/', {'year__isnull': 'True'})
+        request = self.request_factory.get("/", {"year__isnull": "True"})
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
@@ -514,26 +570,26 @@ class ListFiltersTests(TestCase):
 
         # Make sure the last choice is None and is selected
         filterspec = changelist.get_filters(request)[0][0]
-        self.assertEqual(filterspec.title, 'year')
+        self.assertEqual(filterspec.title, "year")
         choices = list(filterspec.choices(changelist))
-        self.assertIs(choices[-1]['selected'], True)
-        self.assertEqual(choices[-1]['query_string'], '?year__isnull=True')
+        self.assertIs(choices[-1]["selected"], True)
+        self.assertEqual(choices[-1]["query_string"], "?year__isnull=True")
 
-        request = self.request_factory.get('/', {'year': '2002'})
+        request = self.request_factory.get("/", {"year": "2002"})
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][0]
-        self.assertEqual(filterspec.title, 'year')
+        self.assertEqual(filterspec.title, "year")
         choices = list(filterspec.choices(changelist))
-        self.assertIs(choices[2]['selected'], True)
-        self.assertEqual(choices[2]['query_string'], '?year=2002')
+        self.assertIs(choices[2]["selected"], True)
+        self.assertEqual(choices[2]["query_string"], "?year=2002")
 
     def test_allvaluesfieldlistfilter_custom_qs(self):
         # Make sure that correct filters are returned with custom querysets
         modeladmin = BookAdminWithCustomQueryset(self.alfred, Book, site)
-        request = self.request_factory.get('/')
+        request = self.request_factory.get("/")
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
@@ -543,23 +599,27 @@ class ListFiltersTests(TestCase):
         # books written by alfred (which is the filtering criteria set by
         # BookAdminWithCustomQueryset.get_queryset())
         self.assertEqual(3, len(choices))
-        self.assertEqual(choices[0]['query_string'], '?')
-        self.assertEqual(choices[1]['query_string'], '?year=1999')
-        self.assertEqual(choices[2]['query_string'], '?year=2009')
+        self.assertEqual(choices[0]["query_string"], "?")
+        self.assertEqual(choices[1]["query_string"], "?year=1999")
+        self.assertEqual(choices[2]["query_string"], "?year=2009")
 
     def test_relatedfieldlistfilter_foreignkey(self):
         modeladmin = BookAdmin(Book, site)
 
-        request = self.request_factory.get('/')
+        request = self.request_factory.get("/")
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
         # Make sure that all users are present in the author's list filter
         filterspec = changelist.get_filters(request)[0][1]
-        expected = [(self.alfred.pk, 'alfred'), (self.bob.pk, 'bob'), (self.lisa.pk, 'lisa')]
+        expected = [
+            (self.alfred.pk, "alfred"),
+            (self.bob.pk, "bob"),
+            (self.lisa.pk, "lisa"),
+        ]
         self.assertEqual(sorted(filterspec.lookup_choices), sorted(expected))
 
-        request = self.request_factory.get('/', {'author__isnull': 'True'})
+        request = self.request_factory.get("/", {"author__isnull": "True"})
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
@@ -569,119 +629,133 @@ class ListFiltersTests(TestCase):
 
         # Make sure the last choice is None and is selected
         filterspec = changelist.get_filters(request)[0][1]
-        self.assertEqual(filterspec.title, 'Verbose Author')
+        self.assertEqual(filterspec.title, "Verbose Author")
         choices = list(filterspec.choices(changelist))
-        self.assertIs(choices[-1]['selected'], True)
-        self.assertEqual(choices[-1]['query_string'], '?author__isnull=True')
+        self.assertIs(choices[-1]["selected"], True)
+        self.assertEqual(choices[-1]["query_string"], "?author__isnull=True")
 
-        request = self.request_factory.get('/', {'author__id__exact': self.alfred.pk})
+        request = self.request_factory.get("/", {"author__id__exact": self.alfred.pk})
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][1]
-        self.assertEqual(filterspec.title, 'Verbose Author')
+        self.assertEqual(filterspec.title, "Verbose Author")
         # order of choices depends on User model, which has no order
         choice = select_by(filterspec.choices(changelist), "display", "alfred")
-        self.assertIs(choice['selected'], True)
-        self.assertEqual(choice['query_string'], '?author__id__exact=%d' % self.alfred.pk)
+        self.assertIs(choice["selected"], True)
+        self.assertEqual(
+            choice["query_string"], "?author__id__exact=%d" % self.alfred.pk
+        )
 
     def test_relatedfieldlistfilter_foreignkey_ordering(self):
         """RelatedFieldListFilter ordering respects ModelAdmin.ordering."""
+
         class EmployeeAdminWithOrdering(ModelAdmin):
-            ordering = ('name',)
+            ordering = ("name",)
 
         class BookAdmin(ModelAdmin):
-            list_filter = ('employee',)
+            list_filter = ("employee",)
 
         site.register(Employee, EmployeeAdminWithOrdering)
         self.addCleanup(lambda: site.unregister(Employee))
         modeladmin = BookAdmin(Book, site)
 
-        request = self.request_factory.get('/')
+        request = self.request_factory.get("/")
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
         filterspec = changelist.get_filters(request)[0][0]
-        expected = [(self.jack.pk, 'Jack Red'), (self.john.pk, 'John Blue')]
+        expected = [(self.jack.pk, "Jack Red"), (self.john.pk, "John Blue")]
         self.assertEqual(filterspec.lookup_choices, expected)
 
     def test_relatedfieldlistfilter_foreignkey_ordering_reverse(self):
         class EmployeeAdminWithOrdering(ModelAdmin):
-            ordering = ('-name',)
+            ordering = ("-name",)
 
         class BookAdmin(ModelAdmin):
-            list_filter = ('employee',)
+            list_filter = ("employee",)
 
         site.register(Employee, EmployeeAdminWithOrdering)
         self.addCleanup(lambda: site.unregister(Employee))
         modeladmin = BookAdmin(Book, site)
 
-        request = self.request_factory.get('/')
+        request = self.request_factory.get("/")
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
         filterspec = changelist.get_filters(request)[0][0]
-        expected = [(self.john.pk, 'John Blue'), (self.jack.pk, 'Jack Red')]
+        expected = [(self.john.pk, "John Blue"), (self.jack.pk, "Jack Red")]
         self.assertEqual(filterspec.lookup_choices, expected)
 
     def test_relatedfieldlistfilter_foreignkey_default_ordering(self):
         """RelatedFieldListFilter ordering respects Model.ordering."""
+
         class BookAdmin(ModelAdmin):
-            list_filter = ('employee',)
+            list_filter = ("employee",)
 
-        self.addCleanup(setattr, Employee._meta, 'ordering', Employee._meta.ordering)
-        Employee._meta.ordering = ('name',)
+        self.addCleanup(setattr, Employee._meta, "ordering", Employee._meta.ordering)
+        Employee._meta.ordering = ("name",)
         modeladmin = BookAdmin(Book, site)
 
-        request = self.request_factory.get('/')
+        request = self.request_factory.get("/")
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
         filterspec = changelist.get_filters(request)[0][0]
-        expected = [(self.jack.pk, 'Jack Red'), (self.john.pk, 'John Blue')]
+        expected = [(self.jack.pk, "Jack Red"), (self.john.pk, "John Blue")]
         self.assertEqual(filterspec.lookup_choices, expected)
 
     def test_relatedfieldlistfilter_manytomany(self):
         modeladmin = BookAdmin(Book, site)
 
-        request = self.request_factory.get('/')
+        request = self.request_factory.get("/")
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
         # Make sure that all users are present in the contrib's list filter
         filterspec = changelist.get_filters(request)[0][2]
-        expected = [(self.alfred.pk, 'alfred'), (self.bob.pk, 'bob'), (self.lisa.pk, 'lisa')]
+        expected = [
+            (self.alfred.pk, "alfred"),
+            (self.bob.pk, "bob"),
+            (self.lisa.pk, "lisa"),
+        ]
         self.assertEqual(sorted(filterspec.lookup_choices), sorted(expected))
 
-        request = self.request_factory.get('/', {'contributors__isnull': 'True'})
+        request = self.request_factory.get("/", {"contributors__isnull": "True"})
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
         # Make sure the correct queryset is returned
         queryset = changelist.get_queryset(request)
-        self.assertEqual(list(queryset), [self.django_book, self.bio_book, self.djangonaut_book])
+        self.assertEqual(
+            list(queryset), [self.django_book, self.bio_book, self.djangonaut_book]
+        )
 
         # Make sure the last choice is None and is selected
         filterspec = changelist.get_filters(request)[0][2]
-        self.assertEqual(filterspec.title, 'Verbose Contributors')
+        self.assertEqual(filterspec.title, "Verbose Contributors")
         choices = list(filterspec.choices(changelist))
-        self.assertIs(choices[-1]['selected'], True)
-        self.assertEqual(choices[-1]['query_string'], '?contributors__isnull=True')
+        self.assertIs(choices[-1]["selected"], True)
+        self.assertEqual(choices[-1]["query_string"], "?contributors__isnull=True")
 
-        request = self.request_factory.get('/', {'contributors__id__exact': self.bob.pk})
+        request = self.request_factory.get(
+            "/", {"contributors__id__exact": self.bob.pk}
+        )
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][2]
-        self.assertEqual(filterspec.title, 'Verbose Contributors')
+        self.assertEqual(filterspec.title, "Verbose Contributors")
         choice = select_by(filterspec.choices(changelist), "display", "bob")
-        self.assertIs(choice['selected'], True)
-        self.assertEqual(choice['query_string'], '?contributors__id__exact=%d' % self.bob.pk)
+        self.assertIs(choice["selected"], True)
+        self.assertEqual(
+            choice["query_string"], "?contributors__id__exact=%d" % self.bob.pk
+        )
 
     def test_relatedfieldlistfilter_reverse_relationships(self):
         modeladmin = CustomUserAdmin(User, site)
 
         # FK relationship -----
-        request = self.request_factory.get('/', {'books_authored__isnull': 'True'})
+        request = self.request_factory.get("/", {"books_authored__isnull": "True"})
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
@@ -691,24 +765,30 @@ class ListFiltersTests(TestCase):
 
         # Make sure the last choice is None and is selected
         filterspec = changelist.get_filters(request)[0][0]
-        self.assertEqual(filterspec.title, 'book')
+        self.assertEqual(filterspec.title, "book")
         choices = list(filterspec.choices(changelist))
-        self.assertIs(choices[-1]['selected'], True)
-        self.assertEqual(choices[-1]['query_string'], '?books_authored__isnull=True')
+        self.assertIs(choices[-1]["selected"], True)
+        self.assertEqual(choices[-1]["query_string"], "?books_authored__isnull=True")
 
-        request = self.request_factory.get('/', {'books_authored__id__exact': self.bio_book.pk})
+        request = self.request_factory.get(
+            "/", {"books_authored__id__exact": self.bio_book.pk}
+        )
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][0]
-        self.assertEqual(filterspec.title, 'book')
-        choice = select_by(filterspec.choices(changelist), "display", self.bio_book.title)
-        self.assertIs(choice['selected'], True)
-        self.assertEqual(choice['query_string'], '?books_authored__id__exact=%d' % self.bio_book.pk)
+        self.assertEqual(filterspec.title, "book")
+        choice = select_by(
+            filterspec.choices(changelist), "display", self.bio_book.title
+        )
+        self.assertIs(choice["selected"], True)
+        self.assertEqual(
+            choice["query_string"], "?books_authored__id__exact=%d" % self.bio_book.pk
+        )
 
         # M2M relationship -----
-        request = self.request_factory.get('/', {'books_contributed__isnull': 'True'})
+        request = self.request_factory.get("/", {"books_contributed__isnull": "True"})
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
@@ -718,21 +798,28 @@ class ListFiltersTests(TestCase):
 
         # Make sure the last choice is None and is selected
         filterspec = changelist.get_filters(request)[0][1]
-        self.assertEqual(filterspec.title, 'book')
+        self.assertEqual(filterspec.title, "book")
         choices = list(filterspec.choices(changelist))
-        self.assertIs(choices[-1]['selected'], True)
-        self.assertEqual(choices[-1]['query_string'], '?books_contributed__isnull=True')
+        self.assertIs(choices[-1]["selected"], True)
+        self.assertEqual(choices[-1]["query_string"], "?books_contributed__isnull=True")
 
-        request = self.request_factory.get('/', {'books_contributed__id__exact': self.django_book.pk})
+        request = self.request_factory.get(
+            "/", {"books_contributed__id__exact": self.django_book.pk}
+        )
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][1]
-        self.assertEqual(filterspec.title, 'book')
-        choice = select_by(filterspec.choices(changelist), "display", self.django_book.title)
-        self.assertIs(choice['selected'], True)
-        self.assertEqual(choice['query_string'], '?books_contributed__id__exact=%d' % self.django_book.pk)
+        self.assertEqual(filterspec.title, "book")
+        choice = select_by(
+            filterspec.choices(changelist), "display", self.django_book.title
+        )
+        self.assertIs(choice["selected"], True)
+        self.assertEqual(
+            choice["query_string"],
+            "?books_contributed__id__exact=%d" % self.django_book.pk,
+        )
 
         # With one book, the list filter should appear because there is also a
         # (None) option.
@@ -745,39 +832,37 @@ class ListFiltersTests(TestCase):
         self.assertEqual(len(filterspec), 0)
 
     def test_relatedfieldlistfilter_reverse_relationships_default_ordering(self):
-        self.addCleanup(setattr, Book._meta, 'ordering', Book._meta.ordering)
-        Book._meta.ordering = ('title',)
+        self.addCleanup(setattr, Book._meta, "ordering", Book._meta.ordering)
+        Book._meta.ordering = ("title",)
         modeladmin = CustomUserAdmin(User, site)
 
-        request = self.request_factory.get('/')
+        request = self.request_factory.get("/")
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
         filterspec = changelist.get_filters(request)[0][0]
         expected = [
-            (self.bio_book.pk, 'Django: a biography'),
-            (self.djangonaut_book.pk, 'Djangonaut: an art of living'),
-            (self.guitar_book.pk, 'Guitar for dummies'),
-            (self.django_book.pk, 'The Django Book')
+            (self.bio_book.pk, "Django: a biography"),
+            (self.djangonaut_book.pk, "Djangonaut: an art of living"),
+            (self.guitar_book.pk, "Guitar for dummies"),
+            (self.django_book.pk, "The Django Book"),
         ]
         self.assertEqual(filterspec.lookup_choices, expected)
 
     def test_relatedonlyfieldlistfilter_foreignkey(self):
         modeladmin = BookAdminRelatedOnlyFilter(Book, site)
 
-        request = self.request_factory.get('/')
+        request = self.request_factory.get("/")
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
         # Make sure that only actual authors are present in author's list filter
         filterspec = changelist.get_filters(request)[0][4]
-        expected = [(self.alfred.pk, 'alfred'), (self.bob.pk, 'bob')]
+        expected = [(self.alfred.pk, "alfred"), (self.bob.pk, "bob")]
         self.assertEqual(sorted(filterspec.lookup_choices), sorted(expected))
 
     def test_relatedonlyfieldlistfilter_foreignkey_reverse_relationships(self):
         class EmployeeAdminReverseRelationship(ModelAdmin):
-            list_filter = (
-                ('book', RelatedOnlyFieldListFilter),
-            )
+            list_filter = (("book", RelatedOnlyFieldListFilter),)
 
         self.djangonaut_book.employee = self.john
         self.djangonaut_book.save()
@@ -785,42 +870,42 @@ class ListFiltersTests(TestCase):
         self.django_book.save()
 
         modeladmin = EmployeeAdminReverseRelationship(Employee, site)
-        request = self.request_factory.get('/')
+        request = self.request_factory.get("/")
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
         filterspec = changelist.get_filters(request)[0][0]
-        self.assertEqual(filterspec.lookup_choices, [
-            (self.djangonaut_book.pk, 'Djangonaut: an art of living'),
-            (self.django_book.pk, 'The Django Book'),
-        ])
+        self.assertEqual(
+            filterspec.lookup_choices,
+            [
+                (self.djangonaut_book.pk, "Djangonaut: an art of living"),
+                (self.django_book.pk, "The Django Book"),
+            ],
+        )
 
     def test_relatedonlyfieldlistfilter_manytomany_reverse_relationships(self):
         class UserAdminReverseRelationship(ModelAdmin):
-            list_filter = (
-                ('books_contributed', RelatedOnlyFieldListFilter),
-            )
+            list_filter = (("books_contributed", RelatedOnlyFieldListFilter),)
 
         modeladmin = UserAdminReverseRelationship(User, site)
-        request = self.request_factory.get('/')
+        request = self.request_factory.get("/")
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
         filterspec = changelist.get_filters(request)[0][0]
         self.assertEqual(
             filterspec.lookup_choices,
-            [(self.guitar_book.pk, 'Guitar for dummies')],
+            [(self.guitar_book.pk, "Guitar for dummies")],
         )
 
     def test_relatedonlyfieldlistfilter_foreignkey_ordering(self):
         """RelatedOnlyFieldListFilter ordering respects ModelAdmin.ordering."""
+
         class EmployeeAdminWithOrdering(ModelAdmin):
-            ordering = ('name',)
+            ordering = ("name",)
 
         class BookAdmin(ModelAdmin):
-            list_filter = (
-                ('employee', RelatedOnlyFieldListFilter),
-            )
+            list_filter = (("employee", RelatedOnlyFieldListFilter),)
 
-        albert = Employee.objects.create(name='Albert Green', department=self.dev)
+        albert = Employee.objects.create(name="Albert Green", department=self.dev)
         self.djangonaut_book.employee = albert
         self.djangonaut_book.save()
         self.bio_book.employee = self.jack
@@ -830,46 +915,45 @@ class ListFiltersTests(TestCase):
         self.addCleanup(lambda: site.unregister(Employee))
         modeladmin = BookAdmin(Book, site)
 
-        request = self.request_factory.get('/')
+        request = self.request_factory.get("/")
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
         filterspec = changelist.get_filters(request)[0][0]
-        expected = [(albert.pk, 'Albert Green'), (self.jack.pk, 'Jack Red')]
+        expected = [(albert.pk, "Albert Green"), (self.jack.pk, "Jack Red")]
         self.assertEqual(filterspec.lookup_choices, expected)
 
     def test_relatedonlyfieldlistfilter_foreignkey_default_ordering(self):
         """RelatedOnlyFieldListFilter ordering respects Meta.ordering."""
+
         class BookAdmin(ModelAdmin):
-            list_filter = (
-                ('employee', RelatedOnlyFieldListFilter),
-            )
+            list_filter = (("employee", RelatedOnlyFieldListFilter),)
 
-        albert = Employee.objects.create(name='Albert Green', department=self.dev)
+        albert = Employee.objects.create(name="Albert Green", department=self.dev)
         self.djangonaut_book.employee = albert
         self.djangonaut_book.save()
         self.bio_book.employee = self.jack
         self.bio_book.save()
 
-        self.addCleanup(setattr, Employee._meta, 'ordering', Employee._meta.ordering)
-        Employee._meta.ordering = ('name',)
+        self.addCleanup(setattr, Employee._meta, "ordering", Employee._meta.ordering)
+        Employee._meta.ordering = ("name",)
         modeladmin = BookAdmin(Book, site)
 
-        request = self.request_factory.get('/')
+        request = self.request_factory.get("/")
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
         filterspec = changelist.get_filters(request)[0][0]
-        expected = [(albert.pk, 'Albert Green'), (self.jack.pk, 'Jack Red')]
+        expected = [(albert.pk, "Albert Green"), (self.jack.pk, "Jack Red")]
         self.assertEqual(filterspec.lookup_choices, expected)
 
     def test_relatedonlyfieldlistfilter_underscorelookup_foreignkey(self):
-        Department.objects.create(code='TEST', description='Testing')
+        Department.objects.create(code="TEST", description="Testing")
         self.djangonaut_book.employee = self.john
         self.djangonaut_book.save()
         self.bio_book.employee = self.jack
         self.bio_book.save()
 
         modeladmin = BookAdminRelatedOnlyFilter(Book, site)
-        request = self.request_factory.get('/')
+        request = self.request_factory.get("/")
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
@@ -885,27 +969,27 @@ class ListFiltersTests(TestCase):
     def test_relatedonlyfieldlistfilter_manytomany(self):
         modeladmin = BookAdminRelatedOnlyFilter(Book, site)
 
-        request = self.request_factory.get('/')
+        request = self.request_factory.get("/")
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
         # Make sure that only actual contributors are present in contrib's list filter
         filterspec = changelist.get_filters(request)[0][5]
-        expected = [(self.bob.pk, 'bob'), (self.lisa.pk, 'lisa')]
+        expected = [(self.bob.pk, "bob"), (self.lisa.pk, "lisa")]
         self.assertEqual(sorted(filterspec.lookup_choices), sorted(expected))
 
     def test_listfilter_genericrelation(self):
-        django_bookmark = Bookmark.objects.create(url='https://www.djangoproject.com/')
-        python_bookmark = Bookmark.objects.create(url='https://www.python.org/')
-        kernel_bookmark = Bookmark.objects.create(url='https://www.kernel.org/')
+        django_bookmark = Bookmark.objects.create(url="https://www.djangoproject.com/")
+        python_bookmark = Bookmark.objects.create(url="https://www.python.org/")
+        kernel_bookmark = Bookmark.objects.create(url="https://www.kernel.org/")
 
-        TaggedItem.objects.create(content_object=django_bookmark, tag='python')
-        TaggedItem.objects.create(content_object=python_bookmark, tag='python')
-        TaggedItem.objects.create(content_object=kernel_bookmark, tag='linux')
+        TaggedItem.objects.create(content_object=django_bookmark, tag="python")
+        TaggedItem.objects.create(content_object=python_bookmark, tag="python")
+        TaggedItem.objects.create(content_object=kernel_bookmark, tag="linux")
 
         modeladmin = BookmarkAdminGenericRelation(Bookmark, site)
 
-        request = self.request_factory.get('/', {'tags__tag': 'python'})
+        request = self.request_factory.get("/", {"tags__tag": "python"})
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
         queryset = changelist.get_queryset(request)
@@ -922,11 +1006,11 @@ class ListFiltersTests(TestCase):
         self.verify_booleanfieldlistfilter(modeladmin)
 
     def verify_booleanfieldlistfilter(self, modeladmin):
-        request = self.request_factory.get('/')
+        request = self.request_factory.get("/")
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
-        request = self.request_factory.get('/', {'is_best_seller__exact': 0})
+        request = self.request_factory.get("/", {"is_best_seller__exact": 0})
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
@@ -936,12 +1020,12 @@ class ListFiltersTests(TestCase):
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][3]
-        self.assertEqual(filterspec.title, 'is best seller')
+        self.assertEqual(filterspec.title, "is best seller")
         choice = select_by(filterspec.choices(changelist), "display", "No")
-        self.assertIs(choice['selected'], True)
-        self.assertEqual(choice['query_string'], '?is_best_seller__exact=0')
+        self.assertIs(choice["selected"], True)
+        self.assertEqual(choice["query_string"], "?is_best_seller__exact=0")
 
-        request = self.request_factory.get('/', {'is_best_seller__exact': 1})
+        request = self.request_factory.get("/", {"is_best_seller__exact": 1})
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
@@ -951,12 +1035,12 @@ class ListFiltersTests(TestCase):
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][3]
-        self.assertEqual(filterspec.title, 'is best seller')
+        self.assertEqual(filterspec.title, "is best seller")
         choice = select_by(filterspec.choices(changelist), "display", "Yes")
-        self.assertIs(choice['selected'], True)
-        self.assertEqual(choice['query_string'], '?is_best_seller__exact=1')
+        self.assertIs(choice["selected"], True)
+        self.assertEqual(choice["query_string"], "?is_best_seller__exact=1")
 
-        request = self.request_factory.get('/', {'is_best_seller__isnull': 'True'})
+        request = self.request_factory.get("/", {"is_best_seller__isnull": "True"})
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
@@ -966,10 +1050,10 @@ class ListFiltersTests(TestCase):
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][3]
-        self.assertEqual(filterspec.title, 'is best seller')
+        self.assertEqual(filterspec.title, "is best seller")
         choice = select_by(filterspec.choices(changelist), "display", "Unknown")
-        self.assertIs(choice['selected'], True)
-        self.assertEqual(choice['query_string'], '?is_best_seller__isnull=True')
+        self.assertIs(choice["selected"], True)
+        self.assertEqual(choice["query_string"], "?is_best_seller__isnull=True")
 
     def test_booleanfieldlistfilter_choices(self):
         modeladmin = BookAdmin(Book, site)
@@ -981,40 +1065,40 @@ class ListFiltersTests(TestCase):
 
     def verify_booleanfieldlistfilter_choices(self, modeladmin):
         # False.
-        request = self.request_factory.get('/', {'availability__exact': 0})
+        request = self.request_factory.get("/", {"availability__exact": 0})
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
         queryset = changelist.get_queryset(request)
         self.assertEqual(list(queryset), [self.bio_book])
         filterspec = changelist.get_filters(request)[0][6]
-        self.assertEqual(filterspec.title, 'availability')
-        choice = select_by(filterspec.choices(changelist), 'display', 'Paid')
-        self.assertIs(choice['selected'], True)
-        self.assertEqual(choice['query_string'], '?availability__exact=0')
+        self.assertEqual(filterspec.title, "availability")
+        choice = select_by(filterspec.choices(changelist), "display", "Paid")
+        self.assertIs(choice["selected"], True)
+        self.assertEqual(choice["query_string"], "?availability__exact=0")
         # True.
-        request = self.request_factory.get('/', {'availability__exact': 1})
+        request = self.request_factory.get("/", {"availability__exact": 1})
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
         queryset = changelist.get_queryset(request)
         self.assertEqual(list(queryset), [self.django_book, self.djangonaut_book])
         filterspec = changelist.get_filters(request)[0][6]
-        self.assertEqual(filterspec.title, 'availability')
-        choice = select_by(filterspec.choices(changelist), 'display', 'Free')
-        self.assertIs(choice['selected'], True)
-        self.assertEqual(choice['query_string'], '?availability__exact=1')
+        self.assertEqual(filterspec.title, "availability")
+        choice = select_by(filterspec.choices(changelist), "display", "Free")
+        self.assertIs(choice["selected"], True)
+        self.assertEqual(choice["query_string"], "?availability__exact=1")
         # None.
-        request = self.request_factory.get('/', {'availability__isnull': 'True'})
+        request = self.request_factory.get("/", {"availability__isnull": "True"})
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
         queryset = changelist.get_queryset(request)
         self.assertEqual(list(queryset), [self.guitar_book])
         filterspec = changelist.get_filters(request)[0][6]
-        self.assertEqual(filterspec.title, 'availability')
-        choice = select_by(filterspec.choices(changelist), 'display', 'Obscure')
-        self.assertIs(choice['selected'], True)
-        self.assertEqual(choice['query_string'], '?availability__isnull=True')
+        self.assertEqual(filterspec.title, "availability")
+        choice = select_by(filterspec.choices(changelist), "display", "Obscure")
+        self.assertIs(choice["selected"], True)
+        self.assertEqual(choice["query_string"], "?availability__isnull=True")
         # All.
-        request = self.request_factory.get('/')
+        request = self.request_factory.get("/")
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
         queryset = changelist.get_queryset(request)
@@ -1023,10 +1107,10 @@ class ListFiltersTests(TestCase):
             [self.guitar_book, self.django_book, self.bio_book, self.djangonaut_book],
         )
         filterspec = changelist.get_filters(request)[0][6]
-        self.assertEqual(filterspec.title, 'availability')
-        choice = select_by(filterspec.choices(changelist), 'display', 'All')
-        self.assertIs(choice['selected'], True)
-        self.assertEqual(choice['query_string'], '?')
+        self.assertEqual(filterspec.title, "availability")
+        choice = select_by(filterspec.choices(changelist), "display", "All")
+        self.assertIs(choice["selected"], True)
+        self.assertEqual(choice["query_string"], "?")
 
     def test_fieldlistfilter_underscorelookup_tuple(self):
         """
@@ -1034,11 +1118,11 @@ class ListFiltersTests(TestCase):
         when fieldpath contains double underscore in value (#19182).
         """
         modeladmin = BookAdminWithUnderscoreLookupAndTuple(Book, site)
-        request = self.request_factory.get('/')
+        request = self.request_factory.get("/")
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
-        request = self.request_factory.get('/', {'author__email': 'alfred@example.com'})
+        request = self.request_factory.get("/", {"author__email": "alfred@example.com"})
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
@@ -1049,7 +1133,9 @@ class ListFiltersTests(TestCase):
     def test_fieldlistfilter_invalid_lookup_parameters(self):
         """Filtering by an invalid value."""
         modeladmin = BookAdmin(Book, site)
-        request = self.request_factory.get('/', {'author__id__exact': 'StringNotInteger!'})
+        request = self.request_factory.get(
+            "/", {"author__id__exact": "StringNotInteger!"}
+        )
         request.user = self.alfred
         with self.assertRaises(IncorrectLookupParameters):
             modeladmin.get_changelist_instance(request)
@@ -1058,24 +1144,24 @@ class ListFiltersTests(TestCase):
         modeladmin = DecadeFilterBookAdmin(Book, site)
 
         # Make sure that the first option is 'All' ---------------------------
-        request = self.request_factory.get('/', {})
+        request = self.request_factory.get("/", {})
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
         # Make sure the correct queryset is returned
         queryset = changelist.get_queryset(request)
-        self.assertEqual(list(queryset), list(Book.objects.all().order_by('-id')))
+        self.assertEqual(list(queryset), list(Book.objects.all().order_by("-id")))
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][1]
-        self.assertEqual(filterspec.title, 'publication decade')
+        self.assertEqual(filterspec.title, "publication decade")
         choices = list(filterspec.choices(changelist))
-        self.assertEqual(choices[0]['display'], 'All')
-        self.assertIs(choices[0]['selected'], True)
-        self.assertEqual(choices[0]['query_string'], '?')
+        self.assertEqual(choices[0]["display"], "All")
+        self.assertIs(choices[0]["selected"], True)
+        self.assertEqual(choices[0]["query_string"], "?")
 
         # Look for books in the 1980s ----------------------------------------
-        request = self.request_factory.get('/', {'publication-decade': 'the 80s'})
+        request = self.request_factory.get("/", {"publication-decade": "the 80s"})
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
@@ -1085,14 +1171,14 @@ class ListFiltersTests(TestCase):
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][1]
-        self.assertEqual(filterspec.title, 'publication decade')
+        self.assertEqual(filterspec.title, "publication decade")
         choices = list(filterspec.choices(changelist))
-        self.assertEqual(choices[1]['display'], 'the 1980\'s')
-        self.assertIs(choices[1]['selected'], True)
-        self.assertEqual(choices[1]['query_string'], '?publication-decade=the+80s')
+        self.assertEqual(choices[1]["display"], "the 1980's")
+        self.assertIs(choices[1]["selected"], True)
+        self.assertEqual(choices[1]["query_string"], "?publication-decade=the+80s")
 
         # Look for books in the 1990s ----------------------------------------
-        request = self.request_factory.get('/', {'publication-decade': 'the 90s'})
+        request = self.request_factory.get("/", {"publication-decade": "the 90s"})
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
@@ -1102,14 +1188,14 @@ class ListFiltersTests(TestCase):
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][1]
-        self.assertEqual(filterspec.title, 'publication decade')
+        self.assertEqual(filterspec.title, "publication decade")
         choices = list(filterspec.choices(changelist))
-        self.assertEqual(choices[2]['display'], 'the 1990\'s')
-        self.assertIs(choices[2]['selected'], True)
-        self.assertEqual(choices[2]['query_string'], '?publication-decade=the+90s')
+        self.assertEqual(choices[2]["display"], "the 1990's")
+        self.assertIs(choices[2]["selected"], True)
+        self.assertEqual(choices[2]["query_string"], "?publication-decade=the+90s")
 
         # Look for books in the 2000s ----------------------------------------
-        request = self.request_factory.get('/', {'publication-decade': 'the 00s'})
+        request = self.request_factory.get("/", {"publication-decade": "the 00s"})
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
@@ -1119,14 +1205,16 @@ class ListFiltersTests(TestCase):
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][1]
-        self.assertEqual(filterspec.title, 'publication decade')
+        self.assertEqual(filterspec.title, "publication decade")
         choices = list(filterspec.choices(changelist))
-        self.assertEqual(choices[3]['display'], 'the 2000\'s')
-        self.assertIs(choices[3]['selected'], True)
-        self.assertEqual(choices[3]['query_string'], '?publication-decade=the+00s')
+        self.assertEqual(choices[3]["display"], "the 2000's")
+        self.assertIs(choices[3]["selected"], True)
+        self.assertEqual(choices[3]["query_string"], "?publication-decade=the+00s")
 
         # Combine multiple filters -------------------------------------------
-        request = self.request_factory.get('/', {'publication-decade': 'the 00s', 'author__id__exact': self.alfred.pk})
+        request = self.request_factory.get(
+            "/", {"publication-decade": "the 00s", "author__id__exact": self.alfred.pk}
+        )
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
@@ -1136,29 +1224,34 @@ class ListFiltersTests(TestCase):
 
         # Make sure the correct choices are selected
         filterspec = changelist.get_filters(request)[0][1]
-        self.assertEqual(filterspec.title, 'publication decade')
+        self.assertEqual(filterspec.title, "publication decade")
         choices = list(filterspec.choices(changelist))
-        self.assertEqual(choices[3]['display'], 'the 2000\'s')
-        self.assertIs(choices[3]['selected'], True)
+        self.assertEqual(choices[3]["display"], "the 2000's")
+        self.assertIs(choices[3]["selected"], True)
         self.assertEqual(
-            choices[3]['query_string'],
-            '?author__id__exact=%s&publication-decade=the+00s' % self.alfred.pk
+            choices[3]["query_string"],
+            "?author__id__exact=%s&publication-decade=the+00s" % self.alfred.pk,
         )
 
         filterspec = changelist.get_filters(request)[0][0]
-        self.assertEqual(filterspec.title, 'Verbose Author')
+        self.assertEqual(filterspec.title, "Verbose Author")
         choice = select_by(filterspec.choices(changelist), "display", "alfred")
-        self.assertIs(choice['selected'], True)
-        self.assertEqual(choice['query_string'], '?author__id__exact=%s&publication-decade=the+00s' % self.alfred.pk)
+        self.assertIs(choice["selected"], True)
+        self.assertEqual(
+            choice["query_string"],
+            "?author__id__exact=%s&publication-decade=the+00s" % self.alfred.pk,
+        )
 
     def test_listfilter_without_title(self):
         """
         Any filter must define a title.
         """
         modeladmin = DecadeFilterBookAdminWithoutTitle(Book, site)
-        request = self.request_factory.get('/', {})
+        request = self.request_factory.get("/", {})
         request.user = self.alfred
-        msg = "The list filter 'DecadeListFilterWithoutTitle' does not specify a 'title'."
+        msg = (
+            "The list filter 'DecadeListFilterWithoutTitle' does not specify a 'title'."
+        )
         with self.assertRaisesMessage(ImproperlyConfigured, msg):
             modeladmin.get_changelist_instance(request)
 
@@ -1167,7 +1260,7 @@ class ListFiltersTests(TestCase):
         Any SimpleListFilter must define a parameter_name.
         """
         modeladmin = DecadeFilterBookAdminWithoutParameter(Book, site)
-        request = self.request_factory.get('/', {})
+        request = self.request_factory.get("/", {})
         request.user = self.alfred
         msg = "The list filter 'DecadeListFilterWithoutParameter' does not specify a 'parameter_name'."
         with self.assertRaisesMessage(ImproperlyConfigured, msg):
@@ -1179,7 +1272,7 @@ class ListFiltersTests(TestCase):
         filter completely.
         """
         modeladmin = DecadeFilterBookAdminWithNoneReturningLookups(Book, site)
-        request = self.request_factory.get('/', {})
+        request = self.request_factory.get("/", {})
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
         filterspec = changelist.get_filters(request)[0]
@@ -1191,40 +1284,40 @@ class ListFiltersTests(TestCase):
         the corresponding exception doesn't get swallowed (#17828).
         """
         modeladmin = DecadeFilterBookAdminWithFailingQueryset(Book, site)
-        request = self.request_factory.get('/', {})
+        request = self.request_factory.get("/", {})
         request.user = self.alfred
         with self.assertRaises(ZeroDivisionError):
             modeladmin.get_changelist_instance(request)
 
     def test_simplelistfilter_with_queryset_based_lookups(self):
         modeladmin = DecadeFilterBookAdminWithQuerysetBasedLookups(Book, site)
-        request = self.request_factory.get('/', {})
+        request = self.request_factory.get("/", {})
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
         filterspec = changelist.get_filters(request)[0][0]
-        self.assertEqual(filterspec.title, 'publication decade')
+        self.assertEqual(filterspec.title, "publication decade")
         choices = list(filterspec.choices(changelist))
         self.assertEqual(len(choices), 3)
 
-        self.assertEqual(choices[0]['display'], 'All')
-        self.assertIs(choices[0]['selected'], True)
-        self.assertEqual(choices[0]['query_string'], '?')
+        self.assertEqual(choices[0]["display"], "All")
+        self.assertIs(choices[0]["selected"], True)
+        self.assertEqual(choices[0]["query_string"], "?")
 
-        self.assertEqual(choices[1]['display'], 'the 1990\'s')
-        self.assertIs(choices[1]['selected'], False)
-        self.assertEqual(choices[1]['query_string'], '?publication-decade=the+90s')
+        self.assertEqual(choices[1]["display"], "the 1990's")
+        self.assertIs(choices[1]["selected"], False)
+        self.assertEqual(choices[1]["query_string"], "?publication-decade=the+90s")
 
-        self.assertEqual(choices[2]['display'], 'the 2000\'s')
-        self.assertIs(choices[2]['selected'], False)
-        self.assertEqual(choices[2]['query_string'], '?publication-decade=the+00s')
+        self.assertEqual(choices[2]["display"], "the 2000's")
+        self.assertIs(choices[2]["selected"], False)
+        self.assertEqual(choices[2]["query_string"], "?publication-decade=the+00s")
 
     def test_two_characters_long_field(self):
         """
         list_filter works with two-characters long field names (#16080).
         """
         modeladmin = BookAdmin(Book, site)
-        request = self.request_factory.get('/', {'no': '207'})
+        request = self.request_factory.get("/", {"no": "207"})
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
@@ -1233,10 +1326,10 @@ class ListFiltersTests(TestCase):
         self.assertEqual(list(queryset), [self.bio_book])
 
         filterspec = changelist.get_filters(request)[0][5]
-        self.assertEqual(filterspec.title, 'number')
+        self.assertEqual(filterspec.title, "number")
         choices = list(filterspec.choices(changelist))
-        self.assertIs(choices[2]['selected'], True)
-        self.assertEqual(choices[2]['query_string'], '?no=207')
+        self.assertIs(choices[2]["selected"], True)
+        self.assertEqual(choices[2]["query_string"], "?no=207")
 
     def test_parameter_ends_with__in__or__isnull(self):
         """
@@ -1245,7 +1338,7 @@ class ListFiltersTests(TestCase):
         """
         # When it ends with '__in' -----------------------------------------
         modeladmin = DecadeFilterBookAdminParameterEndsWith__In(Book, site)
-        request = self.request_factory.get('/', {'decade__in': 'the 90s'})
+        request = self.request_factory.get("/", {"decade__in": "the 90s"})
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
@@ -1255,15 +1348,15 @@ class ListFiltersTests(TestCase):
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][0]
-        self.assertEqual(filterspec.title, 'publication decade')
+        self.assertEqual(filterspec.title, "publication decade")
         choices = list(filterspec.choices(changelist))
-        self.assertEqual(choices[2]['display'], 'the 1990\'s')
-        self.assertIs(choices[2]['selected'], True)
-        self.assertEqual(choices[2]['query_string'], '?decade__in=the+90s')
+        self.assertEqual(choices[2]["display"], "the 1990's")
+        self.assertIs(choices[2]["selected"], True)
+        self.assertEqual(choices[2]["query_string"], "?decade__in=the+90s")
 
         # When it ends with '__isnull' ---------------------------------------
         modeladmin = DecadeFilterBookAdminParameterEndsWith__Isnull(Book, site)
-        request = self.request_factory.get('/', {'decade__isnull': 'the 90s'})
+        request = self.request_factory.get("/", {"decade__isnull": "the 90s"})
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
@@ -1273,11 +1366,11 @@ class ListFiltersTests(TestCase):
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][0]
-        self.assertEqual(filterspec.title, 'publication decade')
+        self.assertEqual(filterspec.title, "publication decade")
         choices = list(filterspec.choices(changelist))
-        self.assertEqual(choices[2]['display'], 'the 1990\'s')
-        self.assertIs(choices[2]['selected'], True)
-        self.assertEqual(choices[2]['query_string'], '?decade__isnull=the+90s')
+        self.assertEqual(choices[2]["display"], "the 1990's")
+        self.assertIs(choices[2]["selected"], True)
+        self.assertEqual(choices[2]["query_string"], "?decade__isnull=the+90s")
 
     def test_lookup_with_non_string_value(self):
         """
@@ -1285,7 +1378,7 @@ class ListFiltersTests(TestCase):
         for lookups in SimpleListFilters (#19318).
         """
         modeladmin = DepartmentFilterEmployeeAdmin(Employee, site)
-        request = self.request_factory.get('/', {'department': self.john.department.pk})
+        request = self.request_factory.get("/", {"department": self.john.department.pk})
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
@@ -1294,11 +1387,13 @@ class ListFiltersTests(TestCase):
         self.assertEqual(list(queryset), [self.john])
 
         filterspec = changelist.get_filters(request)[0][-1]
-        self.assertEqual(filterspec.title, 'department')
+        self.assertEqual(filterspec.title, "department")
         choices = list(filterspec.choices(changelist))
-        self.assertEqual(choices[1]['display'], 'DEV')
-        self.assertIs(choices[1]['selected'], True)
-        self.assertEqual(choices[1]['query_string'], '?department=%s' % self.john.department.pk)
+        self.assertEqual(choices[1]["display"], "DEV")
+        self.assertIs(choices[1]["selected"], True)
+        self.assertEqual(
+            choices[1]["query_string"], "?department=%s" % self.john.department.pk
+        )
 
     def test_lookup_with_non_string_value_underscored(self):
         """
@@ -1306,7 +1401,9 @@ class ListFiltersTests(TestCase):
         parameter_name attribute contains double-underscore value (#19182).
         """
         modeladmin = DepartmentFilterUnderscoredEmployeeAdmin(Employee, site)
-        request = self.request_factory.get('/', {'department__whatever': self.john.department.pk})
+        request = self.request_factory.get(
+            "/", {"department__whatever": self.john.department.pk}
+        )
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
@@ -1315,11 +1412,14 @@ class ListFiltersTests(TestCase):
         self.assertEqual(list(queryset), [self.john])
 
         filterspec = changelist.get_filters(request)[0][-1]
-        self.assertEqual(filterspec.title, 'department')
+        self.assertEqual(filterspec.title, "department")
         choices = list(filterspec.choices(changelist))
-        self.assertEqual(choices[1]['display'], 'DEV')
-        self.assertIs(choices[1]['selected'], True)
-        self.assertEqual(choices[1]['query_string'], '?department__whatever=%s' % self.john.department.pk)
+        self.assertEqual(choices[1]["display"], "DEV")
+        self.assertIs(choices[1]["selected"], True)
+        self.assertEqual(
+            choices[1]["query_string"],
+            "?department__whatever=%s" % self.john.department.pk,
+        )
 
     def test_fk_with_to_field(self):
         """
@@ -1327,7 +1427,7 @@ class ListFiltersTests(TestCase):
         """
         modeladmin = EmployeeAdmin(Employee, site)
 
-        request = self.request_factory.get('/', {})
+        request = self.request_factory.get("/", {})
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
@@ -1336,24 +1436,24 @@ class ListFiltersTests(TestCase):
         self.assertEqual(list(queryset), [self.jack, self.john])
 
         filterspec = changelist.get_filters(request)[0][-1]
-        self.assertEqual(filterspec.title, 'department')
+        self.assertEqual(filterspec.title, "department")
         choices = list(filterspec.choices(changelist))
 
-        self.assertEqual(choices[0]['display'], 'All')
-        self.assertIs(choices[0]['selected'], True)
-        self.assertEqual(choices[0]['query_string'], '?')
+        self.assertEqual(choices[0]["display"], "All")
+        self.assertIs(choices[0]["selected"], True)
+        self.assertEqual(choices[0]["query_string"], "?")
 
-        self.assertEqual(choices[1]['display'], 'Development')
-        self.assertIs(choices[1]['selected'], False)
-        self.assertEqual(choices[1]['query_string'], '?department__code__exact=DEV')
+        self.assertEqual(choices[1]["display"], "Development")
+        self.assertIs(choices[1]["selected"], False)
+        self.assertEqual(choices[1]["query_string"], "?department__code__exact=DEV")
 
-        self.assertEqual(choices[2]['display'], 'Design')
-        self.assertIs(choices[2]['selected'], False)
-        self.assertEqual(choices[2]['query_string'], '?department__code__exact=DSN')
+        self.assertEqual(choices[2]["display"], "Design")
+        self.assertIs(choices[2]["selected"], False)
+        self.assertEqual(choices[2]["query_string"], "?department__code__exact=DSN")
 
         # Filter by Department=='Development' --------------------------------
 
-        request = self.request_factory.get('/', {'department__code__exact': 'DEV'})
+        request = self.request_factory.get("/", {"department__code__exact": "DEV"})
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
 
@@ -1362,20 +1462,20 @@ class ListFiltersTests(TestCase):
         self.assertEqual(list(queryset), [self.john])
 
         filterspec = changelist.get_filters(request)[0][-1]
-        self.assertEqual(filterspec.title, 'department')
+        self.assertEqual(filterspec.title, "department")
         choices = list(filterspec.choices(changelist))
 
-        self.assertEqual(choices[0]['display'], 'All')
-        self.assertIs(choices[0]['selected'], False)
-        self.assertEqual(choices[0]['query_string'], '?')
+        self.assertEqual(choices[0]["display"], "All")
+        self.assertIs(choices[0]["selected"], False)
+        self.assertEqual(choices[0]["query_string"], "?")
 
-        self.assertEqual(choices[1]['display'], 'Development')
-        self.assertIs(choices[1]['selected'], True)
-        self.assertEqual(choices[1]['query_string'], '?department__code__exact=DEV')
+        self.assertEqual(choices[1]["display"], "Development")
+        self.assertIs(choices[1]["selected"], True)
+        self.assertEqual(choices[1]["query_string"], "?department__code__exact=DEV")
 
-        self.assertEqual(choices[2]['display'], 'Design')
-        self.assertIs(choices[2]['selected'], False)
-        self.assertEqual(choices[2]['query_string'], '?department__code__exact=DSN')
+        self.assertEqual(choices[2]["display"], "Design")
+        self.assertIs(choices[2]["selected"], False)
+        self.assertEqual(choices[2]["query_string"], "?department__code__exact=DSN")
 
     def test_lookup_with_dynamic_value(self):
         """
@@ -1387,18 +1487,23 @@ class ListFiltersTests(TestCase):
             request.user = self.alfred
             changelist = modeladmin.get_changelist_instance(request)
             filterspec = changelist.get_filters(request)[0][0]
-            self.assertEqual(filterspec.title, 'publication decade')
-            choices = tuple(c['display'] for c in filterspec.choices(changelist))
+            self.assertEqual(filterspec.title, "publication decade")
+            choices = tuple(c["display"] for c in filterspec.choices(changelist))
             self.assertEqual(choices, expected_displays)
 
-        _test_choices(self.request_factory.get('/', {}),
-                      ("All", "the 1980's", "the 1990's"))
+        _test_choices(
+            self.request_factory.get("/", {}), ("All", "the 1980's", "the 1990's")
+        )
 
-        _test_choices(self.request_factory.get('/', {'publication-decade': 'the 80s'}),
-                      ("All", "the 1990's"))
+        _test_choices(
+            self.request_factory.get("/", {"publication-decade": "the 80s"}),
+            ("All", "the 1990's"),
+        )
 
-        _test_choices(self.request_factory.get('/', {'publication-decade': 'the 90s'}),
-                      ("All", "the 1980's"))
+        _test_choices(
+            self.request_factory.get("/", {"publication-decade": "the 90s"}),
+            ("All", "the 1980's"),
+        )
 
     def test_list_filter_queryset_filtered_by_default(self):
         """
@@ -1406,16 +1511,16 @@ class ListFiltersTests(TestCase):
         full_result_count.
         """
         modeladmin = NotNinetiesListFilterAdmin(Book, site)
-        request = self.request_factory.get('/', {})
+        request = self.request_factory.get("/", {})
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
         changelist.get_results(request)
         self.assertEqual(changelist.full_result_count, 4)
 
     def test_emptylistfieldfilter(self):
-        empty_description = Department.objects.create(code='EMPT', description='')
-        none_description = Department.objects.create(code='NONE', description=None)
-        empty_title = Book.objects.create(title='', author=self.alfred)
+        empty_description = Department.objects.create(code="EMPT", description="")
+        none_description = Department.objects.create(code="NONE", description=None)
+        empty_title = Book.objects.create(title="", author=self.alfred)
 
         department_admin = DepartmentAdminWithEmptyFieldListFilter(Department, site)
         book_admin = BookAdminWithEmptyFieldListFilter(Book, site)
@@ -1424,27 +1529,32 @@ class ListFiltersTests(TestCase):
             # Allows nulls and empty strings.
             (
                 department_admin,
-                {'description__isempty': '1'},
+                {"description__isempty": "1"},
                 [empty_description, none_description],
             ),
             (
                 department_admin,
-                {'description__isempty': '0'},
+                {"description__isempty": "0"},
                 [self.dev, self.design],
             ),
             # Allows nulls.
-            (book_admin, {'author__isempty': '1'}, [self.guitar_book]),
+            (book_admin, {"author__isempty": "1"}, [self.guitar_book]),
             (
                 book_admin,
-                {'author__isempty': '0'},
+                {"author__isempty": "0"},
                 [self.django_book, self.bio_book, self.djangonaut_book, empty_title],
             ),
             # Allows empty strings.
-            (book_admin, {'title__isempty': '1'}, [empty_title]),
+            (book_admin, {"title__isempty": "1"}, [empty_title]),
             (
                 book_admin,
-                {'title__isempty': '0'},
-                [self.django_book, self.bio_book, self.djangonaut_book, self.guitar_book],
+                {"title__isempty": "0"},
+                [
+                    self.django_book,
+                    self.bio_book,
+                    self.djangonaut_book,
+                    self.guitar_book,
+                ],
             ),
         ]
         for modeladmin, query_string, expected_result in tests:
@@ -1452,7 +1562,7 @@ class ListFiltersTests(TestCase):
                 modeladmin=modeladmin.__class__.__name__,
                 query_string=query_string,
             ):
-                request = self.request_factory.get('/', query_string)
+                request = self.request_factory.get("/", query_string)
                 request.user = self.alfred
                 changelist = modeladmin.get_changelist_instance(request)
                 queryset = changelist.get_queryset(request)
@@ -1460,12 +1570,10 @@ class ListFiltersTests(TestCase):
 
     def test_emptylistfieldfilter_reverse_relationships(self):
         class UserAdminReverseRelationship(UserAdmin):
-            list_filter = (
-                ('books_contributed', EmptyFieldListFilter),
-            )
+            list_filter = (("books_contributed", EmptyFieldListFilter),)
 
         ImprovedBook.objects.create(book=self.guitar_book)
-        no_employees = Department.objects.create(code='NONE', description=None)
+        no_employees = Department.objects.create(code="NONE", description=None)
 
         book_admin = BookAdminWithEmptyFieldListFilter(Book, site)
         department_admin = DepartmentAdminWithEmptyFieldListFilter(Department, site)
@@ -1475,23 +1583,23 @@ class ListFiltersTests(TestCase):
             # Reverse one-to-one relationship.
             (
                 book_admin,
-                {'improvedbook__isempty': '1'},
+                {"improvedbook__isempty": "1"},
                 [self.django_book, self.bio_book, self.djangonaut_book],
             ),
-            (book_admin, {'improvedbook__isempty': '0'}, [self.guitar_book]),
+            (book_admin, {"improvedbook__isempty": "0"}, [self.guitar_book]),
             # Reverse foreign key relationship.
-            (department_admin, {'employee__isempty': '1'}, [no_employees]),
-            (department_admin, {'employee__isempty': '0'}, [self.dev, self.design]),
+            (department_admin, {"employee__isempty": "1"}, [no_employees]),
+            (department_admin, {"employee__isempty": "0"}, [self.dev, self.design]),
             # Reverse many-to-many relationship.
-            (user_admin, {'books_contributed__isempty': '1'}, [self.alfred]),
-            (user_admin, {'books_contributed__isempty': '0'}, [self.bob, self.lisa]),
+            (user_admin, {"books_contributed__isempty": "1"}, [self.alfred]),
+            (user_admin, {"books_contributed__isempty": "0"}, [self.bob, self.lisa]),
         ]
         for modeladmin, query_string, expected_result in tests:
             with self.subTest(
                 modeladmin=modeladmin.__class__.__name__,
                 query_string=query_string,
             ):
-                request = self.request_factory.get('/', query_string)
+                request = self.request_factory.get("/", query_string)
                 request.user = self.alfred
                 changelist = modeladmin.get_changelist_instance(request)
                 queryset = changelist.get_queryset(request)
@@ -1499,25 +1607,23 @@ class ListFiltersTests(TestCase):
 
     def test_emptylistfieldfilter_genericrelation(self):
         class BookmarkGenericRelation(ModelAdmin):
-            list_filter = (
-                ('tags', EmptyFieldListFilter),
-            )
+            list_filter = (("tags", EmptyFieldListFilter),)
 
         modeladmin = BookmarkGenericRelation(Bookmark, site)
 
-        django_bookmark = Bookmark.objects.create(url='https://www.djangoproject.com/')
-        python_bookmark = Bookmark.objects.create(url='https://www.python.org/')
-        none_tags = Bookmark.objects.create(url='https://www.kernel.org/')
-        TaggedItem.objects.create(content_object=django_bookmark, tag='python')
-        TaggedItem.objects.create(content_object=python_bookmark, tag='python')
+        django_bookmark = Bookmark.objects.create(url="https://www.djangoproject.com/")
+        python_bookmark = Bookmark.objects.create(url="https://www.python.org/")
+        none_tags = Bookmark.objects.create(url="https://www.kernel.org/")
+        TaggedItem.objects.create(content_object=django_bookmark, tag="python")
+        TaggedItem.objects.create(content_object=python_bookmark, tag="python")
 
         tests = [
-            ({'tags__isempty': '1'}, [none_tags]),
-            ({'tags__isempty': '0'}, [django_bookmark, python_bookmark]),
+            ({"tags__isempty": "1"}, [none_tags]),
+            ({"tags__isempty": "0"}, [django_bookmark, python_bookmark]),
         ]
         for query_string, expected_result in tests:
             with self.subTest(query_string=query_string):
-                request = self.request_factory.get('/', query_string)
+                request = self.request_factory.get("/", query_string)
                 request.user = self.alfred
                 changelist = modeladmin.get_changelist_instance(request)
                 queryset = changelist.get_queryset(request)
@@ -1525,32 +1631,32 @@ class ListFiltersTests(TestCase):
 
     def test_emptylistfieldfilter_choices(self):
         modeladmin = BookAdminWithEmptyFieldListFilter(Book, site)
-        request = self.request_factory.get('/')
+        request = self.request_factory.get("/")
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
         filterspec = changelist.get_filters(request)[0][0]
-        self.assertEqual(filterspec.title, 'Verbose Author')
+        self.assertEqual(filterspec.title, "Verbose Author")
         choices = list(filterspec.choices(changelist))
         self.assertEqual(len(choices), 3)
 
-        self.assertEqual(choices[0]['display'], 'All')
-        self.assertIs(choices[0]['selected'], True)
-        self.assertEqual(choices[0]['query_string'], '?')
+        self.assertEqual(choices[0]["display"], "All")
+        self.assertIs(choices[0]["selected"], True)
+        self.assertEqual(choices[0]["query_string"], "?")
 
-        self.assertEqual(choices[1]['display'], 'Empty')
-        self.assertIs(choices[1]['selected'], False)
-        self.assertEqual(choices[1]['query_string'], '?author__isempty=1')
+        self.assertEqual(choices[1]["display"], "Empty")
+        self.assertIs(choices[1]["selected"], False)
+        self.assertEqual(choices[1]["query_string"], "?author__isempty=1")
 
-        self.assertEqual(choices[2]['display'], 'Not empty')
-        self.assertIs(choices[2]['selected'], False)
-        self.assertEqual(choices[2]['query_string'], '?author__isempty=0')
+        self.assertEqual(choices[2]["display"], "Not empty")
+        self.assertIs(choices[2]["selected"], False)
+        self.assertEqual(choices[2]["query_string"], "?author__isempty=0")
 
     def test_emptylistfieldfilter_non_empty_field(self):
         class EmployeeAdminWithEmptyFieldListFilter(ModelAdmin):
-            list_filter = [('department', EmptyFieldListFilter)]
+            list_filter = [("department", EmptyFieldListFilter)]
 
         modeladmin = EmployeeAdminWithEmptyFieldListFilter(Employee, site)
-        request = self.request_factory.get('/')
+        request = self.request_factory.get("/")
         request.user = self.alfred
         msg = (
             "The list filter 'EmptyFieldListFilter' cannot be used with field "
@@ -1561,7 +1667,7 @@ class ListFiltersTests(TestCase):
 
     def test_emptylistfieldfilter_invalid_lookup_parameters(self):
         modeladmin = BookAdminWithEmptyFieldListFilter(Book, site)
-        request = self.request_factory.get('/', {'author__isempty': 42})
+        request = self.request_factory.get("/", {"author__isempty": 42})
         request.user = self.alfred
         with self.assertRaises(IncorrectLookupParameters):
             modeladmin.get_changelist_instance(request)
@@ -1570,12 +1676,12 @@ class ListFiltersTests(TestCase):
         """
         Filter __in lookups with a custom divider.
         """
-        jane = Employee.objects.create(name='Jane,Green', department=self.design)
+        jane = Employee.objects.create(name="Jane,Green", department=self.design)
         modeladmin = EmployeeCustomDividerFilterAdmin(Employee, site)
         employees = [jane, self.jack]
 
         request = self.request_factory.get(
-            '/', {'name__in': "|".join(e.name for e in employees)}
+            "/", {"name__in": "|".join(e.name for e in employees)}
         )
         # test for lookup with custom divider
         request.user = self.alfred
@@ -1585,7 +1691,7 @@ class ListFiltersTests(TestCase):
         self.assertEqual(list(queryset), employees)
 
         # test for lookup with comma in the lookup string
-        request = self.request_factory.get('/', {'name': jane.name})
+        request = self.request_factory.get("/", {"name": jane.name})
         request.user = self.alfred
         changelist = modeladmin.get_changelist_instance(request)
         # Make sure the correct queryset is returned