Refs #33476 -- Reformatted code with Black.

11 files changed, 325 insertions, 233 deletions

diff --git a/tests/flatpages_tests/absolute_urls.py b/tests/flatpages_tests/absolute_urls.py
index 197aa3d6af..acd9c7c1cf 100644
--- a/tests/flatpages_tests/absolute_urls.py
+++ b/tests/flatpages_tests/absolute_urls.py
@@ -2,5 +2,5 @@ from django.contrib.flatpages import views
 from django.urls import path
 
 urlpatterns = [
-    path('flatpage/', views.flatpage, {'url': '/hardcoded/'}),
+    path("flatpage/", views.flatpage, {"url": "/hardcoded/"}),
 ]
diff --git a/tests/flatpages_tests/no_slash_urls.py b/tests/flatpages_tests/no_slash_urls.py
index 112e6d1638..e7becfa81d 100644
--- a/tests/flatpages_tests/no_slash_urls.py
+++ b/tests/flatpages_tests/no_slash_urls.py
@@ -1,5 +1,5 @@
 from django.urls import include, path
 
 urlpatterns = [
-    path('flatpage', include('django.contrib.flatpages.urls')),
+    path("flatpage", include("django.contrib.flatpages.urls")),
 ]
diff --git a/tests/flatpages_tests/settings.py b/tests/flatpages_tests/settings.py
index ad888f9d95..ea36b2bbee 100644
--- a/tests/flatpages_tests/settings.py
+++ b/tests/flatpages_tests/settings.py
@@ -1,11 +1,11 @@
 import os
 
-FLATPAGES_TEMPLATES = [{
-    'BACKEND': 'django.template.backends.django.DjangoTemplates',
-    'DIRS': [os.path.join(os.path.dirname(__file__), 'templates')],
-    'OPTIONS': {
-        'context_processors': (
-            'django.contrib.auth.context_processors.auth',
-        ),
-    },
-}]
+FLATPAGES_TEMPLATES = [
+    {
+        "BACKEND": "django.template.backends.django.DjangoTemplates",
+        "DIRS": [os.path.join(os.path.dirname(__file__), "templates")],
+        "OPTIONS": {
+            "context_processors": ("django.contrib.auth.context_processors.auth",),
+        },
+    }
+]
diff --git a/tests/flatpages_tests/test_csrf.py b/tests/flatpages_tests/test_csrf.py
index ae2dd9755f..d26546876e 100644
--- a/tests/flatpages_tests/test_csrf.py
+++ b/tests/flatpages_tests/test_csrf.py
@@ -6,45 +6,60 @@ from django.test import Client, TestCase, modify_settings, override_settings
 from .settings import FLATPAGES_TEMPLATES
 
 
-@modify_settings(INSTALLED_APPS={'append': 'django.contrib.flatpages'})
+@modify_settings(INSTALLED_APPS={"append": "django.contrib.flatpages"})
 @override_settings(
-    LOGIN_URL='/accounts/login/',
+    LOGIN_URL="/accounts/login/",
     MIDDLEWARE=[
-        'django.middleware.common.CommonMiddleware',
-        'django.contrib.sessions.middleware.SessionMiddleware',
-        'django.middleware.csrf.CsrfViewMiddleware',
-        'django.contrib.auth.middleware.AuthenticationMiddleware',
-        'django.contrib.messages.middleware.MessageMiddleware',
-        'django.contrib.flatpages.middleware.FlatpageFallbackMiddleware',
+        "django.middleware.common.CommonMiddleware",
+        "django.contrib.sessions.middleware.SessionMiddleware",
+        "django.middleware.csrf.CsrfViewMiddleware",
+        "django.contrib.auth.middleware.AuthenticationMiddleware",
+        "django.contrib.messages.middleware.MessageMiddleware",
+        "django.contrib.flatpages.middleware.FlatpageFallbackMiddleware",
     ],
-    ROOT_URLCONF='flatpages_tests.urls',
-    CSRF_FAILURE_VIEW='django.views.csrf.csrf_failure',
+    ROOT_URLCONF="flatpages_tests.urls",
+    CSRF_FAILURE_VIEW="django.views.csrf.csrf_failure",
     TEMPLATES=FLATPAGES_TEMPLATES,
     SITE_ID=1,
 )
 class FlatpageCSRFTests(TestCase):
-
     @classmethod
     def setUpTestData(cls):
         # don't use the manager because we want to ensure the site exists
         # with pk=1, regardless of whether or not it already exists.
-        cls.site1 = Site(pk=1, domain='example.com', name='example.com')
+        cls.site1 = Site(pk=1, domain="example.com", name="example.com")
         cls.site1.save()
         cls.fp1 = FlatPage.objects.create(
-            url='/flatpage/', title='A Flatpage', content="Isn't it flat!",
-            enable_comments=False, template_name='', registration_required=False
+            url="/flatpage/",
+            title="A Flatpage",
+            content="Isn't it flat!",
+            enable_comments=False,
+            template_name="",
+            registration_required=False,
         )
         cls.fp2 = FlatPage.objects.create(
-            url='/location/flatpage/', title='A Nested Flatpage', content="Isn't it flat and deep!",
-            enable_comments=False, template_name='', registration_required=False
+            url="/location/flatpage/",
+            title="A Nested Flatpage",
+            content="Isn't it flat and deep!",
+            enable_comments=False,
+            template_name="",
+            registration_required=False,
         )
         cls.fp3 = FlatPage.objects.create(
-            url='/sekrit/', title='Sekrit Flatpage', content="Isn't it sekrit!",
-            enable_comments=False, template_name='', registration_required=True
+            url="/sekrit/",
+            title="Sekrit Flatpage",
+            content="Isn't it sekrit!",
+            enable_comments=False,
+            template_name="",
+            registration_required=True,
         )
         cls.fp4 = FlatPage.objects.create(
-            url='/location/sekrit/', title='Sekrit Nested Flatpage', content="Isn't it sekrit and deep!",
-            enable_comments=False, template_name='', registration_required=True
+            url="/location/sekrit/",
+            title="Sekrit Nested Flatpage",
+            content="Isn't it sekrit and deep!",
+            enable_comments=False,
+            template_name="",
+            registration_required=True,
         )
         cls.fp1.sites.add(cls.site1)
         cls.fp2.sites.add(cls.site1)
@@ -56,7 +71,7 @@ class FlatpageCSRFTests(TestCase):
 
     def test_view_flatpage(self):
         "A flatpage can be served through a view, even when the middleware is in use"
-        response = self.client.get('/flatpage_root/flatpage/')
+        response = self.client.get("/flatpage_root/flatpage/")
         self.assertContains(response, "<p>Isn't it flat!</p>")
 
     def test_view_non_existent_flatpage(self):
@@ -64,21 +79,21 @@ class FlatpageCSRFTests(TestCase):
         A nonexistent flatpage raises 404 when served through a view, even when
         the middleware is in use.
         """
-        response = self.client.get('/flatpage_root/no_such_flatpage/')
+        response = self.client.get("/flatpage_root/no_such_flatpage/")
         self.assertEqual(response.status_code, 404)
 
     def test_view_authenticated_flatpage(self):
         "A flatpage served through a view can require authentication"
-        response = self.client.get('/flatpage_root/sekrit/')
-        self.assertRedirects(response, '/accounts/login/?next=/flatpage_root/sekrit/')
-        user = User.objects.create_user('testuser', 'test@example.com', 's3krit')
+        response = self.client.get("/flatpage_root/sekrit/")
+        self.assertRedirects(response, "/accounts/login/?next=/flatpage_root/sekrit/")
+        user = User.objects.create_user("testuser", "test@example.com", "s3krit")
         self.client.force_login(user)
-        response = self.client.get('/flatpage_root/sekrit/')
+        response = self.client.get("/flatpage_root/sekrit/")
         self.assertContains(response, "<p>Isn't it sekrit!</p>")
 
     def test_fallback_flatpage(self):
         "A flatpage can be served by the fallback middleware"
-        response = self.client.get('/flatpage/')
+        response = self.client.get("/flatpage/")
         self.assertContains(response, "<p>Isn't it flat!</p>")
 
     def test_fallback_non_existent_flatpage(self):
@@ -86,20 +101,20 @@ class FlatpageCSRFTests(TestCase):
         A nonexistent flatpage raises a 404 when served by the fallback
         middleware.
         """
-        response = self.client.get('/no_such_flatpage/')
+        response = self.client.get("/no_such_flatpage/")
         self.assertEqual(response.status_code, 404)
 
     def test_post_view_flatpage(self):
         "POSTing to a flatpage served through a view will raise a CSRF error if no token is provided (Refs #14156)"
-        response = self.client.post('/flatpage_root/flatpage/')
+        response = self.client.post("/flatpage_root/flatpage/")
         self.assertEqual(response.status_code, 403)
 
     def test_post_fallback_flatpage(self):
         "POSTing to a flatpage served by the middleware will raise a CSRF error if no token is provided (Refs #14156)"
-        response = self.client.post('/flatpage/')
+        response = self.client.post("/flatpage/")
         self.assertEqual(response.status_code, 403)
 
     def test_post_unknown_page(self):
         "POSTing to an unknown page isn't caught as a 403 CSRF error"
-        response = self.client.post('/no_such_page/')
+        response = self.client.post("/no_such_page/")
         self.assertEqual(response.status_code, 404)
diff --git a/tests/flatpages_tests/test_forms.py b/tests/flatpages_tests/test_forms.py
index e8ba462ec7..7f56549235 100644
--- a/tests/flatpages_tests/test_forms.py
+++ b/tests/flatpages_tests/test_forms.py
@@ -6,15 +6,14 @@ from django.test import TestCase, modify_settings, override_settings
 from django.utils import translation
 
 
-@modify_settings(INSTALLED_APPS={'append': ['django.contrib.flatpages']})
+@modify_settings(INSTALLED_APPS={"append": ["django.contrib.flatpages"]})
 @override_settings(SITE_ID=1)
 class FlatpageAdminFormTests(TestCase):
-
     @classmethod
     def setUpTestData(cls):
         # don't use the manager because we want to ensure the site exists
         # with pk=1, regardless of whether or not it already exists.
-        cls.site1 = Site(pk=1, domain='example.com', name='example.com')
+        cls.site1 = Site(pk=1, domain="example.com", name="example.com")
         cls.site1.save()
 
     def setUp(self):
@@ -22,65 +21,94 @@ class FlatpageAdminFormTests(TestCase):
         # INSTALLED_APPS
         Site._meta._expire_cache()
         self.form_data = {
-            'title': "A test page",
-            'content': "This is a test",
-            'sites': [settings.SITE_ID],
+            "title": "A test page",
+            "content": "This is a test",
+            "sites": [settings.SITE_ID],
         }
 
     def test_flatpage_admin_form_url_validation(self):
         "The flatpage admin form correctly validates urls"
-        self.assertTrue(FlatpageForm(data=dict(url='/new_flatpage/', **self.form_data)).is_valid())
-        self.assertTrue(FlatpageForm(data=dict(url='/some.special~chars/', **self.form_data)).is_valid())
-        self.assertTrue(FlatpageForm(data=dict(url='/some.very_special~chars-here/', **self.form_data)).is_valid())
-
-        self.assertFalse(FlatpageForm(data=dict(url='/a space/', **self.form_data)).is_valid())
-        self.assertFalse(FlatpageForm(data=dict(url='/a % char/', **self.form_data)).is_valid())
-        self.assertFalse(FlatpageForm(data=dict(url='/a ! char/', **self.form_data)).is_valid())
-        self.assertFalse(FlatpageForm(data=dict(url='/a & char/', **self.form_data)).is_valid())
-        self.assertFalse(FlatpageForm(data=dict(url='/a ? char/', **self.form_data)).is_valid())
+        self.assertTrue(
+            FlatpageForm(data=dict(url="/new_flatpage/", **self.form_data)).is_valid()
+        )
+        self.assertTrue(
+            FlatpageForm(
+                data=dict(url="/some.special~chars/", **self.form_data)
+            ).is_valid()
+        )
+        self.assertTrue(
+            FlatpageForm(
+                data=dict(url="/some.very_special~chars-here/", **self.form_data)
+            ).is_valid()
+        )
+
+        self.assertFalse(
+            FlatpageForm(data=dict(url="/a space/", **self.form_data)).is_valid()
+        )
+        self.assertFalse(
+            FlatpageForm(data=dict(url="/a % char/", **self.form_data)).is_valid()
+        )
+        self.assertFalse(
+            FlatpageForm(data=dict(url="/a ! char/", **self.form_data)).is_valid()
+        )
+        self.assertFalse(
+            FlatpageForm(data=dict(url="/a & char/", **self.form_data)).is_valid()
+        )
+        self.assertFalse(
+            FlatpageForm(data=dict(url="/a ? char/", **self.form_data)).is_valid()
+        )
 
     def test_flatpage_requires_leading_slash(self):
-        form = FlatpageForm(data=dict(url='no_leading_slash/', **self.form_data))
-        with translation.override('en'):
+        form = FlatpageForm(data=dict(url="no_leading_slash/", **self.form_data))
+        with translation.override("en"):
             self.assertFalse(form.is_valid())
-            self.assertEqual(form.errors['url'], ["URL is missing a leading slash."])
+            self.assertEqual(form.errors["url"], ["URL is missing a leading slash."])
 
-    @override_settings(APPEND_SLASH=True, MIDDLEWARE=['django.middleware.common.CommonMiddleware'])
+    @override_settings(
+        APPEND_SLASH=True, MIDDLEWARE=["django.middleware.common.CommonMiddleware"]
+    )
     def test_flatpage_requires_trailing_slash_with_append_slash(self):
-        form = FlatpageForm(data=dict(url='/no_trailing_slash', **self.form_data))
-        with translation.override('en'):
+        form = FlatpageForm(data=dict(url="/no_trailing_slash", **self.form_data))
+        with translation.override("en"):
             self.assertEqual(
-                form.fields['url'].help_text,
-                'Example: “/about/contact/”. Make sure to have leading and '
-                'trailing slashes.'
+                form.fields["url"].help_text,
+                "Example: “/about/contact/”. Make sure to have leading and "
+                "trailing slashes.",
             )
             self.assertFalse(form.is_valid())
-            self.assertEqual(form.errors['url'], ["URL is missing a trailing slash."])
+            self.assertEqual(form.errors["url"], ["URL is missing a trailing slash."])
 
-    @override_settings(APPEND_SLASH=False, MIDDLEWARE=['django.middleware.common.CommonMiddleware'])
+    @override_settings(
+        APPEND_SLASH=False, MIDDLEWARE=["django.middleware.common.CommonMiddleware"]
+    )
     def test_flatpage_doesnt_requires_trailing_slash_without_append_slash(self):
-        form = FlatpageForm(data=dict(url='/no_trailing_slash', **self.form_data))
+        form = FlatpageForm(data=dict(url="/no_trailing_slash", **self.form_data))
         self.assertTrue(form.is_valid())
-        with translation.override('en'):
+        with translation.override("en"):
             self.assertEqual(
-                form.fields['url'].help_text,
-                'Example: “/about/contact”. Make sure to have a leading slash.'
+                form.fields["url"].help_text,
+                "Example: “/about/contact”. Make sure to have a leading slash.",
             )
 
     def test_flatpage_admin_form_url_uniqueness_validation(self):
         "The flatpage admin form correctly enforces url uniqueness among flatpages of the same site"
-        data = dict(url='/myflatpage1/', **self.form_data)
+        data = dict(url="/myflatpage1/", **self.form_data)
 
         FlatpageForm(data=data).save()
 
         f = FlatpageForm(data=data)
 
-        with translation.override('en'):
+        with translation.override("en"):
             self.assertFalse(f.is_valid())
 
             self.assertEqual(
                 f.errors,
-                {'__all__': ['Flatpage with url /myflatpage1/ already exists for site example.com']})
+                {
+                    "__all__": [
+                        "Flatpage with url /myflatpage1/ already exists for site example.com"
+                    ]
+                },
+            )
 
     def test_flatpage_admin_form_edit(self):
         """
@@ -88,10 +116,11 @@ class FlatpageAdminFormTests(TestCase):
         the url-uniqueness validation.
         """
         existing = FlatPage.objects.create(
-            url="/myflatpage1/", title="Some page", content="The content")
+            url="/myflatpage1/", title="Some page", content="The content"
+        )
         existing.sites.add(settings.SITE_ID)
 
-        data = dict(url='/myflatpage1/', **self.form_data)
+        data = dict(url="/myflatpage1/", **self.form_data)
 
         f = FlatpageForm(data=data, instance=existing)
 
@@ -102,11 +131,13 @@ class FlatpageAdminFormTests(TestCase):
         self.assertEqual(updated.title, "A test page")
 
     def test_flatpage_nosites(self):
-        data = dict(url='/myflatpage1/', **self.form_data)
-        data.update({'sites': ''})
+        data = dict(url="/myflatpage1/", **self.form_data)
+        data.update({"sites": ""})
 
         f = FlatpageForm(data=data)
 
         self.assertFalse(f.is_valid())
 
-        self.assertEqual(f.errors, {'sites': [translation.gettext('This field is required.')]})
+        self.assertEqual(
+            f.errors, {"sites": [translation.gettext("This field is required.")]}
+        )
diff --git a/tests/flatpages_tests/test_middleware.py b/tests/flatpages_tests/test_middleware.py
index 22e4c2ba31..193c8232bf 100644
--- a/tests/flatpages_tests/test_middleware.py
+++ b/tests/flatpages_tests/test_middleware.py
@@ -8,28 +8,43 @@ from .settings import FLATPAGES_TEMPLATES
 
 
 class TestDataMixin:
-
     @classmethod
     def setUpTestData(cls):
         # don't use the manager because we want to ensure the site exists
         # with pk=1, regardless of whether or not it already exists.
-        cls.site1 = Site(pk=1, domain='example.com', name='example.com')
+        cls.site1 = Site(pk=1, domain="example.com", name="example.com")
         cls.site1.save()
         cls.fp1 = FlatPage.objects.create(
-            url='/flatpage/', title='A Flatpage', content="Isn't it flat!",
-            enable_comments=False, template_name='', registration_required=False
+            url="/flatpage/",
+            title="A Flatpage",
+            content="Isn't it flat!",
+            enable_comments=False,
+            template_name="",
+            registration_required=False,
         )
         cls.fp2 = FlatPage.objects.create(
-            url='/location/flatpage/', title='A Nested Flatpage', content="Isn't it flat and deep!",
-            enable_comments=False, template_name='', registration_required=False
+            url="/location/flatpage/",
+            title="A Nested Flatpage",
+            content="Isn't it flat and deep!",
+            enable_comments=False,
+            template_name="",
+            registration_required=False,
         )
         cls.fp3 = FlatPage.objects.create(
-            url='/sekrit/', title='Sekrit Flatpage', content="Isn't it sekrit!",
-            enable_comments=False, template_name='', registration_required=True
+            url="/sekrit/",
+            title="Sekrit Flatpage",
+            content="Isn't it sekrit!",
+            enable_comments=False,
+            template_name="",
+            registration_required=True,
         )
         cls.fp4 = FlatPage.objects.create(
-            url='/location/sekrit/', title='Sekrit Nested Flatpage', content="Isn't it sekrit and deep!",
-            enable_comments=False, template_name='', registration_required=True
+            url="/location/sekrit/",
+            title="Sekrit Nested Flatpage",
+            content="Isn't it sekrit and deep!",
+            enable_comments=False,
+            template_name="",
+            registration_required=True,
         )
         cls.fp1.sites.add(cls.site1)
         cls.fp2.sites.add(cls.site1)
@@ -37,26 +52,25 @@ class TestDataMixin:
         cls.fp4.sites.add(cls.site1)
 
 
-@modify_settings(INSTALLED_APPS={'append': 'django.contrib.flatpages'})
+@modify_settings(INSTALLED_APPS={"append": "django.contrib.flatpages"})
 @override_settings(
-    LOGIN_URL='/accounts/login/',
+    LOGIN_URL="/accounts/login/",
     MIDDLEWARE=[
-        'django.middleware.common.CommonMiddleware',
-        'django.contrib.sessions.middleware.SessionMiddleware',
-        'django.middleware.csrf.CsrfViewMiddleware',
-        'django.contrib.auth.middleware.AuthenticationMiddleware',
-        'django.contrib.messages.middleware.MessageMiddleware',
-        'django.contrib.flatpages.middleware.FlatpageFallbackMiddleware',
+        "django.middleware.common.CommonMiddleware",
+        "django.contrib.sessions.middleware.SessionMiddleware",
+        "django.middleware.csrf.CsrfViewMiddleware",
+        "django.contrib.auth.middleware.AuthenticationMiddleware",
+        "django.contrib.messages.middleware.MessageMiddleware",
+        "django.contrib.flatpages.middleware.FlatpageFallbackMiddleware",
     ],
-    ROOT_URLCONF='flatpages_tests.urls',
+    ROOT_URLCONF="flatpages_tests.urls",
     TEMPLATES=FLATPAGES_TEMPLATES,
     SITE_ID=1,
 )
 class FlatpageMiddlewareTests(TestDataMixin, TestCase):
-
     def test_view_flatpage(self):
         "A flatpage can be served through a view, even when the middleware is in use"
-        response = self.client.get('/flatpage_root/flatpage/')
+        response = self.client.get("/flatpage_root/flatpage/")
         self.assertContains(response, "<p>Isn't it flat!</p>")
 
     def test_view_non_existent_flatpage(self):
@@ -64,21 +78,21 @@ class FlatpageMiddlewareTests(TestDataMixin, TestCase):
         A nonexistent flatpage raises 404 when served through a view, even when
         the middleware is in use.
         """
-        response = self.client.get('/flatpage_root/no_such_flatpage/')
+        response = self.client.get("/flatpage_root/no_such_flatpage/")
         self.assertEqual(response.status_code, 404)
 
     def test_view_authenticated_flatpage(self):
         "A flatpage served through a view can require authentication"
-        response = self.client.get('/flatpage_root/sekrit/')
-        self.assertRedirects(response, '/accounts/login/?next=/flatpage_root/sekrit/')
-        user = User.objects.create_user('testuser', 'test@example.com', 's3krit')
+        response = self.client.get("/flatpage_root/sekrit/")
+        self.assertRedirects(response, "/accounts/login/?next=/flatpage_root/sekrit/")
+        user = User.objects.create_user("testuser", "test@example.com", "s3krit")
         self.client.force_login(user)
-        response = self.client.get('/flatpage_root/sekrit/')
+        response = self.client.get("/flatpage_root/sekrit/")
         self.assertContains(response, "<p>Isn't it sekrit!</p>")
 
     def test_fallback_flatpage(self):
         "A flatpage can be served by the fallback middleware"
-        response = self.client.get('/flatpage/')
+        response = self.client.get("/flatpage/")
         self.assertContains(response, "<p>Isn't it flat!</p>")
 
     def test_fallback_non_existent_flatpage(self):
@@ -86,16 +100,16 @@ class FlatpageMiddlewareTests(TestDataMixin, TestCase):
         A nonexistent flatpage raises a 404 when served by the fallback
         middleware.
         """
-        response = self.client.get('/no_such_flatpage/')
+        response = self.client.get("/no_such_flatpage/")
         self.assertEqual(response.status_code, 404)
 
     def test_fallback_authenticated_flatpage(self):
         "A flatpage served by the middleware can require authentication"
-        response = self.client.get('/sekrit/')
-        self.assertRedirects(response, '/accounts/login/?next=/sekrit/')
-        user = User.objects.create_user('testuser', 'test@example.com', 's3krit')
+        response = self.client.get("/sekrit/")
+        self.assertRedirects(response, "/accounts/login/?next=/sekrit/")
+        user = User.objects.create_user("testuser", "test@example.com", "s3krit")
         self.client.force_login(user)
-        response = self.client.get('/sekrit/')
+        response = self.client.get("/sekrit/")
         self.assertContains(response, "<p>Isn't it sekrit!</p>")
 
     def test_fallback_flatpage_special_chars(self):
@@ -109,52 +123,51 @@ class FlatpageMiddlewareTests(TestDataMixin, TestCase):
         )
         fp.sites.add(settings.SITE_ID)
 
-        response = self.client.get('/some.very_special~chars-here/')
+        response = self.client.get("/some.very_special~chars-here/")
         self.assertContains(response, "<p>Isn't it special!</p>")
 
 
-@modify_settings(INSTALLED_APPS={'append': 'django.contrib.flatpages'})
+@modify_settings(INSTALLED_APPS={"append": "django.contrib.flatpages"})
 @override_settings(
     APPEND_SLASH=True,
-    LOGIN_URL='/accounts/login/',
+    LOGIN_URL="/accounts/login/",
     MIDDLEWARE=[
-        'django.middleware.common.CommonMiddleware',
-        'django.contrib.sessions.middleware.SessionMiddleware',
-        'django.middleware.csrf.CsrfViewMiddleware',
-        'django.contrib.auth.middleware.AuthenticationMiddleware',
-        'django.contrib.messages.middleware.MessageMiddleware',
-        'django.contrib.flatpages.middleware.FlatpageFallbackMiddleware',
+        "django.middleware.common.CommonMiddleware",
+        "django.contrib.sessions.middleware.SessionMiddleware",
+        "django.middleware.csrf.CsrfViewMiddleware",
+        "django.contrib.auth.middleware.AuthenticationMiddleware",
+        "django.contrib.messages.middleware.MessageMiddleware",
+        "django.contrib.flatpages.middleware.FlatpageFallbackMiddleware",
     ],
-    ROOT_URLCONF='flatpages_tests.urls',
+    ROOT_URLCONF="flatpages_tests.urls",
     TEMPLATES=FLATPAGES_TEMPLATES,
     SITE_ID=1,
 )
 class FlatpageMiddlewareAppendSlashTests(TestDataMixin, TestCase):
-
     def test_redirect_view_flatpage(self):
         "A flatpage can be served through a view and should add a slash"
-        response = self.client.get('/flatpage_root/flatpage')
-        self.assertRedirects(response, '/flatpage_root/flatpage/', status_code=301)
+        response = self.client.get("/flatpage_root/flatpage")
+        self.assertRedirects(response, "/flatpage_root/flatpage/", status_code=301)
 
     def test_redirect_view_non_existent_flatpage(self):
         """
         A nonexistent flatpage raises 404 when served through a view and
         should not add a slash.
         """
-        response = self.client.get('/flatpage_root/no_such_flatpage')
+        response = self.client.get("/flatpage_root/no_such_flatpage")
         self.assertEqual(response.status_code, 404)
 
     def test_redirect_fallback_flatpage(self):
         "A flatpage can be served by the fallback middleware and should add a slash"
-        response = self.client.get('/flatpage')
-        self.assertRedirects(response, '/flatpage/', status_code=301)
+        response = self.client.get("/flatpage")
+        self.assertRedirects(response, "/flatpage/", status_code=301)
 
     def test_redirect_fallback_non_existent_flatpage(self):
         """
         A nonexistent flatpage raises a 404 when served by the fallback
         middleware and should not add a slash.
         """
-        response = self.client.get('/no_such_flatpage')
+        response = self.client.get("/no_such_flatpage")
         self.assertEqual(response.status_code, 404)
 
     def test_redirect_fallback_flatpage_special_chars(self):
@@ -168,8 +181,10 @@ class FlatpageMiddlewareAppendSlashTests(TestDataMixin, TestCase):
         )
         fp.sites.add(settings.SITE_ID)
 
-        response = self.client.get('/some.very_special~chars-here')
-        self.assertRedirects(response, '/some.very_special~chars-here/', status_code=301)
+        response = self.client.get("/some.very_special~chars-here")
+        self.assertRedirects(
+            response, "/some.very_special~chars-here/", status_code=301
+        )
 
     def test_redirect_fallback_flatpage_root(self):
         "A flatpage at / should not cause a redirect loop when APPEND_SLASH is set"
@@ -182,5 +197,5 @@ class FlatpageMiddlewareAppendSlashTests(TestDataMixin, TestCase):
         )
         fp.sites.add(settings.SITE_ID)
 
-        response = self.client.get('/')
+        response = self.client.get("/")
         self.assertContains(response, "<p>Root</p>")
diff --git a/tests/flatpages_tests/test_models.py b/tests/flatpages_tests/test_models.py
index 4f59c29f6f..95178d9626 100644
--- a/tests/flatpages_tests/test_models.py
+++ b/tests/flatpages_tests/test_models.py
@@ -4,29 +4,28 @@ from django.test.utils import override_script_prefix
 
 
 class FlatpageModelTests(SimpleTestCase):
-
     def setUp(self):
-        self.page = FlatPage(title='Café!', url='/café/')
+        self.page = FlatPage(title="Café!", url="/café/")
 
     def test_get_absolute_url_urlencodes(self):
-        self.assertEqual(self.page.get_absolute_url(), '/caf%C3%A9/')
+        self.assertEqual(self.page.get_absolute_url(), "/caf%C3%A9/")
 
-    @override_script_prefix('/prefix/')
+    @override_script_prefix("/prefix/")
     def test_get_absolute_url_honors_script_prefix(self):
-        self.assertEqual(self.page.get_absolute_url(), '/prefix/caf%C3%A9/')
+        self.assertEqual(self.page.get_absolute_url(), "/prefix/caf%C3%A9/")
 
     def test_str(self):
-        self.assertEqual(str(self.page), '/café/ -- Café!')
+        self.assertEqual(str(self.page), "/café/ -- Café!")
 
-    @override_settings(ROOT_URLCONF='flatpages_tests.urls')
+    @override_settings(ROOT_URLCONF="flatpages_tests.urls")
     def test_get_absolute_url_include(self):
-        self.assertEqual(self.page.get_absolute_url(), '/flatpage_root/caf%C3%A9/')
+        self.assertEqual(self.page.get_absolute_url(), "/flatpage_root/caf%C3%A9/")
 
-    @override_settings(ROOT_URLCONF='flatpages_tests.no_slash_urls')
+    @override_settings(ROOT_URLCONF="flatpages_tests.no_slash_urls")
     def test_get_absolute_url_include_no_slash(self):
-        self.assertEqual(self.page.get_absolute_url(), '/flatpagecaf%C3%A9/')
+        self.assertEqual(self.page.get_absolute_url(), "/flatpagecaf%C3%A9/")
 
-    @override_settings(ROOT_URLCONF='flatpages_tests.absolute_urls')
+    @override_settings(ROOT_URLCONF="flatpages_tests.absolute_urls")
     def test_get_absolute_url_with_hardcoded_url(self):
-        fp = FlatPage(title='Test', url='/hardcoded/')
-        self.assertEqual(fp.get_absolute_url(), '/flatpage/')
+        fp = FlatPage(title="Test", url="/hardcoded/")
+        self.assertEqual(fp.get_absolute_url(), "/flatpage/")
diff --git a/tests/flatpages_tests/test_sitemaps.py b/tests/flatpages_tests/test_sitemaps.py
index 857dbb86a8..abb3e9dba6 100644
--- a/tests/flatpages_tests/test_sitemaps.py
+++ b/tests/flatpages_tests/test_sitemaps.py
@@ -5,16 +5,15 @@ from django.test.utils import modify_settings, override_settings
 
 
 @override_settings(
-    ROOT_URLCONF='flatpages_tests.urls',
+    ROOT_URLCONF="flatpages_tests.urls",
     SITE_ID=1,
 )
 @modify_settings(
     INSTALLED_APPS={
-        'append': ['django.contrib.sitemaps', 'django.contrib.flatpages'],
+        "append": ["django.contrib.sitemaps", "django.contrib.flatpages"],
     },
 )
 class FlatpagesSitemapTests(TestCase):
-
     @classmethod
     def setUpClass(cls):
         super().setUpClass()
@@ -24,15 +23,20 @@ class FlatpagesSitemapTests(TestCase):
 
     @classmethod
     def setUpTestData(cls):
-        Site = apps.get_model('sites.Site')
+        Site = apps.get_model("sites.Site")
         current_site = Site.objects.get_current()
         current_site.flatpage_set.create(url="/foo/", title="foo")
-        current_site.flatpage_set.create(url="/private-foo/", title="private foo", registration_required=True)
+        current_site.flatpage_set.create(
+            url="/private-foo/", title="private foo", registration_required=True
+        )
 
     def test_flatpage_sitemap(self):
-        response = self.client.get('/flatpages/sitemap.xml')
-        self.assertIn(b'<url><loc>http://example.com/flatpage_root/foo/</loc></url>', response.getvalue())
+        response = self.client.get("/flatpages/sitemap.xml")
+        self.assertIn(
+            b"<url><loc>http://example.com/flatpage_root/foo/</loc></url>",
+            response.getvalue(),
+        )
         self.assertNotIn(
-            b'<url><loc>http://example.com/flatpage_root/private-foo/</loc></url>',
+            b"<url><loc>http://example.com/flatpage_root/private-foo/</loc></url>",
             response.getvalue(),
         )
diff --git a/tests/flatpages_tests/test_templatetags.py b/tests/flatpages_tests/test_templatetags.py
index 1ce8f65079..1c7bc4d38a 100644
--- a/tests/flatpages_tests/test_templatetags.py
+++ b/tests/flatpages_tests/test_templatetags.py
@@ -6,28 +6,43 @@ from django.test import TestCase
 
 
 class FlatpageTemplateTagTests(TestCase):
-
     @classmethod
     def setUpTestData(cls):
         # don't use the manager because we want to ensure the site exists
         # with pk=1, regardless of whether or not it already exists.
-        cls.site1 = Site(pk=1, domain='example.com', name='example.com')
+        cls.site1 = Site(pk=1, domain="example.com", name="example.com")
         cls.site1.save()
         cls.fp1 = FlatPage.objects.create(
-            url='/flatpage/', title='A Flatpage', content="Isn't it flat!",
-            enable_comments=False, template_name='', registration_required=False
+            url="/flatpage/",
+            title="A Flatpage",
+            content="Isn't it flat!",
+            enable_comments=False,
+            template_name="",
+            registration_required=False,
         )
         cls.fp2 = FlatPage.objects.create(
-            url='/location/flatpage/', title='A Nested Flatpage', content="Isn't it flat and deep!",
-            enable_comments=False, template_name='', registration_required=False
+            url="/location/flatpage/",
+            title="A Nested Flatpage",
+            content="Isn't it flat and deep!",
+            enable_comments=False,
+            template_name="",
+            registration_required=False,
         )
         cls.fp3 = FlatPage.objects.create(
-            url='/sekrit/', title='Sekrit Flatpage', content="Isn't it sekrit!",
-            enable_comments=False, template_name='', registration_required=True
+            url="/sekrit/",
+            title="Sekrit Flatpage",
+            content="Isn't it sekrit!",
+            enable_comments=False,
+            template_name="",
+            registration_required=True,
         )
         cls.fp4 = FlatPage.objects.create(
-            url='/location/sekrit/', title='Sekrit Nested Flatpage', content="Isn't it sekrit and deep!",
-            enable_comments=False, template_name='', registration_required=True
+            url="/location/sekrit/",
+            title="Sekrit Nested Flatpage",
+            content="Isn't it sekrit and deep!",
+            enable_comments=False,
+            template_name="",
+            registration_required=True,
         )
         cls.fp1.sites.add(cls.site1)
         cls.fp2.sites.add(cls.site1)
@@ -53,24 +68,22 @@ class FlatpageTemplateTagTests(TestCase):
             "{% for page in flatpages %}"
             "{{ page.title }},"
             "{% endfor %}"
-        ).render(Context({
-            'anonuser': AnonymousUser()
-        }))
+        ).render(Context({"anonuser": AnonymousUser()}))
         self.assertEqual(out, "A Flatpage,A Nested Flatpage,")
 
     def test_get_flatpages_tag_for_user(self):
         "The flatpage template tag retrieves all flatpages for an authenticated user"
-        me = User.objects.create_user('testuser', 'test@example.com', 's3krit')
+        me = User.objects.create_user("testuser", "test@example.com", "s3krit")
         out = Template(
             "{% load flatpages %}"
             "{% get_flatpages for me as flatpages %}"
             "{% for page in flatpages %}"
             "{{ page.title }},"
             "{% endfor %}"
-        ).render(Context({
-            'me': me
-        }))
-        self.assertEqual(out, "A Flatpage,A Nested Flatpage,Sekrit Nested Flatpage,Sekrit Flatpage,")
+        ).render(Context({"me": me}))
+        self.assertEqual(
+            out, "A Flatpage,A Nested Flatpage,Sekrit Nested Flatpage,Sekrit Flatpage,"
+        )
 
     def test_get_flatpages_with_prefix(self):
         "The flatpage template tag retrieves unregistered prefixed flatpages by default"
@@ -91,23 +104,19 @@ class FlatpageTemplateTagTests(TestCase):
             "{% for page in location_flatpages %}"
             "{{ page.title }},"
             "{% endfor %}"
-        ).render(Context({
-            'anonuser': AnonymousUser()
-        }))
+        ).render(Context({"anonuser": AnonymousUser()}))
         self.assertEqual(out, "A Nested Flatpage,")
 
     def test_get_flatpages_with_prefix_for_user(self):
         "The flatpage template tag retrieve prefixed flatpages for an authenticated user"
-        me = User.objects.create_user('testuser', 'test@example.com', 's3krit')
+        me = User.objects.create_user("testuser", "test@example.com", "s3krit")
         out = Template(
             "{% load flatpages %}"
             "{% get_flatpages '/location/' for me as location_flatpages %}"
             "{% for page in location_flatpages %}"
             "{{ page.title }},"
             "{% endfor %}"
-        ).render(Context({
-            'me': me
-        }))
+        ).render(Context({"me": me}))
         self.assertEqual(out, "A Nested Flatpage,Sekrit Nested Flatpage,")
 
     def test_get_flatpages_with_variable_prefix(self):
@@ -118,13 +127,12 @@ class FlatpageTemplateTagTests(TestCase):
             "{% for page in location_flatpages %}"
             "{{ page.title }},"
             "{% endfor %}"
-        ).render(Context({
-            'location_prefix': '/location/'
-        }))
+        ).render(Context({"location_prefix": "/location/"}))
         self.assertEqual(out, "A Nested Flatpage,")
 
     def test_parsing_errors(self):
         "There are various ways that the flatpages template tag won't parse"
+
         def render(t):
             return Template(t).render(Context())
 
@@ -141,8 +149,12 @@ class FlatpageTemplateTagTests(TestCase):
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
             render("{% load flatpages %}{% get_flatpages as flatpages asdf %}")
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            render("{% load flatpages %}{% get_flatpages cheesecake user as flatpages %}")
+            render(
+                "{% load flatpages %}{% get_flatpages cheesecake user as flatpages %}"
+            )
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
             render("{% load flatpages %}{% get_flatpages for user as flatpages asdf %}")
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            render("{% load flatpages %}{% get_flatpages prefix for user as flatpages asdf %}")
+            render(
+                "{% load flatpages %}{% get_flatpages prefix for user as flatpages asdf %}"
+            )
diff --git a/tests/flatpages_tests/test_views.py b/tests/flatpages_tests/test_views.py
index 57b05debb4..2a01587a7a 100644
--- a/tests/flatpages_tests/test_views.py
+++ b/tests/flatpages_tests/test_views.py
@@ -8,28 +8,43 @@ from .settings import FLATPAGES_TEMPLATES
 
 
 class TestDataMixin:
-
     @classmethod
     def setUpTestData(cls):
         # don't use the manager because we want to ensure the site exists
         # with pk=1, regardless of whether or not it already exists.
-        cls.site1 = Site(pk=1, domain='example.com', name='example.com')
+        cls.site1 = Site(pk=1, domain="example.com", name="example.com")
         cls.site1.save()
         cls.fp1 = FlatPage.objects.create(
-            url='/flatpage/', title='A Flatpage', content="Isn't it flat!",
-            enable_comments=False, template_name='', registration_required=False
+            url="/flatpage/",
+            title="A Flatpage",
+            content="Isn't it flat!",
+            enable_comments=False,
+            template_name="",
+            registration_required=False,
         )
         cls.fp2 = FlatPage.objects.create(
-            url='/location/flatpage/', title='A Nested Flatpage', content="Isn't it flat and deep!",
-            enable_comments=False, template_name='', registration_required=False
+            url="/location/flatpage/",
+            title="A Nested Flatpage",
+            content="Isn't it flat and deep!",
+            enable_comments=False,
+            template_name="",
+            registration_required=False,
         )
         cls.fp3 = FlatPage.objects.create(
-            url='/sekrit/', title='Sekrit Flatpage', content="Isn't it sekrit!",
-            enable_comments=False, template_name='', registration_required=True
+            url="/sekrit/",
+            title="Sekrit Flatpage",
+            content="Isn't it sekrit!",
+            enable_comments=False,
+            template_name="",
+            registration_required=True,
         )
         cls.fp4 = FlatPage.objects.create(
-            url='/location/sekrit/', title='Sekrit Nested Flatpage', content="Isn't it sekrit and deep!",
-            enable_comments=False, template_name='', registration_required=True
+            url="/location/sekrit/",
+            title="Sekrit Nested Flatpage",
+            content="Isn't it sekrit and deep!",
+            enable_comments=False,
+            template_name="",
+            registration_required=True,
         )
         cls.fp1.sites.add(cls.site1)
         cls.fp2.sites.add(cls.site1)
@@ -37,45 +52,44 @@ class TestDataMixin:
         cls.fp4.sites.add(cls.site1)
 
 
-@modify_settings(INSTALLED_APPS={'append': 'django.contrib.flatpages'})
+@modify_settings(INSTALLED_APPS={"append": "django.contrib.flatpages"})
 @override_settings(
-    LOGIN_URL='/accounts/login/',
+    LOGIN_URL="/accounts/login/",
     MIDDLEWARE=[
-        'django.middleware.common.CommonMiddleware',
-        'django.contrib.sessions.middleware.SessionMiddleware',
-        'django.middleware.csrf.CsrfViewMiddleware',
-        'django.contrib.auth.middleware.AuthenticationMiddleware',
-        'django.contrib.messages.middleware.MessageMiddleware',
+        "django.middleware.common.CommonMiddleware",
+        "django.contrib.sessions.middleware.SessionMiddleware",
+        "django.middleware.csrf.CsrfViewMiddleware",
+        "django.contrib.auth.middleware.AuthenticationMiddleware",
+        "django.contrib.messages.middleware.MessageMiddleware",
         # no 'django.contrib.flatpages.middleware.FlatpageFallbackMiddleware'
     ],
-    ROOT_URLCONF='flatpages_tests.urls',
+    ROOT_URLCONF="flatpages_tests.urls",
     TEMPLATES=FLATPAGES_TEMPLATES,
     SITE_ID=1,
 )
 class FlatpageViewTests(TestDataMixin, TestCase):
-
     def test_view_flatpage(self):
         "A flatpage can be served through a view"
-        response = self.client.get('/flatpage_root/flatpage/')
+        response = self.client.get("/flatpage_root/flatpage/")
         self.assertContains(response, "<p>Isn't it flat!</p>")
 
     def test_view_non_existent_flatpage(self):
         """A nonexistent flatpage raises 404 when served through a view."""
-        response = self.client.get('/flatpage_root/no_such_flatpage/')
+        response = self.client.get("/flatpage_root/no_such_flatpage/")
         self.assertEqual(response.status_code, 404)
 
     def test_view_authenticated_flatpage(self):
         "A flatpage served through a view can require authentication"
-        response = self.client.get('/flatpage_root/sekrit/')
-        self.assertRedirects(response, '/accounts/login/?next=/flatpage_root/sekrit/')
-        user = User.objects.create_user('testuser', 'test@example.com', 's3krit')
+        response = self.client.get("/flatpage_root/sekrit/")
+        self.assertRedirects(response, "/accounts/login/?next=/flatpage_root/sekrit/")
+        user = User.objects.create_user("testuser", "test@example.com", "s3krit")
         self.client.force_login(user)
-        response = self.client.get('/flatpage_root/sekrit/')
+        response = self.client.get("/flatpage_root/sekrit/")
         self.assertContains(response, "<p>Isn't it sekrit!</p>")
 
     def test_fallback_flatpage(self):
         "A fallback flatpage won't be served if the middleware is disabled"
-        response = self.client.get('/flatpage/')
+        response = self.client.get("/flatpage/")
         self.assertEqual(response.status_code, 404)
 
     def test_fallback_non_existent_flatpage(self):
@@ -83,7 +97,7 @@ class FlatpageViewTests(TestDataMixin, TestCase):
         A nonexistent flatpage won't be served if the fallback middleware is
         disabled.
         """
-        response = self.client.get('/no_such_flatpage/')
+        response = self.client.get("/no_such_flatpage/")
         self.assertEqual(response.status_code, 404)
 
     def test_view_flatpage_special_chars(self):
@@ -97,44 +111,43 @@ class FlatpageViewTests(TestDataMixin, TestCase):
         )
         fp.sites.add(settings.SITE_ID)
 
-        response = self.client.get('/flatpage_root/some.very_special~chars-here/')
+        response = self.client.get("/flatpage_root/some.very_special~chars-here/")
         self.assertContains(response, "<p>Isn't it special!</p>")
 
 
-@modify_settings(INSTALLED_APPS={'append': 'django.contrib.flatpages'})
+@modify_settings(INSTALLED_APPS={"append": "django.contrib.flatpages"})
 @override_settings(
     APPEND_SLASH=True,
-    LOGIN_URL='/accounts/login/',
+    LOGIN_URL="/accounts/login/",
     MIDDLEWARE=[
-        'django.middleware.common.CommonMiddleware',
-        'django.contrib.sessions.middleware.SessionMiddleware',
-        'django.middleware.csrf.CsrfViewMiddleware',
-        'django.contrib.auth.middleware.AuthenticationMiddleware',
-        'django.contrib.messages.middleware.MessageMiddleware',
+        "django.middleware.common.CommonMiddleware",
+        "django.contrib.sessions.middleware.SessionMiddleware",
+        "django.middleware.csrf.CsrfViewMiddleware",
+        "django.contrib.auth.middleware.AuthenticationMiddleware",
+        "django.contrib.messages.middleware.MessageMiddleware",
         # no 'django.contrib.flatpages.middleware.FlatpageFallbackMiddleware'
     ],
-    ROOT_URLCONF='flatpages_tests.urls',
+    ROOT_URLCONF="flatpages_tests.urls",
     TEMPLATES=FLATPAGES_TEMPLATES,
     SITE_ID=1,
 )
 class FlatpageViewAppendSlashTests(TestDataMixin, TestCase):
-
     def test_redirect_view_flatpage(self):
         "A flatpage can be served through a view and should add a slash"
-        response = self.client.get('/flatpage_root/flatpage')
-        self.assertRedirects(response, '/flatpage_root/flatpage/', status_code=301)
+        response = self.client.get("/flatpage_root/flatpage")
+        self.assertRedirects(response, "/flatpage_root/flatpage/", status_code=301)
 
     def test_redirect_view_non_existent_flatpage(self):
         """
         A nonexistent flatpage raises 404 when served through a view and
         should not add a slash.
         """
-        response = self.client.get('/flatpage_root/no_such_flatpage')
+        response = self.client.get("/flatpage_root/no_such_flatpage")
         self.assertEqual(response.status_code, 404)
 
     def test_redirect_fallback_flatpage(self):
         "A fallback flatpage won't be served if the middleware is disabled and should not add a slash"
-        response = self.client.get('/flatpage')
+        response = self.client.get("/flatpage")
         self.assertEqual(response.status_code, 404)
 
     def test_redirect_fallback_non_existent_flatpage(self):
@@ -142,7 +155,7 @@ class FlatpageViewAppendSlashTests(TestDataMixin, TestCase):
         A nonexistent flatpage won't be served if the fallback middleware is
         disabled and should not add a slash.
         """
-        response = self.client.get('/no_such_flatpage')
+        response = self.client.get("/no_such_flatpage")
         self.assertEqual(response.status_code, 404)
 
     def test_redirect_view_flatpage_special_chars(self):
@@ -156,5 +169,7 @@ class FlatpageViewAppendSlashTests(TestDataMixin, TestCase):
         )
         fp.sites.add(settings.SITE_ID)
 
-        response = self.client.get('/flatpage_root/some.very_special~chars-here')
-        self.assertRedirects(response, '/flatpage_root/some.very_special~chars-here/', status_code=301)
+        response = self.client.get("/flatpage_root/some.very_special~chars-here")
+        self.assertRedirects(
+            response, "/flatpage_root/some.very_special~chars-here/", status_code=301
+        )
diff --git a/tests/flatpages_tests/urls.py b/tests/flatpages_tests/urls.py
index 3889ebeef1..63c8e271a1 100644
--- a/tests/flatpages_tests/urls.py
+++ b/tests/flatpages_tests/urls.py
@@ -4,10 +4,11 @@ from django.urls import include, path
 
 urlpatterns = [
     path(
-        'flatpages/sitemap.xml', views.sitemap,
-        {'sitemaps': {'flatpages': FlatPageSitemap}},
-        name='django.contrib.sitemaps.views.sitemap'),
-
-    path('flatpage_root/', include('django.contrib.flatpages.urls')),
-    path('accounts/', include('django.contrib.auth.urls')),
+        "flatpages/sitemap.xml",
+        views.sitemap,
+        {"sitemaps": {"flatpages": FlatPageSitemap}},
+        name="django.contrib.sitemaps.views.sitemap",
+    ),
+    path("flatpage_root/", include("django.contrib.flatpages.urls")),
+    path("accounts/", include("django.contrib.auth.urls")),
 ]