Refs #33476 -- Reformatted code with Black.

5 files changed, 288 insertions, 219 deletions

diff --git a/tests/admin_utils/admin.py b/tests/admin_utils/admin.py
index 33c791769b..967f37faf3 100644
--- a/tests/admin_utils/admin.py
+++ b/tests/admin_utils/admin.py
@@ -9,7 +9,7 @@ class ArticleAdminForm(forms.ModelForm):
 
     class Meta:
         model = Article
-        fields = ['title']
+        fields = ["title"]
 
     @property
     def changed_data(self):
@@ -17,13 +17,13 @@ class ArticleAdminForm(forms.ModelForm):
         if data:
             # Add arbitrary name to changed_data to test
             # change message construction.
-            return data + ['not_a_form_field']
+            return data + ["not_a_form_field"]
         return data
 
 
 class ArticleInline(admin.TabularInline):
     model = Article
-    fields = ['title']
+    fields = ["title"]
     form = ArticleAdminForm
 
 
@@ -31,7 +31,7 @@ class SiteAdmin(admin.ModelAdmin):
     inlines = [ArticleInline]
 
 
-site = admin.AdminSite(name='admin')
+site = admin.AdminSite(name="admin")
 site.register(Article)
 site.register(ArticleProxy)
 site.register(Site, SiteAdmin)
diff --git a/tests/admin_utils/models.py b/tests/admin_utils/models.py
index e57c3926b5..243f314b03 100644
--- a/tests/admin_utils/models.py
+++ b/tests/admin_utils/models.py
@@ -14,12 +14,13 @@ class Article(models.Model):
     """
     A simple Article model for testing
     """
+
     site = models.ForeignKey(Site, models.CASCADE, related_name="admin_articles")
     title = models.CharField(max_length=100)
     hist = models.CharField(
         max_length=100,
-        verbose_name=_('History'),
-        help_text=_('History help text'),
+        verbose_name=_("History"),
+        help_text=_("History help text"),
     )
     created = models.DateTimeField(null=True)
 
@@ -29,7 +30,7 @@ class Article(models.Model):
     def test_from_model(self):
         return "nothing"
 
-    @admin.display(description='not What you Expect')
+    @admin.display(description="not What you Expect")
     def test_from_model_with_override(self):
         return "nothing"
 
@@ -41,7 +42,7 @@ class ArticleProxy(Article):
 
 class Count(models.Model):
     num = models.PositiveSmallIntegerField()
-    parent = models.ForeignKey('self', models.CASCADE, null=True)
+    parent = models.ForeignKey("self", models.CASCADE, null=True)
 
     def __str__(self):
         return str(self.num)
@@ -52,7 +53,7 @@ class Event(models.Model):
 
 
 class Location(models.Model):
-    event = models.OneToOneField(Event, models.CASCADE, verbose_name='awesome event')
+    event = models.OneToOneField(Event, models.CASCADE, verbose_name="awesome event")
 
 
 class Guest(models.Model):
@@ -76,7 +77,7 @@ class VehicleMixin(Vehicle):
         Vehicle,
         models.CASCADE,
         parent_link=True,
-        related_name='vehicle_%(app_label)s_%(class)s',
+        related_name="vehicle_%(app_label)s_%(class)s",
     )
 
     class Meta:
diff --git a/tests/admin_utils/test_logentry.py b/tests/admin_utils/test_logentry.py
index 8d8f4ef9ee..c9f080c334 100644
--- a/tests/admin_utils/test_logentry.py
+++ b/tests/admin_utils/test_logentry.py
@@ -13,12 +13,14 @@ from django.utils.html import escape
 from .models import Article, ArticleProxy, Site
 
 
-@override_settings(ROOT_URLCONF='admin_utils.urls')
+@override_settings(ROOT_URLCONF="admin_utils.urls")
 class LogEntryTests(TestCase):
     @classmethod
     def setUpTestData(cls):
-        cls.user = User.objects.create_superuser(username='super', password='secret', email='super@example.com')
-        cls.site = Site.objects.create(domain='example.org')
+        cls.user = User.objects.create_superuser(
+            username="super", password="secret", email="super@example.com"
+        )
+        cls.site = Site.objects.create(domain="example.org")
         cls.a1 = Article.objects.create(
             site=cls.site,
             title="Title",
@@ -26,8 +28,12 @@ class LogEntryTests(TestCase):
         )
         content_type_pk = ContentType.objects.get_for_model(Article).pk
         LogEntry.objects.log_action(
-            cls.user.pk, content_type_pk, cls.a1.pk, repr(cls.a1), CHANGE,
-            change_message='Changed something'
+            cls.user.pk,
+            content_type_pk,
+            cls.a1.pk,
+            repr(cls.a1),
+            CHANGE,
+            change_message="Changed something",
         )
 
     def setUp(self):
@@ -49,29 +55,40 @@ class LogEntryTests(TestCase):
         to get the message dynamically translated at display time.
         """
         post_data = {
-            'site': self.site.pk, 'title': 'Changed', 'hist': 'Some content',
-            'created_0': '2008-03-12', 'created_1': '11:54',
+            "site": self.site.pk,
+            "title": "Changed",
+            "hist": "Some content",
+            "created_0": "2008-03-12",
+            "created_1": "11:54",
         }
-        change_url = reverse('admin:admin_utils_article_change', args=[quote(self.a1.pk)])
+        change_url = reverse(
+            "admin:admin_utils_article_change", args=[quote(self.a1.pk)]
+        )
         response = self.client.post(change_url, post_data)
-        self.assertRedirects(response, reverse('admin:admin_utils_article_changelist'))
-        logentry = LogEntry.objects.filter(content_type__model__iexact='article').latest('id')
-        self.assertEqual(logentry.get_change_message(), 'Changed Title and History.')
-        with translation.override('fr'):
-            self.assertEqual(logentry.get_change_message(), 'Modification de Title et Historique.')
+        self.assertRedirects(response, reverse("admin:admin_utils_article_changelist"))
+        logentry = LogEntry.objects.filter(
+            content_type__model__iexact="article"
+        ).latest("id")
+        self.assertEqual(logentry.get_change_message(), "Changed Title and History.")
+        with translation.override("fr"):
+            self.assertEqual(
+                logentry.get_change_message(), "Modification de Title et Historique."
+            )
 
-        add_url = reverse('admin:admin_utils_article_add')
-        post_data['title'] = 'New'
+        add_url = reverse("admin:admin_utils_article_add")
+        post_data["title"] = "New"
         response = self.client.post(add_url, post_data)
-        self.assertRedirects(response, reverse('admin:admin_utils_article_changelist'))
-        logentry = LogEntry.objects.filter(content_type__model__iexact='article').latest('id')
-        self.assertEqual(logentry.get_change_message(), 'Added.')
-        with translation.override('fr'):
-            self.assertEqual(logentry.get_change_message(), 'Ajout.')
+        self.assertRedirects(response, reverse("admin:admin_utils_article_changelist"))
+        logentry = LogEntry.objects.filter(
+            content_type__model__iexact="article"
+        ).latest("id")
+        self.assertEqual(logentry.get_change_message(), "Added.")
+        with translation.override("fr"):
+            self.assertEqual(logentry.get_change_message(), "Ajout.")
 
     def test_logentry_change_message_not_json(self):
         """LogEntry.change_message was a string before Django 1.10."""
-        logentry = LogEntry(change_message='non-JSON string')
+        logentry = LogEntry(change_message="non-JSON string")
         self.assertEqual(logentry.get_change_message(), logentry.change_message)
 
     def test_logentry_change_message_localized_datetime_input(self):
@@ -79,15 +96,24 @@ class LogEntryTests(TestCase):
         Localized date/time inputs shouldn't affect changed form data detection.
         """
         post_data = {
-            'site': self.site.pk, 'title': 'Changed', 'hist': 'Some content',
-            'created_0': '12/03/2008', 'created_1': '11:54',
+            "site": self.site.pk,
+            "title": "Changed",
+            "hist": "Some content",
+            "created_0": "12/03/2008",
+            "created_1": "11:54",
         }
-        with translation.override('fr'):
-            change_url = reverse('admin:admin_utils_article_change', args=[quote(self.a1.pk)])
+        with translation.override("fr"):
+            change_url = reverse(
+                "admin:admin_utils_article_change", args=[quote(self.a1.pk)]
+            )
             response = self.client.post(change_url, post_data)
-            self.assertRedirects(response, reverse('admin:admin_utils_article_changelist'))
-        logentry = LogEntry.objects.filter(content_type__model__iexact='article').latest('id')
-        self.assertEqual(logentry.get_change_message(), 'Changed Title and History.')
+            self.assertRedirects(
+                response, reverse("admin:admin_utils_article_changelist")
+            )
+        logentry = LogEntry.objects.filter(
+            content_type__model__iexact="article"
+        ).latest("id")
+        self.assertEqual(logentry.get_change_message(), "Changed Title and History.")
 
     def test_logentry_change_message_formsets(self):
         """
@@ -99,52 +125,62 @@ class LogEntryTests(TestCase):
             created=datetime(2012, 3, 18, 11, 54),
         )
         post_data = {
-            'domain': 'example.com',  # domain changed
-            'admin_articles-TOTAL_FORMS': '5',
-            'admin_articles-INITIAL_FORMS': '2',
-            'admin_articles-MIN_NUM_FORMS': '0',
-            'admin_articles-MAX_NUM_FORMS': '1000',
+            "domain": "example.com",  # domain changed
+            "admin_articles-TOTAL_FORMS": "5",
+            "admin_articles-INITIAL_FORMS": "2",
+            "admin_articles-MIN_NUM_FORMS": "0",
+            "admin_articles-MAX_NUM_FORMS": "1000",
             # Changed title for 1st article
-            'admin_articles-0-id': str(self.a1.pk),
-            'admin_articles-0-site': str(self.site.pk),
-            'admin_articles-0-title': 'Changed Title',
+            "admin_articles-0-id": str(self.a1.pk),
+            "admin_articles-0-site": str(self.site.pk),
+            "admin_articles-0-title": "Changed Title",
             # Second article is deleted
-            'admin_articles-1-id': str(a2.pk),
-            'admin_articles-1-site': str(self.site.pk),
-            'admin_articles-1-title': 'Title second article',
-            'admin_articles-1-DELETE': 'on',
+            "admin_articles-1-id": str(a2.pk),
+            "admin_articles-1-site": str(self.site.pk),
+            "admin_articles-1-title": "Title second article",
+            "admin_articles-1-DELETE": "on",
             # A new article is added
-            'admin_articles-2-site': str(self.site.pk),
-            'admin_articles-2-title': 'Added article',
+            "admin_articles-2-site": str(self.site.pk),
+            "admin_articles-2-title": "Added article",
         }
-        change_url = reverse('admin:admin_utils_site_change', args=[quote(self.site.pk)])
+        change_url = reverse(
+            "admin:admin_utils_site_change", args=[quote(self.site.pk)]
+        )
         response = self.client.post(change_url, post_data)
-        self.assertRedirects(response, reverse('admin:admin_utils_site_changelist'))
+        self.assertRedirects(response, reverse("admin:admin_utils_site_changelist"))
         self.assertQuerysetEqual(Article.objects.filter(pk=a2.pk), [])
-        logentry = LogEntry.objects.filter(content_type__model__iexact='site').latest('action_time')
+        logentry = LogEntry.objects.filter(content_type__model__iexact="site").latest(
+            "action_time"
+        )
         self.assertEqual(
             json.loads(logentry.change_message),
             [
                 {"changed": {"fields": ["Domain"]}},
                 {"added": {"object": "Added article", "name": "article"}},
-                {"changed": {"fields": ["Title", "not_a_form_field"], "object": "Changed Title", "name": "article"}},
+                {
+                    "changed": {
+                        "fields": ["Title", "not_a_form_field"],
+                        "object": "Changed Title",
+                        "name": "article",
+                    }
+                },
                 {"deleted": {"object": "Title second article", "name": "article"}},
-            ]
+            ],
         )
         self.assertEqual(
             logentry.get_change_message(),
-            'Changed Domain. Added article “Added article”. '
-            'Changed Title and not_a_form_field for article “Changed Title”. '
-            'Deleted article “Title second article”.'
+            "Changed Domain. Added article “Added article”. "
+            "Changed Title and not_a_form_field for article “Changed Title”. "
+            "Deleted article “Title second article”.",
         )
 
-        with translation.override('fr'):
+        with translation.override("fr"):
             self.assertEqual(
                 logentry.get_change_message(),
                 "Modification de Domain. Ajout de article « Added article ». "
                 "Modification de Title et not_a_form_field pour l'objet "
                 "article « Changed Title ». "
-                "Suppression de article « Title second article »."
+                "Suppression de article « Title second article ».",
             )
 
     def test_logentry_get_edited_object(self):
@@ -161,10 +197,12 @@ class LogEntryTests(TestCase):
         LogEntry.get_admin_url returns a URL to edit the entry's object or
         None for nonexistent (possibly deleted) models.
         """
-        logentry = LogEntry.objects.get(content_type__model__iexact='article')
-        expected_url = reverse('admin:admin_utils_article_change', args=(quote(self.a1.pk),))
+        logentry = LogEntry.objects.get(content_type__model__iexact="article")
+        expected_url = reverse(
+            "admin:admin_utils_article_change", args=(quote(self.a1.pk),)
+        )
         self.assertEqual(logentry.get_admin_url(), expected_url)
-        self.assertIn('article/%d/change/' % self.a1.pk, logentry.get_admin_url())
+        self.assertIn("article/%d/change/" % self.a1.pk, logentry.get_admin_url())
 
         logentry.content_type.model = "nonexistent"
         self.assertIsNone(logentry.get_admin_url())
@@ -173,17 +211,17 @@ class LogEntryTests(TestCase):
         log_entry = LogEntry()
 
         log_entry.action_flag = ADDITION
-        self.assertTrue(str(log_entry).startswith('Added '))
+        self.assertTrue(str(log_entry).startswith("Added "))
 
         log_entry.action_flag = CHANGE
-        self.assertTrue(str(log_entry).startswith('Changed '))
+        self.assertTrue(str(log_entry).startswith("Changed "))
 
         log_entry.action_flag = DELETION
-        self.assertTrue(str(log_entry).startswith('Deleted '))
+        self.assertTrue(str(log_entry).startswith("Deleted "))
 
         # Make sure custom action_flags works
         log_entry.action_flag = 4
-        self.assertEqual(str(log_entry), 'LogEntry Object')
+        self.assertEqual(str(log_entry), "LogEntry Object")
 
     def test_logentry_repr(self):
         logentry = LogEntry.objects.first()
@@ -192,23 +230,30 @@ class LogEntryTests(TestCase):
     def test_log_action(self):
         content_type_pk = ContentType.objects.get_for_model(Article).pk
         log_entry = LogEntry.objects.log_action(
-            self.user.pk, content_type_pk, self.a1.pk, repr(self.a1), CHANGE,
-            change_message='Changed something else',
+            self.user.pk,
+            content_type_pk,
+            self.a1.pk,
+            repr(self.a1),
+            CHANGE,
+            change_message="Changed something else",
         )
-        self.assertEqual(log_entry, LogEntry.objects.latest('id'))
+        self.assertEqual(log_entry, LogEntry.objects.latest("id"))
 
     def test_recentactions_without_content_type(self):
         """
         If a LogEntry is missing content_type it will not display it in span
         tag under the hyperlink.
         """
-        response = self.client.get(reverse('admin:index'))
-        link = reverse('admin:admin_utils_article_change', args=(quote(self.a1.pk),))
-        should_contain = """<a href="%s">%s</a>""" % (escape(link), escape(repr(self.a1)))
+        response = self.client.get(reverse("admin:index"))
+        link = reverse("admin:admin_utils_article_change", args=(quote(self.a1.pk),))
+        should_contain = """<a href="%s">%s</a>""" % (
+            escape(link),
+            escape(repr(self.a1)),
+        )
         self.assertContains(response, should_contain)
         should_contain = "Article"
         self.assertContains(response, should_contain)
-        logentry = LogEntry.objects.get(content_type__model__iexact='article')
+        logentry = LogEntry.objects.get(content_type__model__iexact="article")
         # If the log entry doesn't have a content type it should still be
         # possible to view the Recent Actions part (#10275).
         logentry.content_type = None
@@ -216,7 +261,7 @@ class LogEntryTests(TestCase):
 
         should_contain = should_contain.encode()
         counted_presence_before = response.content.count(should_contain)
-        response = self.client.get(reverse('admin:index'))
+        response = self.client.get(reverse("admin:index"))
         counted_presence_after = response.content.count(should_contain)
         self.assertEqual(counted_presence_before - 1, counted_presence_after)
 
@@ -225,41 +270,50 @@ class LogEntryTests(TestCase):
         Log entries for proxy models should have the proxy model's contenttype
         (#21084).
         """
-        proxy_content_type = ContentType.objects.get_for_model(ArticleProxy, for_concrete_model=False)
+        proxy_content_type = ContentType.objects.get_for_model(
+            ArticleProxy, for_concrete_model=False
+        )
         post_data = {
-            'site': self.site.pk, 'title': "Foo", 'hist': "Bar",
-            'created_0': '2015-12-25', 'created_1': '00:00',
+            "site": self.site.pk,
+            "title": "Foo",
+            "hist": "Bar",
+            "created_0": "2015-12-25",
+            "created_1": "00:00",
         }
-        changelist_url = reverse('admin:admin_utils_articleproxy_changelist')
+        changelist_url = reverse("admin:admin_utils_articleproxy_changelist")
 
         # add
-        proxy_add_url = reverse('admin:admin_utils_articleproxy_add')
+        proxy_add_url = reverse("admin:admin_utils_articleproxy_add")
         response = self.client.post(proxy_add_url, post_data)
         self.assertRedirects(response, changelist_url)
-        proxy_addition_log = LogEntry.objects.latest('id')
+        proxy_addition_log = LogEntry.objects.latest("id")
         self.assertEqual(proxy_addition_log.action_flag, ADDITION)
         self.assertEqual(proxy_addition_log.content_type, proxy_content_type)
 
         # change
         article_id = proxy_addition_log.object_id
-        proxy_change_url = reverse('admin:admin_utils_articleproxy_change', args=(article_id,))
-        post_data['title'] = 'New'
+        proxy_change_url = reverse(
+            "admin:admin_utils_articleproxy_change", args=(article_id,)
+        )
+        post_data["title"] = "New"
         response = self.client.post(proxy_change_url, post_data)
         self.assertRedirects(response, changelist_url)
-        proxy_change_log = LogEntry.objects.latest('id')
+        proxy_change_log = LogEntry.objects.latest("id")
         self.assertEqual(proxy_change_log.action_flag, CHANGE)
         self.assertEqual(proxy_change_log.content_type, proxy_content_type)
 
         # delete
-        proxy_delete_url = reverse('admin:admin_utils_articleproxy_delete', args=(article_id,))
-        response = self.client.post(proxy_delete_url, {'post': 'yes'})
+        proxy_delete_url = reverse(
+            "admin:admin_utils_articleproxy_delete", args=(article_id,)
+        )
+        response = self.client.post(proxy_delete_url, {"post": "yes"})
         self.assertRedirects(response, changelist_url)
-        proxy_delete_log = LogEntry.objects.latest('id')
+        proxy_delete_log = LogEntry.objects.latest("id")
         self.assertEqual(proxy_delete_log.action_flag, DELETION)
         self.assertEqual(proxy_delete_log.content_type, proxy_content_type)
 
     def test_action_flag_choices(self):
-        tests = ((1, 'Addition'), (2, 'Change'), (3, 'Deletion'))
+        tests = ((1, "Addition"), (2, "Change"), (3, "Deletion"))
         for action_flag, display_name in tests:
             with self.subTest(action_flag=action_flag):
                 log = LogEntry(action_flag=action_flag)
diff --git a/tests/admin_utils/tests.py b/tests/admin_utils/tests.py
index 77db318693..27fe049274 100644
--- a/tests/admin_utils/tests.py
+++ b/tests/admin_utils/tests.py
@@ -6,8 +6,14 @@ from django.conf import settings
 from django.contrib import admin
 from django.contrib.admin import helpers
 from django.contrib.admin.utils import (
-    NestedObjects, display_for_field, display_for_value, flatten,
-    flatten_fieldsets, help_text_for_field, label_for_field, lookup_field,
+    NestedObjects,
+    display_for_field,
+    display_for_value,
+    flatten,
+    flatten_fieldsets,
+    help_text_for_field,
+    label_for_field,
+    lookup_field,
     quote,
 )
 from django.db import DEFAULT_DB_ALIAS, models
@@ -15,15 +21,14 @@ from django.test import SimpleTestCase, TestCase, override_settings
 from django.utils.formats import localize
 from django.utils.safestring import mark_safe
 
-from .models import (
-    Article, Car, Count, Event, EventGuide, Location, Site, Vehicle,
-)
+from .models import Article, Car, Count, Event, EventGuide, Location, Site, Vehicle
 
 
 class NestedObjectsTests(TestCase):
     """
     Tests for ``NestedObject`` utility collection.
     """
+
     @classmethod
     def setUpTestData(cls):
         cls.n = NestedObjects(using=DEFAULT_DB_ALIAS)
@@ -95,18 +100,18 @@ class NestedObjectsTests(TestCase):
 
 class UtilsTests(SimpleTestCase):
 
-    empty_value = '-empty-'
+    empty_value = "-empty-"
 
     def test_values_from_lookup_field(self):
         """
         Regression test for #12654: lookup_field
         """
-        SITE_NAME = 'example.com'
-        TITLE_TEXT = 'Some title'
+        SITE_NAME = "example.com"
+        TITLE_TEXT = "Some title"
         CREATED_DATE = datetime.min
-        ADMIN_METHOD = 'admin method'
-        SIMPLE_FUNCTION = 'function'
-        INSTANCE_ATTRIBUTE = 'attr'
+        ADMIN_METHOD = "admin method"
+        SIMPLE_FUNCTION = "function"
+        INSTANCE_ATTRIBUTE = "attr"
 
         class MockModelAdmin:
             def get_admin_value(self, obj):
@@ -124,13 +129,13 @@ class UtilsTests(SimpleTestCase):
         article.non_field = INSTANCE_ATTRIBUTE
 
         verifications = (
-            ('site', SITE_NAME),
-            ('created', localize(CREATED_DATE)),
-            ('title', TITLE_TEXT),
-            ('get_admin_value', ADMIN_METHOD),
+            ("site", SITE_NAME),
+            ("created", localize(CREATED_DATE)),
+            ("title", TITLE_TEXT),
+            ("get_admin_value", ADMIN_METHOD),
             (simple_function, SIMPLE_FUNCTION),
-            ('test_from_model', article.test_from_model()),
-            ('non_field', INSTANCE_ATTRIBUTE)
+            ("test_from_model", article.test_from_model()),
+            ("non_field", INSTANCE_ATTRIBUTE),
         )
 
         mock_admin = MockModelAdmin()
@@ -138,7 +143,9 @@ class UtilsTests(SimpleTestCase):
             field, attr, resolved_value = lookup_field(name, article, mock_admin)
 
             if field is not None:
-                resolved_value = display_for_field(resolved_value, field, self.empty_value)
+                resolved_value = display_for_field(
+                    resolved_value, field, self.empty_value
+                )
 
             self.assertEqual(value, resolved_value)
 
@@ -150,11 +157,9 @@ class UtilsTests(SimpleTestCase):
         display_value = display_for_field(None, models.CharField(), self.empty_value)
         self.assertEqual(display_value, self.empty_value)
 
-        display_value = display_for_field(None, models.CharField(
-            choices=(
-                (None, "test_none"),
-            )
-        ), self.empty_value)
+        display_value = display_for_field(
+            None, models.CharField(choices=((None, "test_none"),)), self.empty_value
+        )
         self.assertEqual(display_value, "test_none")
 
         display_value = display_for_field(None, models.DateField(), self.empty_value)
@@ -163,8 +168,13 @@ class UtilsTests(SimpleTestCase):
         display_value = display_for_field(None, models.TimeField(), self.empty_value)
         self.assertEqual(display_value, self.empty_value)
 
-        display_value = display_for_field(None, models.BooleanField(null=True), self.empty_value)
-        expected = '<img src="%sadmin/img/icon-unknown.svg" alt="None" />' % settings.STATIC_URL
+        display_value = display_for_field(
+            None, models.BooleanField(null=True), self.empty_value
+        )
+        expected = (
+            '<img src="%sadmin/img/icon-unknown.svg" alt="None" />'
+            % settings.STATIC_URL
+        )
         self.assertHTMLEqual(display_value, expected)
 
         display_value = display_for_field(None, models.DecimalField(), self.empty_value)
@@ -178,11 +188,11 @@ class UtilsTests(SimpleTestCase):
 
     def test_json_display_for_field(self):
         tests = [
-            ({'a': {'b': 'c'}}, '{"a": {"b": "c"}}'),
-            (['a', 'b'], '["a", "b"]'),
-            ('a', '"a"'),
-            ({'a': '你好 世界'}, '{"a": "你好 世界"}'),
-            ({('a', 'b'): 'c'}, "{('a', 'b'): 'c'}"),  # Invalid JSON.
+            ({"a": {"b": "c"}}, '{"a": {"b": "c"}}'),
+            (["a", "b"], '["a", "b"]'),
+            ("a", '"a"'),
+            ({"a": "你好 世界"}, '{"a": "你好 世界"}'),
+            ({("a", "b"): "c"}, "{('a', 'b'): 'c'}"),  # Invalid JSON.
         ]
         for value, display_value in tests:
             with self.subTest(value=value):
@@ -192,113 +202,113 @@ class UtilsTests(SimpleTestCase):
                 )
 
     def test_number_formats_display_for_field(self):
-        display_value = display_for_field(12345.6789, models.FloatField(), self.empty_value)
-        self.assertEqual(display_value, '12345.6789')
+        display_value = display_for_field(
+            12345.6789, models.FloatField(), self.empty_value
+        )
+        self.assertEqual(display_value, "12345.6789")
 
-        display_value = display_for_field(Decimal('12345.6789'), models.DecimalField(), self.empty_value)
-        self.assertEqual(display_value, '12345.6789')
+        display_value = display_for_field(
+            Decimal("12345.6789"), models.DecimalField(), self.empty_value
+        )
+        self.assertEqual(display_value, "12345.6789")
 
-        display_value = display_for_field(12345, models.IntegerField(), self.empty_value)
-        self.assertEqual(display_value, '12345')
+        display_value = display_for_field(
+            12345, models.IntegerField(), self.empty_value
+        )
+        self.assertEqual(display_value, "12345")
 
     @override_settings(USE_THOUSAND_SEPARATOR=True)
     def test_number_formats_with_thousand_separator_display_for_field(self):
-        display_value = display_for_field(12345.6789, models.FloatField(), self.empty_value)
-        self.assertEqual(display_value, '12,345.6789')
+        display_value = display_for_field(
+            12345.6789, models.FloatField(), self.empty_value
+        )
+        self.assertEqual(display_value, "12,345.6789")
 
-        display_value = display_for_field(Decimal('12345.6789'), models.DecimalField(), self.empty_value)
-        self.assertEqual(display_value, '12,345.6789')
+        display_value = display_for_field(
+            Decimal("12345.6789"), models.DecimalField(), self.empty_value
+        )
+        self.assertEqual(display_value, "12,345.6789")
 
-        display_value = display_for_field(12345, models.IntegerField(), self.empty_value)
-        self.assertEqual(display_value, '12,345')
+        display_value = display_for_field(
+            12345, models.IntegerField(), self.empty_value
+        )
+        self.assertEqual(display_value, "12,345")
 
     def test_list_display_for_value(self):
         display_value = display_for_value([1, 2, 3], self.empty_value)
-        self.assertEqual(display_value, '1, 2, 3')
+        self.assertEqual(display_value, "1, 2, 3")
 
-        display_value = display_for_value([1, 2, 'buckle', 'my', 'shoe'], self.empty_value)
-        self.assertEqual(display_value, '1, 2, buckle, my, shoe')
+        display_value = display_for_value(
+            [1, 2, "buckle", "my", "shoe"], self.empty_value
+        )
+        self.assertEqual(display_value, "1, 2, buckle, my, shoe")
 
     @override_settings(USE_THOUSAND_SEPARATOR=True)
     def test_list_display_for_value_boolean(self):
         self.assertEqual(
-            display_for_value(True, '', boolean=True),
-            '<img src="/static/admin/img/icon-yes.svg" alt="True">'
+            display_for_value(True, "", boolean=True),
+            '<img src="/static/admin/img/icon-yes.svg" alt="True">',
         )
         self.assertEqual(
-            display_for_value(False, '', boolean=True),
-            '<img src="/static/admin/img/icon-no.svg" alt="False">'
+            display_for_value(False, "", boolean=True),
+            '<img src="/static/admin/img/icon-no.svg" alt="False">',
         )
-        self.assertEqual(display_for_value(True, ''), 'True')
-        self.assertEqual(display_for_value(False, ''), 'False')
+        self.assertEqual(display_for_value(True, ""), "True")
+        self.assertEqual(display_for_value(False, ""), "False")
 
     def test_label_for_field(self):
         """
         Tests for label_for_field
         """
+        self.assertEqual(label_for_field("title", Article), "title")
+        self.assertEqual(label_for_field("hist", Article), "History")
         self.assertEqual(
-            label_for_field("title", Article),
-            "title"
-        )
-        self.assertEqual(
-            label_for_field("hist", Article),
-            "History"
-        )
-        self.assertEqual(
-            label_for_field("hist", Article, return_attr=True),
-            ("History", None)
+            label_for_field("hist", Article, return_attr=True), ("History", None)
         )
 
-        self.assertEqual(
-            label_for_field("__str__", Article),
-            "article"
-        )
+        self.assertEqual(label_for_field("__str__", Article), "article")
 
-        with self.assertRaisesMessage(AttributeError, "Unable to lookup 'unknown' on Article"):
+        with self.assertRaisesMessage(
+            AttributeError, "Unable to lookup 'unknown' on Article"
+        ):
             label_for_field("unknown", Article)
 
         def test_callable(obj):
             return "nothing"
-        self.assertEqual(
-            label_for_field(test_callable, Article),
-            "Test callable"
-        )
+
+        self.assertEqual(label_for_field(test_callable, Article), "Test callable")
         self.assertEqual(
             label_for_field(test_callable, Article, return_attr=True),
-            ("Test callable", test_callable)
+            ("Test callable", test_callable),
         )
 
-        self.assertEqual(
-            label_for_field("test_from_model", Article),
-            "Test from model"
-        )
+        self.assertEqual(label_for_field("test_from_model", Article), "Test from model")
         self.assertEqual(
             label_for_field("test_from_model", Article, return_attr=True),
-            ("Test from model", Article.test_from_model)
+            ("Test from model", Article.test_from_model),
         )
         self.assertEqual(
             label_for_field("test_from_model_with_override", Article),
-            "not What you Expect"
+            "not What you Expect",
         )
 
-        self.assertEqual(
-            label_for_field(lambda x: "nothing", Article),
-            "--"
-        )
-        self.assertEqual(label_for_field('site_id', Article), 'Site id')
+        self.assertEqual(label_for_field(lambda x: "nothing", Article), "--")
+        self.assertEqual(label_for_field("site_id", Article), "Site id")
 
         class MockModelAdmin:
-            @admin.display(description='not Really the Model')
+            @admin.display(description="not Really the Model")
             def test_from_model(self, obj):
                 return "nothing"
 
         self.assertEqual(
             label_for_field("test_from_model", Article, model_admin=MockModelAdmin),
-            "not Really the Model"
+            "not Really the Model",
         )
         self.assertEqual(
-            label_for_field("test_from_model", Article, model_admin=MockModelAdmin, return_attr=True),
-            ("not Really the Model", MockModelAdmin.test_from_model)
+            label_for_field(
+                "test_from_model", Article, model_admin=MockModelAdmin, return_attr=True
+            ),
+            ("not Really the Model", MockModelAdmin.test_from_model),
         )
 
     def test_label_for_field_form_argument(self):
@@ -306,34 +316,34 @@ class UtilsTests(SimpleTestCase):
             extra_form_field = forms.BooleanField()
 
             class Meta:
-                fields = '__all__'
+                fields = "__all__"
                 model = Article
 
         self.assertEqual(
-            label_for_field('extra_form_field', Article, form=ArticleForm()),
-            'Extra form field'
+            label_for_field("extra_form_field", Article, form=ArticleForm()),
+            "Extra form field",
         )
         msg = "Unable to lookup 'nonexistent' on Article or ArticleForm"
         with self.assertRaisesMessage(AttributeError, msg):
-            label_for_field('nonexistent', Article, form=ArticleForm()),
+            label_for_field("nonexistent", Article, form=ArticleForm()),
 
     def test_label_for_property(self):
         class MockModelAdmin:
             @property
-            @admin.display(description='property short description')
+            @admin.display(description="property short description")
             def test_from_property(self):
                 return "this if from property"
 
         self.assertEqual(
             label_for_field("test_from_property", Article, model_admin=MockModelAdmin),
-            'property short description'
+            "property short description",
         )
 
     def test_help_text_for_field(self):
         tests = [
-            ('article', ''),
-            ('unknown', ''),
-            ('hist', 'History help text'),
+            ("article", ""),
+            ("unknown", ""),
+            ("hist", "History help text"),
         ]
         for name, help_text in tests:
             with self.subTest(name=name):
@@ -344,48 +354,56 @@ class UtilsTests(SimpleTestCase):
         Regression test for #13963
         """
         self.assertEqual(
-            label_for_field('location', Event, return_attr=True),
-            ('location', None),
+            label_for_field("location", Event, return_attr=True),
+            ("location", None),
         )
         self.assertEqual(
-            label_for_field('event', Location, return_attr=True),
-            ('awesome event', None),
+            label_for_field("event", Location, return_attr=True),
+            ("awesome event", None),
         )
         self.assertEqual(
-            label_for_field('guest', Event, return_attr=True),
-            ('awesome guest', None),
+            label_for_field("guest", Event, return_attr=True),
+            ("awesome guest", None),
         )
 
     def test_safestring_in_field_label(self):
         # safestring should not be escaped
         class MyForm(forms.Form):
-            text = forms.CharField(label=mark_safe('<i>text</i>'))
-            cb = forms.BooleanField(label=mark_safe('<i>cb</i>'))
+            text = forms.CharField(label=mark_safe("<i>text</i>"))
+            cb = forms.BooleanField(label=mark_safe("<i>cb</i>"))
 
         form = MyForm()
-        self.assertHTMLEqual(helpers.AdminField(form, 'text', is_first=False).label_tag(),
-                             '<label for="id_text" class="required inline"><i>text</i>:</label>')
-        self.assertHTMLEqual(helpers.AdminField(form, 'cb', is_first=False).label_tag(),
-                             '<label for="id_cb" class="vCheckboxLabel required inline"><i>cb</i></label>')
+        self.assertHTMLEqual(
+            helpers.AdminField(form, "text", is_first=False).label_tag(),
+            '<label for="id_text" class="required inline"><i>text</i>:</label>',
+        )
+        self.assertHTMLEqual(
+            helpers.AdminField(form, "cb", is_first=False).label_tag(),
+            '<label for="id_cb" class="vCheckboxLabel required inline"><i>cb</i></label>',
+        )
 
         # normal strings needs to be escaped
         class MyForm(forms.Form):
-            text = forms.CharField(label='&text')
-            cb = forms.BooleanField(label='&cb')
+            text = forms.CharField(label="&text")
+            cb = forms.BooleanField(label="&cb")
 
         form = MyForm()
-        self.assertHTMLEqual(helpers.AdminField(form, 'text', is_first=False).label_tag(),
-                             '<label for="id_text" class="required inline">&amp;text:</label>')
-        self.assertHTMLEqual(helpers.AdminField(form, 'cb', is_first=False).label_tag(),
-                             '<label for="id_cb" class="vCheckboxLabel required inline">&amp;cb</label>')
+        self.assertHTMLEqual(
+            helpers.AdminField(form, "text", is_first=False).label_tag(),
+            '<label for="id_text" class="required inline">&amp;text:</label>',
+        )
+        self.assertHTMLEqual(
+            helpers.AdminField(form, "cb", is_first=False).label_tag(),
+            '<label for="id_cb" class="vCheckboxLabel required inline">&amp;cb</label>',
+        )
 
     def test_flatten(self):
-        flat_all = ['url', 'title', 'content', 'sites']
+        flat_all = ["url", "title", "content", "sites"]
         inputs = (
             ((), []),
-            (('url', 'title', ('content', 'sites')), flat_all),
-            (('url', 'title', 'content', 'sites'), flat_all),
-            ((('url', 'title'), ('content', 'sites')), flat_all)
+            (("url", "title", ("content", "sites")), flat_all),
+            (("url", "title", "content", "sites"), flat_all),
+            ((("url", "title"), ("content", "sites")), flat_all),
         )
         for orig, expected in inputs:
             self.assertEqual(flatten(orig), expected)
@@ -394,19 +412,15 @@ class UtilsTests(SimpleTestCase):
         """
         Regression test for #18051
         """
-        fieldsets = (
-            (None, {
-                'fields': ('url', 'title', ('content', 'sites'))
-            }),
+        fieldsets = ((None, {"fields": ("url", "title", ("content", "sites"))}),)
+        self.assertEqual(
+            flatten_fieldsets(fieldsets), ["url", "title", "content", "sites"]
         )
-        self.assertEqual(flatten_fieldsets(fieldsets), ['url', 'title', 'content', 'sites'])
 
-        fieldsets = (
-            (None, {
-                'fields': ('url', 'title', ['content', 'sites'])
-            }),
+        fieldsets = ((None, {"fields": ("url", "title", ["content", "sites"])}),)
+        self.assertEqual(
+            flatten_fieldsets(fieldsets), ["url", "title", "content", "sites"]
         )
-        self.assertEqual(flatten_fieldsets(fieldsets), ['url', 'title', 'content', 'sites'])
 
     def test_quote(self):
-        self.assertEqual(quote('something\nor\nother'), 'something_0Aor_0Aother')
+        self.assertEqual(quote("something\nor\nother"), "something_0Aor_0Aother")
diff --git a/tests/admin_utils/urls.py b/tests/admin_utils/urls.py
index 2e472fc575..1b6a97e4bd 100644
--- a/tests/admin_utils/urls.py
+++ b/tests/admin_utils/urls.py
@@ -3,5 +3,5 @@ from django.urls import path
 from .admin import site
 
 urlpatterns = [
-    path('test_admin/admin/', site.urls),
+    path("test_admin/admin/", site.urls),
 ]