Refs #33476 -- Reformatted code with Black.

7 files changed, 354 insertions, 274 deletions

diff --git a/tests/admin_docs/models.py b/tests/admin_docs/models.py
index 06569d5c4c..7ae1ed8f95 100644
--- a/tests/admin_docs/models.py
+++ b/tests/admin_docs/models.py
@@ -36,10 +36,11 @@ class Person(models.Model):
 
     .. include:: admin_docs/evilfile.txt
     """
+
     first_name = models.CharField(max_length=200, help_text="The person's first name")
     last_name = models.CharField(max_length=200, help_text="The person's last name")
     company = models.ForeignKey(Company, models.CASCADE, help_text="place of work")
-    family = models.ForeignKey(Family, models.SET_NULL, related_name='+', null=True)
+    family = models.ForeignKey(Family, models.SET_NULL, related_name="+", null=True)
     groups = models.ManyToManyField(Group, help_text="has membership")
 
     def _get_full_name(self):
@@ -55,13 +56,13 @@ class Person(models.Model):
 
     @property
     def a_property(self):
-        return 'a_property'
+        return "a_property"
 
     @cached_property
     def a_cached_property(self):
-        return 'a_cached_property'
+        return "a_cached_property"
 
-    def suffix_company_name(self, suffix='ltd'):
+    def suffix_company_name(self, suffix="ltd"):
         return self.company.name + suffix
 
     def add_image(self):
diff --git a/tests/admin_docs/namespace_urls.py b/tests/admin_docs/namespace_urls.py
index 719bf0ddf5..b8eb0351f2 100644
--- a/tests/admin_docs/namespace_urls.py
+++ b/tests/admin_docs/namespace_urls.py
@@ -3,12 +3,15 @@ from django.urls import include, path
 
 from . import views
 
-backend_urls = ([
-    path('something/', views.XViewClass.as_view(), name='something'),
-], 'backend')
+backend_urls = (
+    [
+        path("something/", views.XViewClass.as_view(), name="something"),
+    ],
+    "backend",
+)
 
 urlpatterns = [
-    path('admin/doc/', include('django.contrib.admindocs.urls')),
-    path('admin/', admin.site.urls),
-    path('api/backend/', include(backend_urls, namespace='backend')),
+    path("admin/doc/", include("django.contrib.admindocs.urls")),
+    path("admin/", admin.site.urls),
+    path("api/backend/", include(backend_urls, namespace="backend")),
 ]
diff --git a/tests/admin_docs/test_middleware.py b/tests/admin_docs/test_middleware.py
index 5d737f1bfd..3095074ee6 100644
--- a/tests/admin_docs/test_middleware.py
+++ b/tests/admin_docs/test_middleware.py
@@ -6,47 +6,48 @@ from .tests import AdminDocsTestCase, TestDataMixin
 
 
 class XViewMiddlewareTest(TestDataMixin, AdminDocsTestCase):
-
     def test_xview_func(self):
-        user = User.objects.get(username='super')
-        response = self.client.head('/xview/func/')
-        self.assertNotIn('X-View', response)
+        user = User.objects.get(username="super")
+        response = self.client.head("/xview/func/")
+        self.assertNotIn("X-View", response)
         self.client.force_login(self.superuser)
-        response = self.client.head('/xview/func/')
-        self.assertIn('X-View', response)
-        self.assertEqual(response.headers['X-View'], 'admin_docs.views.xview')
+        response = self.client.head("/xview/func/")
+        self.assertIn("X-View", response)
+        self.assertEqual(response.headers["X-View"], "admin_docs.views.xview")
         user.is_staff = False
         user.save()
-        response = self.client.head('/xview/func/')
-        self.assertNotIn('X-View', response)
+        response = self.client.head("/xview/func/")
+        self.assertNotIn("X-View", response)
         user.is_staff = True
         user.is_active = False
         user.save()
-        response = self.client.head('/xview/func/')
-        self.assertNotIn('X-View', response)
+        response = self.client.head("/xview/func/")
+        self.assertNotIn("X-View", response)
 
     def test_xview_class(self):
-        user = User.objects.get(username='super')
-        response = self.client.head('/xview/class/')
-        self.assertNotIn('X-View', response)
+        user = User.objects.get(username="super")
+        response = self.client.head("/xview/class/")
+        self.assertNotIn("X-View", response)
         self.client.force_login(self.superuser)
-        response = self.client.head('/xview/class/')
-        self.assertIn('X-View', response)
-        self.assertEqual(response.headers['X-View'], 'admin_docs.views.XViewClass')
+        response = self.client.head("/xview/class/")
+        self.assertIn("X-View", response)
+        self.assertEqual(response.headers["X-View"], "admin_docs.views.XViewClass")
         user.is_staff = False
         user.save()
-        response = self.client.head('/xview/class/')
-        self.assertNotIn('X-View', response)
+        response = self.client.head("/xview/class/")
+        self.assertNotIn("X-View", response)
         user.is_staff = True
         user.is_active = False
         user.save()
-        response = self.client.head('/xview/class/')
-        self.assertNotIn('X-View', response)
+        response = self.client.head("/xview/class/")
+        self.assertNotIn("X-View", response)
 
     def test_callable_object_view(self):
         self.client.force_login(self.superuser)
-        response = self.client.head('/xview/callable_object/')
-        self.assertEqual(response.headers['X-View'], 'admin_docs.views.XViewCallableObject')
+        response = self.client.head("/xview/callable_object/")
+        self.assertEqual(
+            response.headers["X-View"], "admin_docs.views.XViewCallableObject"
+        )
 
     @override_settings(MIDDLEWARE=[])
     def test_no_auth_middleware(self):
@@ -56,4 +57,4 @@ class XViewMiddlewareTest(TestDataMixin, AdminDocsTestCase):
             "'django.contrib.auth.middleware.AuthenticationMiddleware'."
         )
         with self.assertRaisesMessage(ImproperlyConfigured, msg):
-            self.client.head('/xview/func/')
+            self.client.head("/xview/func/")
diff --git a/tests/admin_docs/test_utils.py b/tests/admin_docs/test_utils.py
index 9ffc25392c..18c6769fad 100644
--- a/tests/admin_docs/test_utils.py
+++ b/tests/admin_docs/test_utils.py
@@ -1,7 +1,9 @@
 import unittest
 
 from django.contrib.admindocs.utils import (
-    docutils_is_available, parse_docstring, parse_rst,
+    docutils_is_available,
+    parse_docstring,
+    parse_rst,
 )
 from django.test.utils import captured_stderr
 
@@ -29,41 +31,42 @@ class TestUtils(AdminDocsSimpleTestCase):
 
     some_metadata: some data
     """
+
     def setUp(self):
         self.docstring = self.__doc__
 
     def test_parse_docstring(self):
         title, description, metadata = parse_docstring(self.docstring)
         docstring_title = (
-            'This __doc__ output is required for testing. I copied this example from\n'
-            '`admindocs` documentation. (TITLE)'
+            "This __doc__ output is required for testing. I copied this example from\n"
+            "`admindocs` documentation. (TITLE)"
         )
         docstring_description = (
-            'Display an individual :model:`myapp.MyModel`.\n\n'
-            '**Context**\n\n``RequestContext``\n\n``mymodel``\n'
-            '    An instance of :model:`myapp.MyModel`.\n\n'
-            '**Template:**\n\n:template:`myapp/my_template.html` '
-            '(DESCRIPTION)'
+            "Display an individual :model:`myapp.MyModel`.\n\n"
+            "**Context**\n\n``RequestContext``\n\n``mymodel``\n"
+            "    An instance of :model:`myapp.MyModel`.\n\n"
+            "**Template:**\n\n:template:`myapp/my_template.html` "
+            "(DESCRIPTION)"
         )
         self.assertEqual(title, docstring_title)
         self.assertEqual(description, docstring_description)
-        self.assertEqual(metadata, {'some_metadata': 'some data'})
+        self.assertEqual(metadata, {"some_metadata": "some data"})
 
     def test_title_output(self):
         title, description, metadata = parse_docstring(self.docstring)
-        title_output = parse_rst(title, 'model', 'model:admindocs')
-        self.assertIn('TITLE', title_output)
+        title_output = parse_rst(title, "model", "model:admindocs")
+        self.assertIn("TITLE", title_output)
         title_rendered = (
-            '<p>This __doc__ output is required for testing. I copied this '
+            "<p>This __doc__ output is required for testing. I copied this "
             'example from\n<a class="reference external" '
             'href="/admindocs/models/admindocs/">admindocs</a> documentation. '
-            '(TITLE)</p>\n'
+            "(TITLE)</p>\n"
         )
         self.assertHTMLEqual(title_output, title_rendered)
 
     def test_description_output(self):
         title, description, metadata = parse_docstring(self.docstring)
-        description_output = parse_rst(description, 'model', 'model:admindocs')
+        description_output = parse_rst(description, "model", "model:admindocs")
         description_rendered = (
             '<p>Display an individual <a class="reference external" '
             'href="/admindocs/models/myapp.mymodel/">myapp.MyModel</a>.</p>\n'
@@ -71,35 +74,35 @@ class TestUtils(AdminDocsSimpleTestCase):
             'RequestContext</tt></p>\n<dl class="docutils">\n<dt><tt class="'
             'docutils literal">mymodel</tt></dt>\n<dd>An instance of <a class="'
             'reference external" href="/admindocs/models/myapp.mymodel/">'
-            'myapp.MyModel</a>.</dd>\n</dl>\n<p><strong>Template:</strong></p>'
+            "myapp.MyModel</a>.</dd>\n</dl>\n<p><strong>Template:</strong></p>"
             '\n<p><a class="reference external" href="/admindocs/templates/'
             'myapp/my_template.html/">myapp/my_template.html</a> (DESCRIPTION)'
-            '</p>\n'
+            "</p>\n"
         )
         self.assertHTMLEqual(description_output, description_rendered)
 
     def test_initial_header_level(self):
-        header = 'should be h3...\n\nHeader\n------\n'
-        output = parse_rst(header, 'header')
-        self.assertIn('<h3>Header</h3>', output)
+        header = "should be h3...\n\nHeader\n------\n"
+        output = parse_rst(header, "header")
+        self.assertIn("<h3>Header</h3>", output)
 
     def test_parse_rst(self):
         """
         parse_rst() should use `cmsreference` as the default role.
         """
         markup = '<p><a class="reference external" href="/admindocs/%s">title</a></p>\n'
-        self.assertEqual(parse_rst('`title`', 'model'), markup % 'models/title/')
-        self.assertEqual(parse_rst('`title`', 'view'), markup % 'views/title/')
-        self.assertEqual(parse_rst('`title`', 'template'), markup % 'templates/title/')
-        self.assertEqual(parse_rst('`title`', 'filter'), markup % 'filters/#title')
-        self.assertEqual(parse_rst('`title`', 'tag'), markup % 'tags/#title')
+        self.assertEqual(parse_rst("`title`", "model"), markup % "models/title/")
+        self.assertEqual(parse_rst("`title`", "view"), markup % "views/title/")
+        self.assertEqual(parse_rst("`title`", "template"), markup % "templates/title/")
+        self.assertEqual(parse_rst("`title`", "filter"), markup % "filters/#title")
+        self.assertEqual(parse_rst("`title`", "tag"), markup % "tags/#title")
 
     def test_parse_rst_with_docstring_no_leading_line_feed(self):
-        title, body, _ = parse_docstring('firstline\n\n    second line')
+        title, body, _ = parse_docstring("firstline\n\n    second line")
         with captured_stderr() as stderr:
-            self.assertEqual(parse_rst(title, ''), '<p>firstline</p>\n')
-            self.assertEqual(parse_rst(body, ''), '<p>second line</p>\n')
-        self.assertEqual(stderr.getvalue(), '')
+            self.assertEqual(parse_rst(title, ""), "<p>firstline</p>\n")
+            self.assertEqual(parse_rst(body, ""), "<p>second line</p>\n")
+        self.assertEqual(stderr.getvalue(), "")
 
     def test_publish_parts(self):
         """
@@ -108,8 +111,11 @@ class TestUtils(AdminDocsSimpleTestCase):
         ``cmsreference`` (#6681).
         """
         import docutils
-        self.assertNotEqual(docutils.parsers.rst.roles.DEFAULT_INTERPRETED_ROLE, 'cmsreference')
-        source = 'reST, `interpreted text`, default role.'
-        markup = '<p>reST, <cite>interpreted text</cite>, default role.</p>\n'
+
+        self.assertNotEqual(
+            docutils.parsers.rst.roles.DEFAULT_INTERPRETED_ROLE, "cmsreference"
+        )
+        source = "reST, `interpreted text`, default role."
+        markup = "<p>reST, <cite>interpreted text</cite>, default role.</p>\n"
         parts = docutils.core.publish_parts(source=source, writer_name="html4css1")
-        self.assertEqual(parts['fragment'], markup)
+        self.assertEqual(parts["fragment"], markup)
diff --git a/tests/admin_docs/test_views.py b/tests/admin_docs/test_views.py
index b786fb1930..c11b8f71c2 100644
--- a/tests/admin_docs/test_views.py
+++ b/tests/admin_docs/test_views.py
@@ -19,44 +19,50 @@ from .tests import AdminDocsTestCase, TestDataMixin
 
 @unittest.skipUnless(utils.docutils_is_available, "no docutils installed.")
 class AdminDocViewTests(TestDataMixin, AdminDocsTestCase):
-
     def setUp(self):
         self.client.force_login(self.superuser)
 
     def test_index(self):
-        response = self.client.get(reverse('django-admindocs-docroot'))
-        self.assertContains(response, '<h1>Documentation</h1>', html=True)
-        self.assertContains(response, '<h1 id="site-name"><a href="/admin/">Django administration</a></h1>')
+        response = self.client.get(reverse("django-admindocs-docroot"))
+        self.assertContains(response, "<h1>Documentation</h1>", html=True)
+        self.assertContains(
+            response,
+            '<h1 id="site-name"><a href="/admin/">Django administration</a></h1>',
+        )
         self.client.logout()
-        response = self.client.get(reverse('django-admindocs-docroot'), follow=True)
+        response = self.client.get(reverse("django-admindocs-docroot"), follow=True)
         # Should display the login screen
-        self.assertContains(response, '<input type="hidden" name="next" value="/admindocs/">', html=True)
+        self.assertContains(
+            response, '<input type="hidden" name="next" value="/admindocs/">', html=True
+        )
 
     def test_bookmarklets(self):
-        response = self.client.get(reverse('django-admindocs-bookmarklets'))
-        self.assertContains(response, '/admindocs/views/')
+        response = self.client.get(reverse("django-admindocs-bookmarklets"))
+        self.assertContains(response, "/admindocs/views/")
 
     def test_templatetag_index(self):
-        response = self.client.get(reverse('django-admindocs-tags'))
-        self.assertContains(response, '<h3 id="built_in-extends">extends</h3>', html=True)
+        response = self.client.get(reverse("django-admindocs-tags"))
+        self.assertContains(
+            response, '<h3 id="built_in-extends">extends</h3>', html=True
+        )
 
     def test_templatefilter_index(self):
-        response = self.client.get(reverse('django-admindocs-filters'))
+        response = self.client.get(reverse("django-admindocs-filters"))
         self.assertContains(response, '<h3 id="built_in-first">first</h3>', html=True)
 
     def test_view_index(self):
-        response = self.client.get(reverse('django-admindocs-views-index'))
+        response = self.client.get(reverse("django-admindocs-views-index"))
         self.assertContains(
             response,
             '<h3><a href="/admindocs/views/django.contrib.admindocs.views.BaseAdminDocsView/">/admindocs/</a></h3>',
-            html=True
+            html=True,
         )
-        self.assertContains(response, 'Views by namespace test')
-        self.assertContains(response, 'Name: <code>test:func</code>.')
+        self.assertContains(response, "Views by namespace test")
+        self.assertContains(response, "Name: <code>test:func</code>.")
         self.assertContains(
             response,
             '<h3><a href="/admindocs/views/admin_docs.views.XViewCallableObject/">'
-            '/xview/callable_object_without_xview/</a></h3>',
+            "/xview/callable_object_without_xview/</a></h3>",
             html=True,
         )
 
@@ -64,27 +70,35 @@ class AdminDocViewTests(TestDataMixin, AdminDocsTestCase):
         """
         Views that are methods are listed correctly.
         """
-        response = self.client.get(reverse('django-admindocs-views-index'))
+        response = self.client.get(reverse("django-admindocs-views-index"))
         self.assertContains(
             response,
             '<h3><a href="/admindocs/views/django.contrib.admin.sites.AdminSite.index/">/admin/</a></h3>',
-            html=True
+            html=True,
         )
 
     def test_view_detail(self):
-        url = reverse('django-admindocs-views-detail', args=['django.contrib.admindocs.views.BaseAdminDocsView'])
+        url = reverse(
+            "django-admindocs-views-detail",
+            args=["django.contrib.admindocs.views.BaseAdminDocsView"],
+        )
         response = self.client.get(url)
         # View docstring
-        self.assertContains(response, 'Base view for admindocs views.')
+        self.assertContains(response, "Base view for admindocs views.")
 
-    @override_settings(ROOT_URLCONF='admin_docs.namespace_urls')
+    @override_settings(ROOT_URLCONF="admin_docs.namespace_urls")
     def test_namespaced_view_detail(self):
-        url = reverse('django-admindocs-views-detail', args=['admin_docs.views.XViewClass'])
+        url = reverse(
+            "django-admindocs-views-detail", args=["admin_docs.views.XViewClass"]
+        )
         response = self.client.get(url)
-        self.assertContains(response, '<h1>admin_docs.views.XViewClass</h1>')
+        self.assertContains(response, "<h1>admin_docs.views.XViewClass</h1>")
 
     def test_view_detail_illegal_import(self):
-        url = reverse('django-admindocs-views-detail', args=['urlpatterns_reverse.nonimported_module.view'])
+        url = reverse(
+            "django-admindocs-views-detail",
+            args=["urlpatterns_reverse.nonimported_module.view"],
+        )
         response = self.client.get(url)
         self.assertEqual(response.status_code, 404)
         self.assertNotIn("urlpatterns_reverse.nonimported_module", sys.modules)
@@ -93,41 +107,55 @@ class AdminDocViewTests(TestDataMixin, AdminDocsTestCase):
         """
         Views that are methods can be displayed.
         """
-        url = reverse('django-admindocs-views-detail', args=['django.contrib.admin.sites.AdminSite.index'])
+        url = reverse(
+            "django-admindocs-views-detail",
+            args=["django.contrib.admin.sites.AdminSite.index"],
+        )
         response = self.client.get(url)
         self.assertEqual(response.status_code, 200)
 
     def test_model_index(self):
-        response = self.client.get(reverse('django-admindocs-models-index'))
+        response = self.client.get(reverse("django-admindocs-models-index"))
         self.assertContains(
             response,
             '<h2 id="app-auth">Authentication and Authorization (django.contrib.auth)</h2>',
-            html=True
+            html=True,
         )
 
     def test_template_detail(self):
-        response = self.client.get(reverse('django-admindocs-templates', args=['admin_doc/template_detail.html']))
-        self.assertContains(response, '<h1>Template: <q>admin_doc/template_detail.html</q></h1>', html=True)
+        response = self.client.get(
+            reverse(
+                "django-admindocs-templates", args=["admin_doc/template_detail.html"]
+            )
+        )
+        self.assertContains(
+            response,
+            "<h1>Template: <q>admin_doc/template_detail.html</q></h1>",
+            html=True,
+        )
 
     def test_missing_docutils(self):
         utils.docutils_is_available = False
         try:
-            response = self.client.get(reverse('django-admindocs-docroot'))
+            response = self.client.get(reverse("django-admindocs-docroot"))
             self.assertContains(
                 response,
-                '<h3>The admin documentation system requires Python’s '
+                "<h3>The admin documentation system requires Python’s "
                 '<a href="https://docutils.sourceforge.io/">docutils</a> '
-                'library.</h3>'
-                '<p>Please ask your administrators to install '
+                "library.</h3>"
+                "<p>Please ask your administrators to install "
                 '<a href="https://docutils.sourceforge.io/">docutils</a>.</p>',
-                html=True
+                html=True,
+            )
+            self.assertContains(
+                response,
+                '<h1 id="site-name"><a href="/admin/">Django administration</a></h1>',
             )
-            self.assertContains(response, '<h1 id="site-name"><a href="/admin/">Django administration</a></h1>')
         finally:
             utils.docutils_is_available = True
 
-    @modify_settings(INSTALLED_APPS={'remove': 'django.contrib.sites'})
-    @override_settings(SITE_ID=None)    # will restore SITE_ID after the test
+    @modify_settings(INSTALLED_APPS={"remove": "django.contrib.sites"})
+    @override_settings(SITE_ID=None)  # will restore SITE_ID after the test
     def test_no_sites_framework(self):
         """
         Without the sites framework, should not access SITE_ID or Site
@@ -135,73 +163,78 @@ class AdminDocViewTests(TestDataMixin, AdminDocsTestCase):
         """
         Site.objects.all().delete()
         del settings.SITE_ID
-        response = self.client.get(reverse('django-admindocs-views-index'))
-        self.assertContains(response, 'View documentation')
+        response = self.client.get(reverse("django-admindocs-views-index"))
+        self.assertContains(response, "View documentation")
 
     def test_callable_urlconf(self):
         """
         Index view should correctly resolve view patterns when ROOT_URLCONF is
         not a string.
         """
+
         def urlpatterns():
             return (
-                path('admin/doc/', include('django.contrib.admindocs.urls')),
-                path('admin/', admin.site.urls),
+                path("admin/doc/", include("django.contrib.admindocs.urls")),
+                path("admin/", admin.site.urls),
             )
 
         with self.settings(ROOT_URLCONF=SimpleLazyObject(urlpatterns)):
-            response = self.client.get(reverse('django-admindocs-views-index'))
+            response = self.client.get(reverse("django-admindocs-views-index"))
             self.assertEqual(response.status_code, 200)
 
 
-@unittest.skipUnless(utils.docutils_is_available, 'no docutils installed.')
+@unittest.skipUnless(utils.docutils_is_available, "no docutils installed.")
 class AdminDocViewDefaultEngineOnly(TestDataMixin, AdminDocsTestCase):
-
     def setUp(self):
         self.client.force_login(self.superuser)
 
     def test_template_detail_path_traversal(self):
-        cases = ['/etc/passwd', '../passwd']
+        cases = ["/etc/passwd", "../passwd"]
         for fpath in cases:
             with self.subTest(path=fpath):
                 response = self.client.get(
-                    reverse('django-admindocs-templates', args=[fpath]),
+                    reverse("django-admindocs-templates", args=[fpath]),
                 )
                 self.assertEqual(response.status_code, 400)
 
 
-@override_settings(TEMPLATES=[{
-    'NAME': 'ONE',
-    'BACKEND': 'django.template.backends.django.DjangoTemplates',
-    'APP_DIRS': True,
-}, {
-    'NAME': 'TWO',
-    'BACKEND': 'django.template.backends.django.DjangoTemplates',
-    'APP_DIRS': True,
-}])
+@override_settings(
+    TEMPLATES=[
+        {
+            "NAME": "ONE",
+            "BACKEND": "django.template.backends.django.DjangoTemplates",
+            "APP_DIRS": True,
+        },
+        {
+            "NAME": "TWO",
+            "BACKEND": "django.template.backends.django.DjangoTemplates",
+            "APP_DIRS": True,
+        },
+    ]
+)
 @unittest.skipUnless(utils.docutils_is_available, "no docutils installed.")
 class AdminDocViewWithMultipleEngines(AdminDocViewTests):
-
     def test_templatefilter_index(self):
         # Overridden because non-trivial TEMPLATES settings aren't supported
         # but the page shouldn't crash (#24125).
-        response = self.client.get(reverse('django-admindocs-filters'))
-        self.assertContains(response, '<title>Template filters</title>', html=True)
+        response = self.client.get(reverse("django-admindocs-filters"))
+        self.assertContains(response, "<title>Template filters</title>", html=True)
 
     def test_templatetag_index(self):
         # Overridden because non-trivial TEMPLATES settings aren't supported
         # but the page shouldn't crash (#24125).
-        response = self.client.get(reverse('django-admindocs-tags'))
-        self.assertContains(response, '<title>Template tags</title>', html=True)
+        response = self.client.get(reverse("django-admindocs-tags"))
+        self.assertContains(response, "<title>Template tags</title>", html=True)
 
 
 @unittest.skipUnless(utils.docutils_is_available, "no docutils installed.")
 class TestModelDetailView(TestDataMixin, AdminDocsTestCase):
-
     def setUp(self):
         self.client.force_login(self.superuser)
         with captured_stderr() as self.docutils_stderr:
-            self.response = self.client.get(reverse('django-admindocs-models-detail', args=['admin_docs', 'Person']))
+            self.response = self.client.get(
+                reverse("django-admindocs-models-detail", args=["admin_docs", "Person"])
+            )
 
     def test_method_excludes(self):
         """
@@ -235,42 +268,52 @@ class TestModelDetailView(TestDataMixin, AdminDocsTestCase):
         """
         Methods with keyword arguments should have their arguments displayed.
         """
-        self.assertContains(self.response, '<td>suffix=&#x27;ltd&#x27;</td>')
+        self.assertContains(self.response, "<td>suffix=&#x27;ltd&#x27;</td>")
 
     def test_methods_with_multiple_arguments_display_arguments(self):
         """
         Methods with multiple arguments should have all their arguments
         displayed, but omitting 'self'.
         """
-        self.assertContains(self.response, "<td>baz, rox, *some_args, **some_kwargs</td>")
+        self.assertContains(
+            self.response, "<td>baz, rox, *some_args, **some_kwargs</td>"
+        )
 
     def test_instance_of_property_methods_are_displayed(self):
         """Model properties are displayed as fields."""
-        self.assertContains(self.response, '<td>a_property</td>')
+        self.assertContains(self.response, "<td>a_property</td>")
 
     def test_instance_of_cached_property_methods_are_displayed(self):
         """Model cached properties are displayed as fields."""
-        self.assertContains(self.response, '<td>a_cached_property</td>')
+        self.assertContains(self.response, "<td>a_cached_property</td>")
 
     def test_method_data_types(self):
         company = Company.objects.create(name="Django")
-        person = Person.objects.create(first_name="Human", last_name="User", company=company)
-        self.assertEqual(get_return_data_type(person.get_status_count.__name__), 'Integer')
-        self.assertEqual(get_return_data_type(person.get_groups_list.__name__), 'List')
+        person = Person.objects.create(
+            first_name="Human", last_name="User", company=company
+        )
+        self.assertEqual(
+            get_return_data_type(person.get_status_count.__name__), "Integer"
+        )
+        self.assertEqual(get_return_data_type(person.get_groups_list.__name__), "List")
 
     def test_descriptions_render_correctly(self):
         """
         The ``description`` field should render correctly for each field type.
         """
         # help text in fields
-        self.assertContains(self.response, "<td>first name - The person's first name</td>")
-        self.assertContains(self.response, "<td>last name - The person's last name</td>")
+        self.assertContains(
+            self.response, "<td>first name - The person's first name</td>"
+        )
+        self.assertContains(
+            self.response, "<td>last name - The person's last name</td>"
+        )
 
         # method docstrings
         self.assertContains(self.response, "<p>Get the full name of the person</p>")
 
         link = '<a class="reference external" href="/admindocs/models/%s/">%s</a>'
-        markup = '<p>the related %s object</p>'
+        markup = "<p>the related %s object</p>"
         company_markup = markup % (link % ("admin_docs.company", "admin_docs.Company"))
 
         # foreign keys
@@ -282,18 +325,28 @@ class TestModelDetailView(TestDataMixin, AdminDocsTestCase):
         # many to many fields
         self.assertContains(
             self.response,
-            "number of related %s objects" % (link % ("admin_docs.group", "admin_docs.Group"))
+            "number of related %s objects"
+            % (link % ("admin_docs.group", "admin_docs.Group")),
         )
         self.assertContains(
             self.response,
-            "all related %s objects" % (link % ("admin_docs.group", "admin_docs.Group"))
+            "all related %s objects"
+            % (link % ("admin_docs.group", "admin_docs.Group")),
         )
 
         # "raw" and "include" directives are disabled
-        self.assertContains(self.response, '<p>&quot;raw&quot; directive disabled.</p>',)
-        self.assertContains(self.response, '.. raw:: html\n    :file: admin_docs/evilfile.txt')
-        self.assertContains(self.response, '<p>&quot;include&quot; directive disabled.</p>',)
-        self.assertContains(self.response, '.. include:: admin_docs/evilfile.txt')
+        self.assertContains(
+            self.response,
+            "<p>&quot;raw&quot; directive disabled.</p>",
+        )
+        self.assertContains(
+            self.response, ".. raw:: html\n    :file: admin_docs/evilfile.txt"
+        )
+        self.assertContains(
+            self.response,
+            "<p>&quot;include&quot; directive disabled.</p>",
+        )
+        self.assertContains(self.response, ".. include:: admin_docs/evilfile.txt")
         out = self.docutils_stderr.getvalue()
         self.assertIn('"raw" directive disabled', out)
         self.assertIn('"include" directive disabled', out)
@@ -301,15 +354,17 @@ class TestModelDetailView(TestDataMixin, AdminDocsTestCase):
     def test_model_with_many_to_one(self):
         link = '<a class="reference external" href="/admindocs/models/%s/">%s</a>'
         response = self.client.get(
-            reverse('django-admindocs-models-detail', args=['admin_docs', 'company'])
+            reverse("django-admindocs-models-detail", args=["admin_docs", "company"])
         )
         self.assertContains(
             response,
-            "number of related %s objects" % (link % ("admin_docs.person", "admin_docs.Person"))
+            "number of related %s objects"
+            % (link % ("admin_docs.person", "admin_docs.Person")),
         )
         self.assertContains(
             response,
-            "all related %s objects" % (link % ("admin_docs.person", "admin_docs.Person"))
+            "all related %s objects"
+            % (link % ("admin_docs.person", "admin_docs.Person")),
         )
 
     def test_model_with_no_backward_relations_render_only_relevant_fields(self):
@@ -317,8 +372,10 @@ class TestModelDetailView(TestDataMixin, AdminDocsTestCase):
         A model with ``related_name`` of `+` shouldn't show backward
         relationship links.
         """
-        response = self.client.get(reverse('django-admindocs-models-detail', args=['admin_docs', 'family']))
-        fields = response.context_data.get('fields')
+        response = self.client.get(
+            reverse("django-admindocs-models-detail", args=["admin_docs", "family"])
+        )
+        fields = response.context_data.get("fields")
         self.assertEqual(len(fields), 2)
 
     def test_model_docstring_renders_correctly(self):
@@ -326,31 +383,40 @@ class TestModelDetailView(TestDataMixin, AdminDocsTestCase):
             '<h2 class="subhead"><p>Stores information about a person, related to <a class="reference external" '
             'href="/admindocs/models/myapp.company/">myapp.Company</a>.</p></h2>'
         )
-        subheading = '<p><strong>Notes</strong></p>'
+        subheading = "<p><strong>Notes</strong></p>"
         body = '<p>Use <tt class="docutils literal">save_changes()</tt> when saving this object.</p>'
         model_body = (
             '<dl class="docutils"><dt><tt class="'
             'docutils literal">company</tt></dt><dd>Field storing <a class="'
             'reference external" href="/admindocs/models/myapp.company/">'
-            'myapp.Company</a> where the person works.</dd></dl>'
+            "myapp.Company</a> where the person works.</dd></dl>"
         )
-        self.assertContains(self.response, 'DESCRIPTION')
+        self.assertContains(self.response, "DESCRIPTION")
         self.assertContains(self.response, summary, html=True)
         self.assertContains(self.response, subheading, html=True)
         self.assertContains(self.response, body, html=True)
         self.assertContains(self.response, model_body, html=True)
 
     def test_model_detail_title(self):
-        self.assertContains(self.response, '<h1>admin_docs.Person</h1>', html=True)
+        self.assertContains(self.response, "<h1>admin_docs.Person</h1>", html=True)
 
     def test_app_not_found(self):
-        response = self.client.get(reverse('django-admindocs-models-detail', args=['doesnotexist', 'Person']))
-        self.assertEqual(response.context['exception'], "App 'doesnotexist' not found")
+        response = self.client.get(
+            reverse("django-admindocs-models-detail", args=["doesnotexist", "Person"])
+        )
+        self.assertEqual(response.context["exception"], "App 'doesnotexist' not found")
         self.assertEqual(response.status_code, 404)
 
     def test_model_not_found(self):
-        response = self.client.get(reverse('django-admindocs-models-detail', args=['admin_docs', 'doesnotexist']))
-        self.assertEqual(response.context['exception'], "Model 'doesnotexist' not found in app 'admin_docs'")
+        response = self.client.get(
+            reverse(
+                "django-admindocs-models-detail", args=["admin_docs", "doesnotexist"]
+            )
+        )
+        self.assertEqual(
+            response.context["exception"],
+            "Model 'doesnotexist' not found in app 'admin_docs'",
+        )
         self.assertEqual(response.status_code, 404)
 
 
@@ -370,123 +436,124 @@ class TestFieldType(unittest.TestCase):
     def test_builtin_fields(self):
         self.assertEqual(
             views.get_readable_field_data_type(fields.BooleanField()),
-            'Boolean (Either True or False)'
+            "Boolean (Either True or False)",
         )
 
     def test_custom_fields(self):
-        self.assertEqual(views.get_readable_field_data_type(CustomField()), 'A custom field type')
+        self.assertEqual(
+            views.get_readable_field_data_type(CustomField()), "A custom field type"
+        )
         self.assertEqual(
             views.get_readable_field_data_type(DescriptionLackingField()),
-            'Field of type: DescriptionLackingField'
+            "Field of type: DescriptionLackingField",
         )
 
 
 class AdminDocViewFunctionsTests(SimpleTestCase):
-
     def test_simplify_regex(self):
         tests = (
             # Named and unnamed groups.
-            (r'^(?P<a>\w+)/b/(?P<c>\w+)/$', '/<a>/b/<c>/'),
-            (r'^(?P<a>\w+)/b/(?P<c>\w+)$', '/<a>/b/<c>'),
-            (r'^(?P<a>\w+)/b/(?P<c>\w+)', '/<a>/b/<c>'),
-            (r'^(?P<a>\w+)/b/(\w+)$', '/<a>/b/<var>'),
-            (r'^(?P<a>\w+)/b/(\w+)', '/<a>/b/<var>'),
-            (r'^(?P<a>\w+)/b/((x|y)\w+)$', '/<a>/b/<var>'),
-            (r'^(?P<a>\w+)/b/((x|y)\w+)', '/<a>/b/<var>'),
-            (r'^(?P<a>(x|y))/b/(?P<c>\w+)$', '/<a>/b/<c>'),
-            (r'^(?P<a>(x|y))/b/(?P<c>\w+)', '/<a>/b/<c>'),
-            (r'^(?P<a>(x|y))/b/(?P<c>\w+)ab', '/<a>/b/<c>ab'),
-            (r'^(?P<a>(x|y)(\(|\)))/b/(?P<c>\w+)ab', '/<a>/b/<c>ab'),
+            (r"^(?P<a>\w+)/b/(?P<c>\w+)/$", "/<a>/b/<c>/"),
+            (r"^(?P<a>\w+)/b/(?P<c>\w+)$", "/<a>/b/<c>"),
+            (r"^(?P<a>\w+)/b/(?P<c>\w+)", "/<a>/b/<c>"),
+            (r"^(?P<a>\w+)/b/(\w+)$", "/<a>/b/<var>"),
+            (r"^(?P<a>\w+)/b/(\w+)", "/<a>/b/<var>"),
+            (r"^(?P<a>\w+)/b/((x|y)\w+)$", "/<a>/b/<var>"),
+            (r"^(?P<a>\w+)/b/((x|y)\w+)", "/<a>/b/<var>"),
+            (r"^(?P<a>(x|y))/b/(?P<c>\w+)$", "/<a>/b/<c>"),
+            (r"^(?P<a>(x|y))/b/(?P<c>\w+)", "/<a>/b/<c>"),
+            (r"^(?P<a>(x|y))/b/(?P<c>\w+)ab", "/<a>/b/<c>ab"),
+            (r"^(?P<a>(x|y)(\(|\)))/b/(?P<c>\w+)ab", "/<a>/b/<c>ab"),
             # Non-capturing groups.
-            (r'^a(?:\w+)b', '/ab'),
-            (r'^a(?:(x|y))', '/a'),
-            (r'^(?:\w+(?:\w+))a', '/a'),
-            (r'^a(?:\w+)/b(?:\w+)', '/a/b'),
-            (r'(?P<a>\w+)/b/(?:\w+)c(?:\w+)', '/<a>/b/c'),
-            (r'(?P<a>\w+)/b/(\w+)/(?:\w+)c(?:\w+)', '/<a>/b/<var>/c'),
+            (r"^a(?:\w+)b", "/ab"),
+            (r"^a(?:(x|y))", "/a"),
+            (r"^(?:\w+(?:\w+))a", "/a"),
+            (r"^a(?:\w+)/b(?:\w+)", "/a/b"),
+            (r"(?P<a>\w+)/b/(?:\w+)c(?:\w+)", "/<a>/b/c"),
+            (r"(?P<a>\w+)/b/(\w+)/(?:\w+)c(?:\w+)", "/<a>/b/<var>/c"),
             # Single and repeated metacharacters.
-            (r'^a', '/a'),
-            (r'^^a', '/a'),
-            (r'^^^a', '/a'),
-            (r'a$', '/a'),
-            (r'a$$', '/a'),
-            (r'a$$$', '/a'),
-            (r'a?', '/a'),
-            (r'a??', '/a'),
-            (r'a???', '/a'),
-            (r'a*', '/a'),
-            (r'a**', '/a'),
-            (r'a***', '/a'),
-            (r'a+', '/a'),
-            (r'a++', '/a'),
-            (r'a+++', '/a'),
-            (r'\Aa', '/a'),
-            (r'\A\Aa', '/a'),
-            (r'\A\A\Aa', '/a'),
-            (r'a\Z', '/a'),
-            (r'a\Z\Z', '/a'),
-            (r'a\Z\Z\Z', '/a'),
-            (r'\ba', '/a'),
-            (r'\b\ba', '/a'),
-            (r'\b\b\ba', '/a'),
-            (r'a\B', '/a'),
-            (r'a\B\B', '/a'),
-            (r'a\B\B\B', '/a'),
+            (r"^a", "/a"),
+            (r"^^a", "/a"),
+            (r"^^^a", "/a"),
+            (r"a$", "/a"),
+            (r"a$$", "/a"),
+            (r"a$$$", "/a"),
+            (r"a?", "/a"),
+            (r"a??", "/a"),
+            (r"a???", "/a"),
+            (r"a*", "/a"),
+            (r"a**", "/a"),
+            (r"a***", "/a"),
+            (r"a+", "/a"),
+            (r"a++", "/a"),
+            (r"a+++", "/a"),
+            (r"\Aa", "/a"),
+            (r"\A\Aa", "/a"),
+            (r"\A\A\Aa", "/a"),
+            (r"a\Z", "/a"),
+            (r"a\Z\Z", "/a"),
+            (r"a\Z\Z\Z", "/a"),
+            (r"\ba", "/a"),
+            (r"\b\ba", "/a"),
+            (r"\b\b\ba", "/a"),
+            (r"a\B", "/a"),
+            (r"a\B\B", "/a"),
+            (r"a\B\B\B", "/a"),
             # Multiple mixed metacharacters.
-            (r'^a/?$', '/a/'),
-            (r'\Aa\Z', '/a'),
-            (r'\ba\B', '/a'),
+            (r"^a/?$", "/a/"),
+            (r"\Aa\Z", "/a"),
+            (r"\ba\B", "/a"),
             # Escaped single metacharacters.
-            (r'\^a', r'/^a'),
-            (r'\\^a', r'/\\a'),
-            (r'\\\^a', r'/\\^a'),
-            (r'\\\\^a', r'/\\\\a'),
-            (r'\\\\\^a', r'/\\\\^a'),
-            (r'a\$', r'/a$'),
-            (r'a\\$', r'/a\\'),
-            (r'a\\\$', r'/a\\$'),
-            (r'a\\\\$', r'/a\\\\'),
-            (r'a\\\\\$', r'/a\\\\$'),
-            (r'a\?', r'/a?'),
-            (r'a\\?', r'/a\\'),
-            (r'a\\\?', r'/a\\?'),
-            (r'a\\\\?', r'/a\\\\'),
-            (r'a\\\\\?', r'/a\\\\?'),
-            (r'a\*', r'/a*'),
-            (r'a\\*', r'/a\\'),
-            (r'a\\\*', r'/a\\*'),
-            (r'a\\\\*', r'/a\\\\'),
-            (r'a\\\\\*', r'/a\\\\*'),
-            (r'a\+', r'/a+'),
-            (r'a\\+', r'/a\\'),
-            (r'a\\\+', r'/a\\+'),
-            (r'a\\\\+', r'/a\\\\'),
-            (r'a\\\\\+', r'/a\\\\+'),
-            (r'\\Aa', r'/\Aa'),
-            (r'\\\Aa', r'/\\a'),
-            (r'\\\\Aa', r'/\\\Aa'),
-            (r'\\\\\Aa', r'/\\\\a'),
-            (r'\\\\\\Aa', r'/\\\\\Aa'),
-            (r'a\\Z', r'/a\Z'),
-            (r'a\\\Z', r'/a\\'),
-            (r'a\\\\Z', r'/a\\\Z'),
-            (r'a\\\\\Z', r'/a\\\\'),
-            (r'a\\\\\\Z', r'/a\\\\\Z'),
+            (r"\^a", r"/^a"),
+            (r"\\^a", r"/\\a"),
+            (r"\\\^a", r"/\\^a"),
+            (r"\\\\^a", r"/\\\\a"),
+            (r"\\\\\^a", r"/\\\\^a"),
+            (r"a\$", r"/a$"),
+            (r"a\\$", r"/a\\"),
+            (r"a\\\$", r"/a\\$"),
+            (r"a\\\\$", r"/a\\\\"),
+            (r"a\\\\\$", r"/a\\\\$"),
+            (r"a\?", r"/a?"),
+            (r"a\\?", r"/a\\"),
+            (r"a\\\?", r"/a\\?"),
+            (r"a\\\\?", r"/a\\\\"),
+            (r"a\\\\\?", r"/a\\\\?"),
+            (r"a\*", r"/a*"),
+            (r"a\\*", r"/a\\"),
+            (r"a\\\*", r"/a\\*"),
+            (r"a\\\\*", r"/a\\\\"),
+            (r"a\\\\\*", r"/a\\\\*"),
+            (r"a\+", r"/a+"),
+            (r"a\\+", r"/a\\"),
+            (r"a\\\+", r"/a\\+"),
+            (r"a\\\\+", r"/a\\\\"),
+            (r"a\\\\\+", r"/a\\\\+"),
+            (r"\\Aa", r"/\Aa"),
+            (r"\\\Aa", r"/\\a"),
+            (r"\\\\Aa", r"/\\\Aa"),
+            (r"\\\\\Aa", r"/\\\\a"),
+            (r"\\\\\\Aa", r"/\\\\\Aa"),
+            (r"a\\Z", r"/a\Z"),
+            (r"a\\\Z", r"/a\\"),
+            (r"a\\\\Z", r"/a\\\Z"),
+            (r"a\\\\\Z", r"/a\\\\"),
+            (r"a\\\\\\Z", r"/a\\\\\Z"),
             # Escaped mixed metacharacters.
-            (r'^a\?$', r'/a?'),
-            (r'^a\\?$', r'/a\\'),
-            (r'^a\\\?$', r'/a\\?'),
-            (r'^a\\\\?$', r'/a\\\\'),
-            (r'^a\\\\\?$', r'/a\\\\?'),
+            (r"^a\?$", r"/a?"),
+            (r"^a\\?$", r"/a\\"),
+            (r"^a\\\?$", r"/a\\?"),
+            (r"^a\\\\?$", r"/a\\\\"),
+            (r"^a\\\\\?$", r"/a\\\\?"),
             # Adjacent escaped metacharacters.
-            (r'^a\?\$', r'/a?$'),
-            (r'^a\\?\\$', r'/a\\\\'),
-            (r'^a\\\?\\\$', r'/a\\?\\$'),
-            (r'^a\\\\?\\\\$', r'/a\\\\\\\\'),
-            (r'^a\\\\\?\\\\\$', r'/a\\\\?\\\\$'),
+            (r"^a\?\$", r"/a?$"),
+            (r"^a\\?\\$", r"/a\\\\"),
+            (r"^a\\\?\\\$", r"/a\\?\\$"),
+            (r"^a\\\\?\\\\$", r"/a\\\\\\\\"),
+            (r"^a\\\\\?\\\\\$", r"/a\\\\?\\\\$"),
             # Complex examples with metacharacters and (un)named groups.
-            (r'^\b(?P<slug>\w+)\B/(\w+)?', '/<slug>/<var>'),
-            (r'^\A(?P<slug>\w+)\Z', '/<slug>'),
+            (r"^\b(?P<slug>\w+)\B/(\w+)?", "/<slug>/<var>"),
+            (r"^\A(?P<slug>\w+)\Z", "/<slug>"),
         )
         for pattern, output in tests:
             with self.subTest(pattern=pattern):
diff --git a/tests/admin_docs/tests.py b/tests/admin_docs/tests.py
index d53cb80c94..3ab2970b90 100644
--- a/tests/admin_docs/tests.py
+++ b/tests/admin_docs/tests.py
@@ -1,23 +1,22 @@
 from django.contrib.auth.models import User
-from django.test import (
-    SimpleTestCase, TestCase, modify_settings, override_settings,
-)
+from django.test import SimpleTestCase, TestCase, modify_settings, override_settings
 
 
 class TestDataMixin:
-
     @classmethod
     def setUpTestData(cls):
-        cls.superuser = User.objects.create_superuser(username='super', password='secret', email='super@example.com')
+        cls.superuser = User.objects.create_superuser(
+            username="super", password="secret", email="super@example.com"
+        )
 
 
-@override_settings(ROOT_URLCONF='admin_docs.urls')
-@modify_settings(INSTALLED_APPS={'append': 'django.contrib.admindocs'})
+@override_settings(ROOT_URLCONF="admin_docs.urls")
+@modify_settings(INSTALLED_APPS={"append": "django.contrib.admindocs"})
 class AdminDocsSimpleTestCase(SimpleTestCase):
     pass
 
 
-@override_settings(ROOT_URLCONF='admin_docs.urls')
-@modify_settings(INSTALLED_APPS={'append': 'django.contrib.admindocs'})
+@override_settings(ROOT_URLCONF="admin_docs.urls")
+@modify_settings(INSTALLED_APPS={"append": "django.contrib.admindocs"})
 class AdminDocsTestCase(TestCase):
     pass
diff --git a/tests/admin_docs/urls.py b/tests/admin_docs/urls.py
index f535afc9f2..de23d9baf5 100644
--- a/tests/admin_docs/urls.py
+++ b/tests/admin_docs/urls.py
@@ -3,16 +3,19 @@ from django.urls import include, path
 
 from . import views
 
-ns_patterns = ([
-    path('xview/func/', views.xview_dec(views.xview), name='func'),
-], 'test')
+ns_patterns = (
+    [
+        path("xview/func/", views.xview_dec(views.xview), name="func"),
+    ],
+    "test",
+)
 
 urlpatterns = [
-    path('admin/', admin.site.urls),
-    path('admindocs/', include('django.contrib.admindocs.urls')),
-    path('', include(ns_patterns, namespace='test')),
-    path('xview/func/', views.xview_dec(views.xview)),
-    path('xview/class/', views.xview_dec(views.XViewClass.as_view())),
-    path('xview/callable_object/', views.xview_dec(views.XViewCallableObject())),
-    path('xview/callable_object_without_xview/', views.XViewCallableObject()),
+    path("admin/", admin.site.urls),
+    path("admindocs/", include("django.contrib.admindocs.urls")),
+    path("", include(ns_patterns, namespace="test")),
+    path("xview/func/", views.xview_dec(views.xview)),
+    path("xview/class/", views.xview_dec(views.XViewClass.as_view())),
+    path("xview/callable_object/", views.xview_dec(views.XViewCallableObject())),
+    path("xview/callable_object_without_xview/", views.XViewCallableObject()),
 ]