Refs #33476 -- Reformatted code with Black.

5 files changed, 536 insertions, 326 deletions

diff --git a/tests/timezones/admin.py b/tests/timezones/admin.py
index 4d3e4ca2fe..6761c2d710 100644
--- a/tests/timezones/admin.py
+++ b/tests/timezones/admin.py
@@ -4,13 +4,13 @@ from .models import Event, Timestamp
 
 
 class EventAdmin(admin.ModelAdmin):
-    list_display = ('dt',)
+    list_display = ("dt",)
 
 
 class TimestampAdmin(admin.ModelAdmin):
-    readonly_fields = ('created', 'updated')
+    readonly_fields = ("created", "updated")
 
 
-site = admin.AdminSite(name='admin_tz')
+site = admin.AdminSite(name="admin_tz")
 site.register(Event, EventAdmin)
 site.register(Timestamp, TimestampAdmin)
diff --git a/tests/timezones/forms.py b/tests/timezones/forms.py
index b92562396e..a63f3859de 100644
--- a/tests/timezones/forms.py
+++ b/tests/timezones/forms.py
@@ -18,11 +18,11 @@ class EventLocalizedForm(forms.Form):
 class EventModelForm(forms.ModelForm):
     class Meta:
         model = Event
-        fields = '__all__'
+        fields = "__all__"
 
 
 class EventLocalizedModelForm(forms.ModelForm):
     class Meta:
         model = Event
-        fields = '__all__'
-        localized_fields = '__all__'
+        fields = "__all__"
+        localized_fields = "__all__"
diff --git a/tests/timezones/models.py b/tests/timezones/models.py
index a6e276f2f4..49b555b43d 100644
--- a/tests/timezones/models.py
+++ b/tests/timezones/models.py
@@ -15,7 +15,7 @@ class Session(models.Model):
 
 class SessionEvent(models.Model):
     dt = models.DateTimeField()
-    session = models.ForeignKey(Session, models.CASCADE, related_name='events')
+    session = models.ForeignKey(Session, models.CASCADE, related_name="events")
 
 
 class Timestamp(models.Model):
diff --git a/tests/timezones/tests.py b/tests/timezones/tests.py
index 71bc94f490..fd5ddd7edc 100644
--- a/tests/timezones/tests.py
+++ b/tests/timezones/tests.py
@@ -21,11 +21,20 @@ from django.db import connection
 from django.db.models import F, Max, Min
 from django.http import HttpRequest
 from django.template import (
-    Context, RequestContext, Template, TemplateSyntaxError, context_processors,
+    Context,
+    RequestContext,
+    Template,
+    TemplateSyntaxError,
+    context_processors,
 )
 from django.test import (
-    SimpleTestCase, TestCase, TransactionTestCase, ignore_warnings,
-    override_settings, skipIfDBFeature, skipUnlessDBFeature,
+    SimpleTestCase,
+    TestCase,
+    TransactionTestCase,
+    ignore_warnings,
+    override_settings,
+    skipIfDBFeature,
+    skipUnlessDBFeature,
 )
 from django.test.utils import requires_tz_support
 from django.urls import reverse
@@ -34,16 +43,25 @@ from django.utils.deprecation import RemovedInDjango50Warning
 from django.utils.timezone import timedelta
 
 from .forms import (
-    EventForm, EventLocalizedForm, EventLocalizedModelForm, EventModelForm,
+    EventForm,
+    EventLocalizedForm,
+    EventLocalizedModelForm,
+    EventModelForm,
     EventSplitForm,
 )
 from .models import (
-    AllDayEvent, DailyEvent, Event, MaybeEvent, Session, SessionEvent,
+    AllDayEvent,
+    DailyEvent,
+    Event,
+    MaybeEvent,
+    Session,
+    SessionEvent,
     Timestamp,
 )
 
 try:
     import yaml
+
     HAS_YAML = True
 except ImportError:
     HAS_YAML = False
@@ -58,8 +76,8 @@ except ImportError:
 # 10:20:30 in UTC and 17:20:30 in ICT.
 
 UTC = timezone.utc
-EAT = timezone.get_fixed_timezone(180)      # Africa/Nairobi
-ICT = timezone.get_fixed_timezone(420)      # Asia/Bangkok
+EAT = timezone.get_fixed_timezone(180)  # Africa/Nairobi
+ICT = timezone.get_fixed_timezone(420)  # Asia/Bangkok
 
 ZONE_CONSTRUCTORS = (zoneinfo.ZoneInfo,)
 if pytz is not None:
@@ -73,8 +91,8 @@ def get_timezones(key):
 @contextmanager
 def override_database_connection_timezone(timezone):
     try:
-        orig_timezone = connection.settings_dict['TIME_ZONE']
-        connection.settings_dict['TIME_ZONE'] = timezone
+        orig_timezone = connection.settings_dict["TIME_ZONE"]
+        connection.settings_dict["TIME_ZONE"] = timezone
         # Clear cached properties, after first accessing them to ensure they exist.
         connection.timezone
         del connection.timezone
@@ -82,7 +100,7 @@ def override_database_connection_timezone(timezone):
         del connection.timezone_name
         yield
     finally:
-        connection.settings_dict['TIME_ZONE'] = orig_timezone
+        connection.settings_dict["TIME_ZONE"] = orig_timezone
         # Clear cached properties, after first accessing them to ensure they exist.
         connection.timezone
         del connection.timezone
@@ -90,9 +108,8 @@ def override_database_connection_timezone(timezone):
         del connection.timezone_name
 
 
-@override_settings(TIME_ZONE='Africa/Nairobi', USE_TZ=False)
+@override_settings(TIME_ZONE="Africa/Nairobi", USE_TZ=False)
 class LegacyDatabaseTests(TestCase):
-
     def test_naive_datetime(self):
         dt = datetime.datetime(2011, 9, 1, 13, 20, 30)
         Event.objects.create(dt=dt)
@@ -105,7 +122,7 @@ class LegacyDatabaseTests(TestCase):
         event = Event.objects.get()
         self.assertEqual(event.dt, dt)
 
-    @skipUnlessDBFeature('supports_timezones')
+    @skipUnlessDBFeature("supports_timezones")
     def test_aware_datetime_in_local_timezone(self):
         dt = datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT)
         Event.objects.create(dt=dt)
@@ -114,7 +131,7 @@ class LegacyDatabaseTests(TestCase):
         # interpret the naive datetime in local time to get the correct value
         self.assertEqual(event.dt.replace(tzinfo=EAT), dt)
 
-    @skipUnlessDBFeature('supports_timezones')
+    @skipUnlessDBFeature("supports_timezones")
     def test_aware_datetime_in_local_timezone_with_microsecond(self):
         dt = datetime.datetime(2011, 9, 1, 13, 20, 30, 405060, tzinfo=EAT)
         Event.objects.create(dt=dt)
@@ -123,7 +140,7 @@ class LegacyDatabaseTests(TestCase):
         # interpret the naive datetime in local time to get the correct value
         self.assertEqual(event.dt.replace(tzinfo=EAT), dt)
 
-    @skipUnlessDBFeature('supports_timezones')
+    @skipUnlessDBFeature("supports_timezones")
     def test_aware_datetime_in_utc(self):
         dt = datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC)
         Event.objects.create(dt=dt)
@@ -132,7 +149,7 @@ class LegacyDatabaseTests(TestCase):
         # interpret the naive datetime in local time to get the correct value
         self.assertEqual(event.dt.replace(tzinfo=EAT), dt)
 
-    @skipUnlessDBFeature('supports_timezones')
+    @skipUnlessDBFeature("supports_timezones")
     def test_aware_datetime_in_other_timezone(self):
         dt = datetime.datetime(2011, 9, 1, 17, 20, 30, tzinfo=ICT)
         Event.objects.create(dt=dt)
@@ -141,10 +158,10 @@ class LegacyDatabaseTests(TestCase):
         # interpret the naive datetime in local time to get the correct value
         self.assertEqual(event.dt.replace(tzinfo=EAT), dt)
 
-    @skipIfDBFeature('supports_timezones')
+    @skipIfDBFeature("supports_timezones")
     def test_aware_datetime_unsupported(self):
         dt = datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT)
-        msg = 'backend does not support timezone-aware datetimes when USE_TZ is False.'
+        msg = "backend does not support timezone-aware datetimes when USE_TZ is False."
         with self.assertRaisesMessage(ValueError, msg):
             Event.objects.create(dt=dt)
 
@@ -186,33 +203,46 @@ class LegacyDatabaseTests(TestCase):
         Event.objects.create(dt=datetime.datetime(2011, 9, 1, 23, 20, 20))
         Event.objects.create(dt=datetime.datetime(2011, 9, 1, 13, 20, 30))
         Event.objects.create(dt=datetime.datetime(2011, 9, 1, 3, 20, 40))
-        result = Event.objects.all().aggregate(Min('dt'), Max('dt'))
-        self.assertEqual(result, {
-            'dt__min': datetime.datetime(2011, 9, 1, 3, 20, 40),
-            'dt__max': datetime.datetime(2011, 9, 1, 23, 20, 20),
-        })
+        result = Event.objects.all().aggregate(Min("dt"), Max("dt"))
+        self.assertEqual(
+            result,
+            {
+                "dt__min": datetime.datetime(2011, 9, 1, 3, 20, 40),
+                "dt__max": datetime.datetime(2011, 9, 1, 23, 20, 20),
+            },
+        )
 
     def test_query_annotation(self):
         # Only min and max make sense for datetimes.
-        morning = Session.objects.create(name='morning')
-        afternoon = Session.objects.create(name='afternoon')
-        SessionEvent.objects.create(dt=datetime.datetime(2011, 9, 1, 23, 20, 20), session=afternoon)
-        SessionEvent.objects.create(dt=datetime.datetime(2011, 9, 1, 13, 20, 30), session=afternoon)
-        SessionEvent.objects.create(dt=datetime.datetime(2011, 9, 1, 3, 20, 40), session=morning)
+        morning = Session.objects.create(name="morning")
+        afternoon = Session.objects.create(name="afternoon")
+        SessionEvent.objects.create(
+            dt=datetime.datetime(2011, 9, 1, 23, 20, 20), session=afternoon
+        )
+        SessionEvent.objects.create(
+            dt=datetime.datetime(2011, 9, 1, 13, 20, 30), session=afternoon
+        )
+        SessionEvent.objects.create(
+            dt=datetime.datetime(2011, 9, 1, 3, 20, 40), session=morning
+        )
         morning_min_dt = datetime.datetime(2011, 9, 1, 3, 20, 40)
         afternoon_min_dt = datetime.datetime(2011, 9, 1, 13, 20, 30)
         self.assertQuerysetEqual(
-            Session.objects.annotate(dt=Min('events__dt')).order_by('dt'),
+            Session.objects.annotate(dt=Min("events__dt")).order_by("dt"),
             [morning_min_dt, afternoon_min_dt],
             transform=lambda d: d.dt,
         )
         self.assertQuerysetEqual(
-            Session.objects.annotate(dt=Min('events__dt')).filter(dt__lt=afternoon_min_dt),
+            Session.objects.annotate(dt=Min("events__dt")).filter(
+                dt__lt=afternoon_min_dt
+            ),
             [morning_min_dt],
             transform=lambda d: d.dt,
         )
         self.assertQuerysetEqual(
-            Session.objects.annotate(dt=Min('events__dt')).filter(dt__gte=afternoon_min_dt),
+            Session.objects.annotate(dt=Min("events__dt")).filter(
+                dt__gte=afternoon_min_dt
+            ),
             [afternoon_min_dt],
             transform=lambda d: d.dt,
         )
@@ -220,35 +250,55 @@ class LegacyDatabaseTests(TestCase):
     def test_query_datetimes(self):
         Event.objects.create(dt=datetime.datetime(2011, 1, 1, 1, 30, 0))
         Event.objects.create(dt=datetime.datetime(2011, 1, 1, 4, 30, 0))
-        self.assertSequenceEqual(Event.objects.datetimes('dt', 'year'), [datetime.datetime(2011, 1, 1, 0, 0, 0)])
-        self.assertSequenceEqual(Event.objects.datetimes('dt', 'month'), [datetime.datetime(2011, 1, 1, 0, 0, 0)])
-        self.assertSequenceEqual(Event.objects.datetimes('dt', 'day'), [datetime.datetime(2011, 1, 1, 0, 0, 0)])
         self.assertSequenceEqual(
-            Event.objects.datetimes('dt', 'hour'),
-            [datetime.datetime(2011, 1, 1, 1, 0, 0),
-             datetime.datetime(2011, 1, 1, 4, 0, 0)]
+            Event.objects.datetimes("dt", "year"),
+            [datetime.datetime(2011, 1, 1, 0, 0, 0)],
+        )
+        self.assertSequenceEqual(
+            Event.objects.datetimes("dt", "month"),
+            [datetime.datetime(2011, 1, 1, 0, 0, 0)],
         )
         self.assertSequenceEqual(
-            Event.objects.datetimes('dt', 'minute'),
-            [datetime.datetime(2011, 1, 1, 1, 30, 0),
-             datetime.datetime(2011, 1, 1, 4, 30, 0)]
+            Event.objects.datetimes("dt", "day"),
+            [datetime.datetime(2011, 1, 1, 0, 0, 0)],
         )
         self.assertSequenceEqual(
-            Event.objects.datetimes('dt', 'second'),
-            [datetime.datetime(2011, 1, 1, 1, 30, 0),
-             datetime.datetime(2011, 1, 1, 4, 30, 0)]
+            Event.objects.datetimes("dt", "hour"),
+            [
+                datetime.datetime(2011, 1, 1, 1, 0, 0),
+                datetime.datetime(2011, 1, 1, 4, 0, 0),
+            ],
+        )
+        self.assertSequenceEqual(
+            Event.objects.datetimes("dt", "minute"),
+            [
+                datetime.datetime(2011, 1, 1, 1, 30, 0),
+                datetime.datetime(2011, 1, 1, 4, 30, 0),
+            ],
+        )
+        self.assertSequenceEqual(
+            Event.objects.datetimes("dt", "second"),
+            [
+                datetime.datetime(2011, 1, 1, 1, 30, 0),
+                datetime.datetime(2011, 1, 1, 4, 30, 0),
+            ],
         )
 
     def test_raw_sql(self):
         # Regression test for #17755
         dt = datetime.datetime(2011, 9, 1, 13, 20, 30)
         event = Event.objects.create(dt=dt)
-        self.assertEqual(list(Event.objects.raw('SELECT * FROM timezones_event WHERE dt = %s', [dt])), [event])
+        self.assertEqual(
+            list(
+                Event.objects.raw("SELECT * FROM timezones_event WHERE dt = %s", [dt])
+            ),
+            [event],
+        )
 
     def test_cursor_execute_accepts_naive_datetime(self):
         dt = datetime.datetime(2011, 9, 1, 13, 20, 30)
         with connection.cursor() as cursor:
-            cursor.execute('INSERT INTO timezones_event (dt) VALUES (%s)', [dt])
+            cursor.execute("INSERT INTO timezones_event (dt) VALUES (%s)", [dt])
         event = Event.objects.get()
         self.assertEqual(event.dt, dt)
 
@@ -256,7 +306,7 @@ class LegacyDatabaseTests(TestCase):
         dt = datetime.datetime(2011, 9, 1, 13, 20, 30)
         Event.objects.create(dt=dt)
         with connection.cursor() as cursor:
-            cursor.execute('SELECT dt FROM timezones_event WHERE dt = %s', [dt])
+            cursor.execute("SELECT dt FROM timezones_event WHERE dt = %s", [dt])
             self.assertEqual(cursor.fetchall()[0][0], dt)
 
     def test_filter_date_field_with_aware_datetime(self):
@@ -268,14 +318,14 @@ class LegacyDatabaseTests(TestCase):
         self.assertTrue(AllDayEvent.objects.filter(day__gte=dt).exists())
 
 
-@override_settings(TIME_ZONE='Africa/Nairobi', USE_TZ=True)
+@override_settings(TIME_ZONE="Africa/Nairobi", USE_TZ=True)
 class NewDatabaseTests(TestCase):
-    naive_warning = 'DateTimeField Event.dt received a naive datetime'
+    naive_warning = "DateTimeField Event.dt received a naive datetime"
 
-    @skipIfDBFeature('supports_timezones')
+    @skipIfDBFeature("supports_timezones")
     def test_aware_time_unsupported(self):
         t = datetime.time(13, 20, 30, tzinfo=EAT)
-        msg = 'backend does not support timezone-aware times.'
+        msg = "backend does not support timezone-aware times."
         with self.assertRaisesMessage(ValueError, msg):
             DailyEvent.objects.create(time=t)
 
@@ -351,7 +401,7 @@ class NewDatabaseTests(TestCase):
         self.assertEqual(Event.objects.filter(dt__gt=dt2).count(), 0)
 
     def test_query_filter_with_pytz_timezones(self):
-        for tz in get_timezones('Europe/Paris'):
+        for tz in get_timezones("Europe/Paris"):
             with self.subTest(repr(tz)):
                 dt = datetime.datetime(2011, 9, 1, 12, 20, 30, tzinfo=tz)
                 Event.objects.create(dt=dt)
@@ -360,19 +410,23 @@ class NewDatabaseTests(TestCase):
                 self.assertEqual(Event.objects.filter(dt__exact=dt).count(), 1)
                 self.assertEqual(Event.objects.filter(dt__exact=next).count(), 0)
                 self.assertEqual(Event.objects.filter(dt__in=(prev, next)).count(), 0)
-                self.assertEqual(Event.objects.filter(dt__in=(prev, dt, next)).count(), 1)
-                self.assertEqual(Event.objects.filter(dt__range=(prev, next)).count(), 1)
+                self.assertEqual(
+                    Event.objects.filter(dt__in=(prev, dt, next)).count(), 1
+                )
+                self.assertEqual(
+                    Event.objects.filter(dt__range=(prev, next)).count(), 1
+                )
 
     @ignore_warnings(category=RemovedInDjango50Warning)
     def test_connection_timezone(self):
         tests = [
             (False, None, datetime.timezone),
-            (False, 'Africa/Nairobi', zoneinfo.ZoneInfo),
+            (False, "Africa/Nairobi", zoneinfo.ZoneInfo),
         ]
         if pytz is not None:
             tests += [
                 (True, None, datetime.timezone),
-                (True, 'Africa/Nairobi', pytz.BaseTzInfo),
+                (True, "Africa/Nairobi", pytz.BaseTzInfo),
             ]
         for use_pytz, connection_tz, expected_type in tests:
             with self.subTest(use_pytz=use_pytz, connection_tz=connection_tz):
@@ -383,16 +437,20 @@ class NewDatabaseTests(TestCase):
     def test_query_convert_timezones(self):
         # Connection timezone is equal to the current timezone, datetime
         # shouldn't be converted.
-        with override_database_connection_timezone('Africa/Nairobi'):
+        with override_database_connection_timezone("Africa/Nairobi"):
             event_datetime = datetime.datetime(2016, 1, 2, 23, 10, 11, 123, tzinfo=EAT)
             event = Event.objects.create(dt=event_datetime)
-            self.assertEqual(Event.objects.filter(dt__date=event_datetime.date()).first(), event)
+            self.assertEqual(
+                Event.objects.filter(dt__date=event_datetime.date()).first(), event
+            )
         # Connection timezone is not equal to the current timezone, datetime
         # should be converted (-4h).
-        with override_database_connection_timezone('Asia/Bangkok'):
+        with override_database_connection_timezone("Asia/Bangkok"):
             event_datetime = datetime.datetime(2016, 1, 2, 3, 10, 11, tzinfo=ICT)
             event = Event.objects.create(dt=event_datetime)
-            self.assertEqual(Event.objects.filter(dt__date=datetime.date(2016, 1, 1)).first(), event)
+            self.assertEqual(
+                Event.objects.filter(dt__date=datetime.date(2016, 1, 1)).first(), event
+            )
 
     @requires_tz_support
     def test_query_filter_with_naive_datetime(self):
@@ -407,7 +465,7 @@ class NewDatabaseTests(TestCase):
         with self.assertWarnsMessage(RuntimeWarning, self.naive_warning):
             self.assertEqual(Event.objects.filter(dt__gt=dt).count(), 0)
 
-    @skipUnlessDBFeature('has_zoneinfo_database')
+    @skipUnlessDBFeature("has_zoneinfo_database")
     def test_query_datetime_lookups(self):
         Event.objects.create(dt=datetime.datetime(2011, 1, 1, 1, 30, 0, tzinfo=EAT))
         Event.objects.create(dt=datetime.datetime(2011, 1, 1, 4, 30, 0, tzinfo=EAT))
@@ -420,7 +478,7 @@ class NewDatabaseTests(TestCase):
         self.assertEqual(Event.objects.filter(dt__minute=30).count(), 2)
         self.assertEqual(Event.objects.filter(dt__second=0).count(), 2)
 
-    @skipUnlessDBFeature('has_zoneinfo_database')
+    @skipUnlessDBFeature("has_zoneinfo_database")
     def test_query_datetime_lookups_in_other_timezone(self):
         Event.objects.create(dt=datetime.datetime(2011, 1, 1, 1, 30, 0, tzinfo=EAT))
         Event.objects.create(dt=datetime.datetime(2011, 1, 1, 4, 30, 0, tzinfo=EAT))
@@ -441,152 +499,192 @@ class NewDatabaseTests(TestCase):
         Event.objects.create(dt=datetime.datetime(2011, 9, 1, 23, 20, 20, tzinfo=EAT))
         Event.objects.create(dt=datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT))
         Event.objects.create(dt=datetime.datetime(2011, 9, 1, 3, 20, 40, tzinfo=EAT))
-        result = Event.objects.all().aggregate(Min('dt'), Max('dt'))
-        self.assertEqual(result, {
-            'dt__min': datetime.datetime(2011, 9, 1, 3, 20, 40, tzinfo=EAT),
-            'dt__max': datetime.datetime(2011, 9, 1, 23, 20, 20, tzinfo=EAT),
-        })
+        result = Event.objects.all().aggregate(Min("dt"), Max("dt"))
+        self.assertEqual(
+            result,
+            {
+                "dt__min": datetime.datetime(2011, 9, 1, 3, 20, 40, tzinfo=EAT),
+                "dt__max": datetime.datetime(2011, 9, 1, 23, 20, 20, tzinfo=EAT),
+            },
+        )
 
     def test_query_annotation(self):
         # Only min and max make sense for datetimes.
-        morning = Session.objects.create(name='morning')
-        afternoon = Session.objects.create(name='afternoon')
-        SessionEvent.objects.create(dt=datetime.datetime(2011, 9, 1, 23, 20, 20, tzinfo=EAT), session=afternoon)
-        SessionEvent.objects.create(dt=datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT), session=afternoon)
-        SessionEvent.objects.create(dt=datetime.datetime(2011, 9, 1, 3, 20, 40, tzinfo=EAT), session=morning)
+        morning = Session.objects.create(name="morning")
+        afternoon = Session.objects.create(name="afternoon")
+        SessionEvent.objects.create(
+            dt=datetime.datetime(2011, 9, 1, 23, 20, 20, tzinfo=EAT), session=afternoon
+        )
+        SessionEvent.objects.create(
+            dt=datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT), session=afternoon
+        )
+        SessionEvent.objects.create(
+            dt=datetime.datetime(2011, 9, 1, 3, 20, 40, tzinfo=EAT), session=morning
+        )
         morning_min_dt = datetime.datetime(2011, 9, 1, 3, 20, 40, tzinfo=EAT)
         afternoon_min_dt = datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT)
         self.assertQuerysetEqual(
-            Session.objects.annotate(dt=Min('events__dt')).order_by('dt'),
+            Session.objects.annotate(dt=Min("events__dt")).order_by("dt"),
             [morning_min_dt, afternoon_min_dt],
             transform=lambda d: d.dt,
         )
         self.assertQuerysetEqual(
-            Session.objects.annotate(dt=Min('events__dt')).filter(dt__lt=afternoon_min_dt),
+            Session.objects.annotate(dt=Min("events__dt")).filter(
+                dt__lt=afternoon_min_dt
+            ),
             [morning_min_dt],
             transform=lambda d: d.dt,
         )
         self.assertQuerysetEqual(
-            Session.objects.annotate(dt=Min('events__dt')).filter(dt__gte=afternoon_min_dt),
+            Session.objects.annotate(dt=Min("events__dt")).filter(
+                dt__gte=afternoon_min_dt
+            ),
             [afternoon_min_dt],
             transform=lambda d: d.dt,
         )
 
-    @skipUnlessDBFeature('has_zoneinfo_database')
+    @skipUnlessDBFeature("has_zoneinfo_database")
     def test_query_datetimes(self):
         Event.objects.create(dt=datetime.datetime(2011, 1, 1, 1, 30, 0, tzinfo=EAT))
         Event.objects.create(dt=datetime.datetime(2011, 1, 1, 4, 30, 0, tzinfo=EAT))
         self.assertSequenceEqual(
-            Event.objects.datetimes('dt', 'year'),
-            [datetime.datetime(2011, 1, 1, 0, 0, 0, tzinfo=EAT)]
+            Event.objects.datetimes("dt", "year"),
+            [datetime.datetime(2011, 1, 1, 0, 0, 0, tzinfo=EAT)],
         )
         self.assertSequenceEqual(
-            Event.objects.datetimes('dt', 'month'),
-            [datetime.datetime(2011, 1, 1, 0, 0, 0, tzinfo=EAT)]
+            Event.objects.datetimes("dt", "month"),
+            [datetime.datetime(2011, 1, 1, 0, 0, 0, tzinfo=EAT)],
         )
         self.assertSequenceEqual(
-            Event.objects.datetimes('dt', 'day'),
-            [datetime.datetime(2011, 1, 1, 0, 0, 0, tzinfo=EAT)]
+            Event.objects.datetimes("dt", "day"),
+            [datetime.datetime(2011, 1, 1, 0, 0, 0, tzinfo=EAT)],
         )
         self.assertSequenceEqual(
-            Event.objects.datetimes('dt', 'hour'),
-            [datetime.datetime(2011, 1, 1, 1, 0, 0, tzinfo=EAT),
-             datetime.datetime(2011, 1, 1, 4, 0, 0, tzinfo=EAT)]
+            Event.objects.datetimes("dt", "hour"),
+            [
+                datetime.datetime(2011, 1, 1, 1, 0, 0, tzinfo=EAT),
+                datetime.datetime(2011, 1, 1, 4, 0, 0, tzinfo=EAT),
+            ],
         )
         self.assertSequenceEqual(
-            Event.objects.datetimes('dt', 'minute'),
-            [datetime.datetime(2011, 1, 1, 1, 30, 0, tzinfo=EAT),
-             datetime.datetime(2011, 1, 1, 4, 30, 0, tzinfo=EAT)]
+            Event.objects.datetimes("dt", "minute"),
+            [
+                datetime.datetime(2011, 1, 1, 1, 30, 0, tzinfo=EAT),
+                datetime.datetime(2011, 1, 1, 4, 30, 0, tzinfo=EAT),
+            ],
         )
         self.assertSequenceEqual(
-            Event.objects.datetimes('dt', 'second'),
-            [datetime.datetime(2011, 1, 1, 1, 30, 0, tzinfo=EAT),
-             datetime.datetime(2011, 1, 1, 4, 30, 0, tzinfo=EAT)]
+            Event.objects.datetimes("dt", "second"),
+            [
+                datetime.datetime(2011, 1, 1, 1, 30, 0, tzinfo=EAT),
+                datetime.datetime(2011, 1, 1, 4, 30, 0, tzinfo=EAT),
+            ],
         )
 
-    @skipUnlessDBFeature('has_zoneinfo_database')
+    @skipUnlessDBFeature("has_zoneinfo_database")
     def test_query_datetimes_in_other_timezone(self):
         Event.objects.create(dt=datetime.datetime(2011, 1, 1, 1, 30, 0, tzinfo=EAT))
         Event.objects.create(dt=datetime.datetime(2011, 1, 1, 4, 30, 0, tzinfo=EAT))
         with timezone.override(UTC):
             self.assertSequenceEqual(
-                Event.objects.datetimes('dt', 'year'),
-                [datetime.datetime(2010, 1, 1, 0, 0, 0, tzinfo=UTC),
-                 datetime.datetime(2011, 1, 1, 0, 0, 0, tzinfo=UTC)]
+                Event.objects.datetimes("dt", "year"),
+                [
+                    datetime.datetime(2010, 1, 1, 0, 0, 0, tzinfo=UTC),
+                    datetime.datetime(2011, 1, 1, 0, 0, 0, tzinfo=UTC),
+                ],
             )
             self.assertSequenceEqual(
-                Event.objects.datetimes('dt', 'month'),
-                [datetime.datetime(2010, 12, 1, 0, 0, 0, tzinfo=UTC),
-                 datetime.datetime(2011, 1, 1, 0, 0, 0, tzinfo=UTC)]
+                Event.objects.datetimes("dt", "month"),
+                [
+                    datetime.datetime(2010, 12, 1, 0, 0, 0, tzinfo=UTC),
+                    datetime.datetime(2011, 1, 1, 0, 0, 0, tzinfo=UTC),
+                ],
             )
             self.assertSequenceEqual(
-                Event.objects.datetimes('dt', 'day'),
-                [datetime.datetime(2010, 12, 31, 0, 0, 0, tzinfo=UTC),
-                 datetime.datetime(2011, 1, 1, 0, 0, 0, tzinfo=UTC)]
+                Event.objects.datetimes("dt", "day"),
+                [
+                    datetime.datetime(2010, 12, 31, 0, 0, 0, tzinfo=UTC),
+                    datetime.datetime(2011, 1, 1, 0, 0, 0, tzinfo=UTC),
+                ],
             )
             self.assertSequenceEqual(
-                Event.objects.datetimes('dt', 'hour'),
-                [datetime.datetime(2010, 12, 31, 22, 0, 0, tzinfo=UTC),
-                 datetime.datetime(2011, 1, 1, 1, 0, 0, tzinfo=UTC)]
+                Event.objects.datetimes("dt", "hour"),
+                [
+                    datetime.datetime(2010, 12, 31, 22, 0, 0, tzinfo=UTC),
+                    datetime.datetime(2011, 1, 1, 1, 0, 0, tzinfo=UTC),
+                ],
             )
             self.assertSequenceEqual(
-                Event.objects.datetimes('dt', 'minute'),
-                [datetime.datetime(2010, 12, 31, 22, 30, 0, tzinfo=UTC),
-                 datetime.datetime(2011, 1, 1, 1, 30, 0, tzinfo=UTC)]
+                Event.objects.datetimes("dt", "minute"),
+                [
+                    datetime.datetime(2010, 12, 31, 22, 30, 0, tzinfo=UTC),
+                    datetime.datetime(2011, 1, 1, 1, 30, 0, tzinfo=UTC),
+                ],
             )
             self.assertSequenceEqual(
-                Event.objects.datetimes('dt', 'second'),
-                [datetime.datetime(2010, 12, 31, 22, 30, 0, tzinfo=UTC),
-                 datetime.datetime(2011, 1, 1, 1, 30, 0, tzinfo=UTC)]
+                Event.objects.datetimes("dt", "second"),
+                [
+                    datetime.datetime(2010, 12, 31, 22, 30, 0, tzinfo=UTC),
+                    datetime.datetime(2011, 1, 1, 1, 30, 0, tzinfo=UTC),
+                ],
             )
 
     def test_raw_sql(self):
         # Regression test for #17755
         dt = datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT)
         event = Event.objects.create(dt=dt)
-        self.assertSequenceEqual(list(Event.objects.raw('SELECT * FROM timezones_event WHERE dt = %s', [dt])), [event])
+        self.assertSequenceEqual(
+            list(
+                Event.objects.raw("SELECT * FROM timezones_event WHERE dt = %s", [dt])
+            ),
+            [event],
+        )
 
-    @skipUnlessDBFeature('supports_timezones')
+    @skipUnlessDBFeature("supports_timezones")
     def test_cursor_execute_accepts_aware_datetime(self):
         dt = datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT)
         with connection.cursor() as cursor:
-            cursor.execute('INSERT INTO timezones_event (dt) VALUES (%s)', [dt])
+            cursor.execute("INSERT INTO timezones_event (dt) VALUES (%s)", [dt])
         event = Event.objects.get()
         self.assertEqual(event.dt, dt)
 
-    @skipIfDBFeature('supports_timezones')
+    @skipIfDBFeature("supports_timezones")
     def test_cursor_execute_accepts_naive_datetime(self):
         dt = datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT)
         utc_naive_dt = timezone.make_naive(dt, timezone.utc)
         with connection.cursor() as cursor:
-            cursor.execute('INSERT INTO timezones_event (dt) VALUES (%s)', [utc_naive_dt])
+            cursor.execute(
+                "INSERT INTO timezones_event (dt) VALUES (%s)", [utc_naive_dt]
+            )
         event = Event.objects.get()
         self.assertEqual(event.dt, dt)
 
-    @skipUnlessDBFeature('supports_timezones')
+    @skipUnlessDBFeature("supports_timezones")
     def test_cursor_execute_returns_aware_datetime(self):
         dt = datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT)
         Event.objects.create(dt=dt)
         with connection.cursor() as cursor:
-            cursor.execute('SELECT dt FROM timezones_event WHERE dt = %s', [dt])
+            cursor.execute("SELECT dt FROM timezones_event WHERE dt = %s", [dt])
             self.assertEqual(cursor.fetchall()[0][0], dt)
 
-    @skipIfDBFeature('supports_timezones')
+    @skipIfDBFeature("supports_timezones")
     def test_cursor_execute_returns_naive_datetime(self):
         dt = datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT)
         utc_naive_dt = timezone.make_naive(dt, timezone.utc)
         Event.objects.create(dt=dt)
         with connection.cursor() as cursor:
-            cursor.execute('SELECT dt FROM timezones_event WHERE dt = %s', [utc_naive_dt])
+            cursor.execute(
+                "SELECT dt FROM timezones_event WHERE dt = %s", [utc_naive_dt]
+            )
             self.assertEqual(cursor.fetchall()[0][0], utc_naive_dt)
 
-    @skipUnlessDBFeature('supports_timezones')
+    @skipUnlessDBFeature("supports_timezones")
     def test_cursor_explicit_time_zone(self):
-        with override_database_connection_timezone('Europe/Paris'):
+        with override_database_connection_timezone("Europe/Paris"):
             with connection.cursor() as cursor:
-                cursor.execute('SELECT CURRENT_TIMESTAMP')
+                cursor.execute("SELECT CURRENT_TIMESTAMP")
                 now = cursor.fetchone()[0]
-                self.assertEqual(str(now.tzinfo), 'Europe/Paris')
+                self.assertEqual(str(now.tzinfo), "Europe/Paris")
 
     @requires_tz_support
     def test_filter_date_field_with_aware_datetime(self):
@@ -605,12 +703,12 @@ class NewDatabaseTests(TestCase):
     def test_update_with_timedelta(self):
         initial_dt = timezone.now().replace(microsecond=0)
         event = Event.objects.create(dt=initial_dt)
-        Event.objects.update(dt=F('dt') + timedelta(hours=2))
+        Event.objects.update(dt=F("dt") + timedelta(hours=2))
         event.refresh_from_db()
         self.assertEqual(event.dt, initial_dt + timedelta(hours=2))
 
 
-@override_settings(TIME_ZONE='Africa/Nairobi', USE_TZ=True)
+@override_settings(TIME_ZONE="Africa/Nairobi", USE_TZ=True)
 class ForcedTimeZoneDatabaseTests(TransactionTestCase):
     """
     Test the TIME_ZONE database configuration parameter.
@@ -619,7 +717,7 @@ class ForcedTimeZoneDatabaseTests(TransactionTestCase):
     connections, this is a TransactionTestCase.
     """
 
-    available_apps = ['timezones']
+    available_apps = ["timezones"]
 
     @classmethod
     def setUpClass(cls):
@@ -628,7 +726,9 @@ class ForcedTimeZoneDatabaseTests(TransactionTestCase):
         if connection.features.supports_timezones:
             raise SkipTest("Database has feature(s) supports_timezones")
         if not connection.features.test_db_allows_multiple_connections:
-            raise SkipTest("Database doesn't support feature(s): test_db_allows_multiple_connections")
+            raise SkipTest(
+                "Database doesn't support feature(s): test_db_allows_multiple_connections"
+            )
 
         super().setUpClass()
 
@@ -636,14 +736,14 @@ class ForcedTimeZoneDatabaseTests(TransactionTestCase):
         fake_dt = datetime.datetime(2011, 9, 1, 17, 20, 30, tzinfo=UTC)
         Event.objects.create(dt=fake_dt)
 
-        with override_database_connection_timezone('Asia/Bangkok'):
+        with override_database_connection_timezone("Asia/Bangkok"):
             event = Event.objects.get()
             dt = datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC)
         self.assertEqual(event.dt, dt)
 
     def test_write_datetime(self):
         dt = datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC)
-        with override_database_connection_timezone('Asia/Bangkok'):
+        with override_database_connection_timezone("Asia/Bangkok"):
             Event.objects.create(dt=dt)
 
         event = Event.objects.get()
@@ -651,7 +751,7 @@ class ForcedTimeZoneDatabaseTests(TransactionTestCase):
         self.assertEqual(event.dt, fake_dt)
 
 
-@override_settings(TIME_ZONE='Africa/Nairobi')
+@override_settings(TIME_ZONE="Africa/Nairobi")
 class SerializationTests(SimpleTestCase):
 
     # Backend-specific notes:
@@ -663,13 +763,13 @@ class SerializationTests(SimpleTestCase):
     # Tests are adapted to take these quirks into account.
 
     def assert_python_contains_datetime(self, objects, dt):
-        self.assertEqual(objects[0]['fields']['dt'], dt)
+        self.assertEqual(objects[0]["fields"]["dt"], dt)
 
     def assert_json_contains_datetime(self, json, dt):
         self.assertIn('"fields": {"dt": "%s"}' % dt, json)
 
     def assert_xml_contains_datetime(self, xml, dt):
-        field = parseString(xml).getElementsByTagName('field')[0]
+        field = parseString(xml).getElementsByTagName("field")[0]
         self.assertXMLEqual(field.childNodes[0].wholeText, dt)
 
     def assert_yaml_contains_datetime(self, yaml, dt):
@@ -679,74 +779,86 @@ class SerializationTests(SimpleTestCase):
     def test_naive_datetime(self):
         dt = datetime.datetime(2011, 9, 1, 13, 20, 30)
 
-        data = serializers.serialize('python', [Event(dt=dt)])
+        data = serializers.serialize("python", [Event(dt=dt)])
         self.assert_python_contains_datetime(data, dt)
-        obj = next(serializers.deserialize('python', data)).object
+        obj = next(serializers.deserialize("python", data)).object
         self.assertEqual(obj.dt, dt)
 
-        data = serializers.serialize('json', [Event(dt=dt)])
+        data = serializers.serialize("json", [Event(dt=dt)])
         self.assert_json_contains_datetime(data, "2011-09-01T13:20:30")
-        obj = next(serializers.deserialize('json', data)).object
+        obj = next(serializers.deserialize("json", data)).object
         self.assertEqual(obj.dt, dt)
 
-        data = serializers.serialize('xml', [Event(dt=dt)])
+        data = serializers.serialize("xml", [Event(dt=dt)])
         self.assert_xml_contains_datetime(data, "2011-09-01T13:20:30")
-        obj = next(serializers.deserialize('xml', data)).object
+        obj = next(serializers.deserialize("xml", data)).object
         self.assertEqual(obj.dt, dt)
 
-        if not isinstance(serializers.get_serializer('yaml'), serializers.BadSerializer):
-            data = serializers.serialize('yaml', [Event(dt=dt)], default_flow_style=None)
+        if not isinstance(
+            serializers.get_serializer("yaml"), serializers.BadSerializer
+        ):
+            data = serializers.serialize(
+                "yaml", [Event(dt=dt)], default_flow_style=None
+            )
             self.assert_yaml_contains_datetime(data, "2011-09-01 13:20:30")
-            obj = next(serializers.deserialize('yaml', data)).object
+            obj = next(serializers.deserialize("yaml", data)).object
             self.assertEqual(obj.dt, dt)
 
     def test_naive_datetime_with_microsecond(self):
         dt = datetime.datetime(2011, 9, 1, 13, 20, 30, 405060)
 
-        data = serializers.serialize('python', [Event(dt=dt)])
+        data = serializers.serialize("python", [Event(dt=dt)])
         self.assert_python_contains_datetime(data, dt)
-        obj = next(serializers.deserialize('python', data)).object
+        obj = next(serializers.deserialize("python", data)).object
         self.assertEqual(obj.dt, dt)
 
-        data = serializers.serialize('json', [Event(dt=dt)])
+        data = serializers.serialize("json", [Event(dt=dt)])
         self.assert_json_contains_datetime(data, "2011-09-01T13:20:30.405")
-        obj = next(serializers.deserialize('json', data)).object
+        obj = next(serializers.deserialize("json", data)).object
         self.assertEqual(obj.dt, dt.replace(microsecond=405000))
 
-        data = serializers.serialize('xml', [Event(dt=dt)])
+        data = serializers.serialize("xml", [Event(dt=dt)])
         self.assert_xml_contains_datetime(data, "2011-09-01T13:20:30.405060")
-        obj = next(serializers.deserialize('xml', data)).object
+        obj = next(serializers.deserialize("xml", data)).object
         self.assertEqual(obj.dt, dt)
 
-        if not isinstance(serializers.get_serializer('yaml'), serializers.BadSerializer):
-            data = serializers.serialize('yaml', [Event(dt=dt)], default_flow_style=None)
+        if not isinstance(
+            serializers.get_serializer("yaml"), serializers.BadSerializer
+        ):
+            data = serializers.serialize(
+                "yaml", [Event(dt=dt)], default_flow_style=None
+            )
             self.assert_yaml_contains_datetime(data, "2011-09-01 13:20:30.405060")
-            obj = next(serializers.deserialize('yaml', data)).object
+            obj = next(serializers.deserialize("yaml", data)).object
             self.assertEqual(obj.dt, dt)
 
     def test_aware_datetime_with_microsecond(self):
         dt = datetime.datetime(2011, 9, 1, 17, 20, 30, 405060, tzinfo=ICT)
 
-        data = serializers.serialize('python', [Event(dt=dt)])
+        data = serializers.serialize("python", [Event(dt=dt)])
         self.assert_python_contains_datetime(data, dt)
-        obj = next(serializers.deserialize('python', data)).object
+        obj = next(serializers.deserialize("python", data)).object
         self.assertEqual(obj.dt, dt)
 
-        data = serializers.serialize('json', [Event(dt=dt)])
+        data = serializers.serialize("json", [Event(dt=dt)])
         self.assert_json_contains_datetime(data, "2011-09-01T17:20:30.405+07:00")
-        obj = next(serializers.deserialize('json', data)).object
+        obj = next(serializers.deserialize("json", data)).object
         self.assertEqual(obj.dt, dt.replace(microsecond=405000))
 
-        data = serializers.serialize('xml', [Event(dt=dt)])
+        data = serializers.serialize("xml", [Event(dt=dt)])
         self.assert_xml_contains_datetime(data, "2011-09-01T17:20:30.405060+07:00")
-        obj = next(serializers.deserialize('xml', data)).object
+        obj = next(serializers.deserialize("xml", data)).object
         self.assertEqual(obj.dt, dt)
 
-        if not isinstance(serializers.get_serializer('yaml'), serializers.BadSerializer):
-            data = serializers.serialize('yaml', [Event(dt=dt)], default_flow_style=None)
+        if not isinstance(
+            serializers.get_serializer("yaml"), serializers.BadSerializer
+        ):
+            data = serializers.serialize(
+                "yaml", [Event(dt=dt)], default_flow_style=None
+            )
             self.assert_yaml_contains_datetime(data, "2011-09-01 17:20:30.405060+07:00")
-            obj = next(serializers.deserialize('yaml', data)).object
-            if HAS_YAML and yaml.__version__ < '5.3':
+            obj = next(serializers.deserialize("yaml", data)).object
+            if HAS_YAML and yaml.__version__ < "5.3":
                 self.assertEqual(obj.dt.replace(tzinfo=UTC), dt)
             else:
                 self.assertEqual(obj.dt, dt)
@@ -754,50 +866,58 @@ class SerializationTests(SimpleTestCase):
     def test_aware_datetime_in_utc(self):
         dt = datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC)
 
-        data = serializers.serialize('python', [Event(dt=dt)])
+        data = serializers.serialize("python", [Event(dt=dt)])
         self.assert_python_contains_datetime(data, dt)
-        obj = next(serializers.deserialize('python', data)).object
+        obj = next(serializers.deserialize("python", data)).object
         self.assertEqual(obj.dt, dt)
 
-        data = serializers.serialize('json', [Event(dt=dt)])
+        data = serializers.serialize("json", [Event(dt=dt)])
         self.assert_json_contains_datetime(data, "2011-09-01T10:20:30Z")
-        obj = next(serializers.deserialize('json', data)).object
+        obj = next(serializers.deserialize("json", data)).object
         self.assertEqual(obj.dt, dt)
 
-        data = serializers.serialize('xml', [Event(dt=dt)])
+        data = serializers.serialize("xml", [Event(dt=dt)])
         self.assert_xml_contains_datetime(data, "2011-09-01T10:20:30+00:00")
-        obj = next(serializers.deserialize('xml', data)).object
+        obj = next(serializers.deserialize("xml", data)).object
         self.assertEqual(obj.dt, dt)
 
-        if not isinstance(serializers.get_serializer('yaml'), serializers.BadSerializer):
-            data = serializers.serialize('yaml', [Event(dt=dt)], default_flow_style=None)
+        if not isinstance(
+            serializers.get_serializer("yaml"), serializers.BadSerializer
+        ):
+            data = serializers.serialize(
+                "yaml", [Event(dt=dt)], default_flow_style=None
+            )
             self.assert_yaml_contains_datetime(data, "2011-09-01 10:20:30+00:00")
-            obj = next(serializers.deserialize('yaml', data)).object
+            obj = next(serializers.deserialize("yaml", data)).object
             self.assertEqual(obj.dt.replace(tzinfo=UTC), dt)
 
     def test_aware_datetime_in_local_timezone(self):
         dt = datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT)
 
-        data = serializers.serialize('python', [Event(dt=dt)])
+        data = serializers.serialize("python", [Event(dt=dt)])
         self.assert_python_contains_datetime(data, dt)
-        obj = next(serializers.deserialize('python', data)).object
+        obj = next(serializers.deserialize("python", data)).object
         self.assertEqual(obj.dt, dt)
 
-        data = serializers.serialize('json', [Event(dt=dt)])
+        data = serializers.serialize("json", [Event(dt=dt)])
         self.assert_json_contains_datetime(data, "2011-09-01T13:20:30+03:00")
-        obj = next(serializers.deserialize('json', data)).object
+        obj = next(serializers.deserialize("json", data)).object
         self.assertEqual(obj.dt, dt)
 
-        data = serializers.serialize('xml', [Event(dt=dt)])
+        data = serializers.serialize("xml", [Event(dt=dt)])
         self.assert_xml_contains_datetime(data, "2011-09-01T13:20:30+03:00")
-        obj = next(serializers.deserialize('xml', data)).object
+        obj = next(serializers.deserialize("xml", data)).object
         self.assertEqual(obj.dt, dt)
 
-        if not isinstance(serializers.get_serializer('yaml'), serializers.BadSerializer):
-            data = serializers.serialize('yaml', [Event(dt=dt)], default_flow_style=None)
+        if not isinstance(
+            serializers.get_serializer("yaml"), serializers.BadSerializer
+        ):
+            data = serializers.serialize(
+                "yaml", [Event(dt=dt)], default_flow_style=None
+            )
             self.assert_yaml_contains_datetime(data, "2011-09-01 13:20:30+03:00")
-            obj = next(serializers.deserialize('yaml', data)).object
-            if HAS_YAML and yaml.__version__ < '5.3':
+            obj = next(serializers.deserialize("yaml", data)).object
+            if HAS_YAML and yaml.__version__ < "5.3":
                 self.assertEqual(obj.dt.replace(tzinfo=UTC), dt)
             else:
                 self.assertEqual(obj.dt, dt)
@@ -805,26 +925,30 @@ class SerializationTests(SimpleTestCase):
     def test_aware_datetime_in_other_timezone(self):
         dt = datetime.datetime(2011, 9, 1, 17, 20, 30, tzinfo=ICT)
 
-        data = serializers.serialize('python', [Event(dt=dt)])
+        data = serializers.serialize("python", [Event(dt=dt)])
         self.assert_python_contains_datetime(data, dt)
-        obj = next(serializers.deserialize('python', data)).object
+        obj = next(serializers.deserialize("python", data)).object
         self.assertEqual(obj.dt, dt)
 
-        data = serializers.serialize('json', [Event(dt=dt)])
+        data = serializers.serialize("json", [Event(dt=dt)])
         self.assert_json_contains_datetime(data, "2011-09-01T17:20:30+07:00")
-        obj = next(serializers.deserialize('json', data)).object
+        obj = next(serializers.deserialize("json", data)).object
         self.assertEqual(obj.dt, dt)
 
-        data = serializers.serialize('xml', [Event(dt=dt)])
+        data = serializers.serialize("xml", [Event(dt=dt)])
         self.assert_xml_contains_datetime(data, "2011-09-01T17:20:30+07:00")
-        obj = next(serializers.deserialize('xml', data)).object
+        obj = next(serializers.deserialize("xml", data)).object
         self.assertEqual(obj.dt, dt)
 
-        if not isinstance(serializers.get_serializer('yaml'), serializers.BadSerializer):
-            data = serializers.serialize('yaml', [Event(dt=dt)], default_flow_style=None)
+        if not isinstance(
+            serializers.get_serializer("yaml"), serializers.BadSerializer
+        ):
+            data = serializers.serialize(
+                "yaml", [Event(dt=dt)], default_flow_style=None
+            )
             self.assert_yaml_contains_datetime(data, "2011-09-01 17:20:30+07:00")
-            obj = next(serializers.deserialize('yaml', data)).object
-            if HAS_YAML and yaml.__version__ < '5.3':
+            obj = next(serializers.deserialize("yaml", data)).object
+            if HAS_YAML and yaml.__version__ < "5.3":
                 self.assertEqual(obj.dt.replace(tzinfo=UTC), dt)
             else:
                 self.assertEqual(obj.dt, dt)
@@ -833,7 +957,9 @@ class SerializationTests(SimpleTestCase):
 # RemovedInDjango50Warning: When the deprecation ends, remove setUpClass() and
 # USE_L10N=False. The tests should remain because format-related settings will
 # take precedence over locale-dictated formats.
-@override_settings(DATETIME_FORMAT='c', TIME_ZONE='Africa/Nairobi', USE_L10N=False, USE_TZ=True)
+@override_settings(
+    DATETIME_FORMAT="c", TIME_ZONE="Africa/Nairobi", USE_L10N=False, USE_TZ=True
+)
 class TemplateTests(SimpleTestCase):
     @classmethod
     def setUpClass(cls):
@@ -846,22 +972,24 @@ class TemplateTests(SimpleTestCase):
         Test the {% localtime %} templatetag and related filters.
         """
         datetimes = {
-            'utc': datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC),
-            'eat': datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT),
-            'ict': datetime.datetime(2011, 9, 1, 17, 20, 30, tzinfo=ICT),
-            'naive': datetime.datetime(2011, 9, 1, 13, 20, 30),
+            "utc": datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC),
+            "eat": datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT),
+            "ict": datetime.datetime(2011, 9, 1, 17, 20, 30, tzinfo=ICT),
+            "naive": datetime.datetime(2011, 9, 1, 13, 20, 30),
         }
         templates = {
-            'notag': Template("{% load tz %}{{ dt }}|{{ dt|localtime }}|{{ dt|utc }}|{{ dt|timezone:ICT }}"),
-            'noarg': Template(
+            "notag": Template(
+                "{% load tz %}{{ dt }}|{{ dt|localtime }}|{{ dt|utc }}|{{ dt|timezone:ICT }}"
+            ),
+            "noarg": Template(
                 "{% load tz %}{% localtime %}{{ dt }}|{{ dt|localtime }}|"
                 "{{ dt|utc }}|{{ dt|timezone:ICT }}{% endlocaltime %}"
             ),
-            'on': Template(
+            "on": Template(
                 "{% load tz %}{% localtime on %}{{ dt }}|{{ dt|localtime }}|"
                 "{{ dt|utc }}|{{ dt|timezone:ICT }}{% endlocaltime %}"
             ),
-            'off': Template(
+            "off": Template(
                 "{% load tz %}{% localtime off %}{{ dt }}|{{ dt|localtime }}|"
                 "{{ dt|utc }}|{{ dt|timezone:ICT }}{% endlocaltime %}"
             ),
@@ -870,56 +998,62 @@ class TemplateTests(SimpleTestCase):
         # Transform a list of keys in 'datetimes' to the expected template
         # output. This makes the definition of 'results' more readable.
         def t(*result):
-            return '|'.join(datetimes[key].isoformat() for key in result)
+            return "|".join(datetimes[key].isoformat() for key in result)
 
         # Results for USE_TZ = True
 
         results = {
-            'utc': {
-                'notag': t('eat', 'eat', 'utc', 'ict'),
-                'noarg': t('eat', 'eat', 'utc', 'ict'),
-                'on': t('eat', 'eat', 'utc', 'ict'),
-                'off': t('utc', 'eat', 'utc', 'ict'),
+            "utc": {
+                "notag": t("eat", "eat", "utc", "ict"),
+                "noarg": t("eat", "eat", "utc", "ict"),
+                "on": t("eat", "eat", "utc", "ict"),
+                "off": t("utc", "eat", "utc", "ict"),
             },
-            'eat': {
-                'notag': t('eat', 'eat', 'utc', 'ict'),
-                'noarg': t('eat', 'eat', 'utc', 'ict'),
-                'on': t('eat', 'eat', 'utc', 'ict'),
-                'off': t('eat', 'eat', 'utc', 'ict'),
+            "eat": {
+                "notag": t("eat", "eat", "utc", "ict"),
+                "noarg": t("eat", "eat", "utc", "ict"),
+                "on": t("eat", "eat", "utc", "ict"),
+                "off": t("eat", "eat", "utc", "ict"),
             },
-            'ict': {
-                'notag': t('eat', 'eat', 'utc', 'ict'),
-                'noarg': t('eat', 'eat', 'utc', 'ict'),
-                'on': t('eat', 'eat', 'utc', 'ict'),
-                'off': t('ict', 'eat', 'utc', 'ict'),
+            "ict": {
+                "notag": t("eat", "eat", "utc", "ict"),
+                "noarg": t("eat", "eat", "utc", "ict"),
+                "on": t("eat", "eat", "utc", "ict"),
+                "off": t("ict", "eat", "utc", "ict"),
+            },
+            "naive": {
+                "notag": t("naive", "eat", "utc", "ict"),
+                "noarg": t("naive", "eat", "utc", "ict"),
+                "on": t("naive", "eat", "utc", "ict"),
+                "off": t("naive", "eat", "utc", "ict"),
             },
-            'naive': {
-                'notag': t('naive', 'eat', 'utc', 'ict'),
-                'noarg': t('naive', 'eat', 'utc', 'ict'),
-                'on': t('naive', 'eat', 'utc', 'ict'),
-                'off': t('naive', 'eat', 'utc', 'ict'),
-            }
         }
 
         for k1, dt in datetimes.items():
             for k2, tpl in templates.items():
-                ctx = Context({'dt': dt, 'ICT': ICT})
+                ctx = Context({"dt": dt, "ICT": ICT})
                 actual = tpl.render(ctx)
                 expected = results[k1][k2]
-                self.assertEqual(actual, expected, '%s / %s: %r != %r' % (k1, k2, actual, expected))
+                self.assertEqual(
+                    actual, expected, "%s / %s: %r != %r" % (k1, k2, actual, expected)
+                )
 
         # Changes for USE_TZ = False
 
-        results['utc']['notag'] = t('utc', 'eat', 'utc', 'ict')
-        results['ict']['notag'] = t('ict', 'eat', 'utc', 'ict')
+        results["utc"]["notag"] = t("utc", "eat", "utc", "ict")
+        results["ict"]["notag"] = t("ict", "eat", "utc", "ict")
 
         with self.settings(USE_TZ=False):
             for k1, dt in datetimes.items():
                 for k2, tpl in templates.items():
-                    ctx = Context({'dt': dt, 'ICT': ICT})
+                    ctx = Context({"dt": dt, "ICT": ICT})
                     actual = tpl.render(ctx)
                     expected = results[k1][k2]
-                    self.assertEqual(actual, expected, '%s / %s: %r != %r' % (k1, k2, actual, expected))
+                    self.assertEqual(
+                        actual,
+                        expected,
+                        "%s / %s: %r != %r" % (k1, k2, actual, expected),
+                    )
 
     def test_localtime_filters_with_iana(self):
         """
@@ -927,19 +1061,23 @@ class TemplateTests(SimpleTestCase):
         """
         # Use an IANA timezone as local time
         tpl = Template("{% load tz %}{{ dt|localtime }}|{{ dt|utc }}")
-        ctx = Context({'dt': datetime.datetime(2011, 9, 1, 12, 20, 30)})
+        ctx = Context({"dt": datetime.datetime(2011, 9, 1, 12, 20, 30)})
 
-        with self.settings(TIME_ZONE='Europe/Paris'):
-            self.assertEqual(tpl.render(ctx), "2011-09-01T12:20:30+02:00|2011-09-01T10:20:30+00:00")
+        with self.settings(TIME_ZONE="Europe/Paris"):
+            self.assertEqual(
+                tpl.render(ctx), "2011-09-01T12:20:30+02:00|2011-09-01T10:20:30+00:00"
+            )
 
         # Use an IANA timezone as argument
-        for tz in get_timezones('Europe/Paris'):
+        for tz in get_timezones("Europe/Paris"):
             with self.subTest(repr(tz)):
                 tpl = Template("{% load tz %}{{ dt|timezone:tz }}")
-                ctx = Context({
-                    'dt': datetime.datetime(2011, 9, 1, 13, 20, 30),
-                    'tz': tz,
-                })
+                ctx = Context(
+                    {
+                        "dt": datetime.datetime(2011, 9, 1, 13, 20, 30),
+                        "tz": tz,
+                    }
+                )
                 self.assertEqual(tpl.render(ctx), "2011-09-01T12:20:30+02:00")
 
     def test_localtime_templatetag_invalid_argument(self):
@@ -950,18 +1088,22 @@ class TemplateTests(SimpleTestCase):
         """
         Test the |localtime, |utc, and |timezone filters on bad inputs.
         """
-        tpl = Template("{% load tz %}{{ dt }}|{{ dt|localtime }}|{{ dt|utc }}|{{ dt|timezone:tz }}")
+        tpl = Template(
+            "{% load tz %}{{ dt }}|{{ dt|localtime }}|{{ dt|utc }}|{{ dt|timezone:tz }}"
+        )
         with self.settings(USE_TZ=True):
             # bad datetime value
-            ctx = Context({'dt': None, 'tz': ICT})
+            ctx = Context({"dt": None, "tz": ICT})
             self.assertEqual(tpl.render(ctx), "None|||")
-            ctx = Context({'dt': 'not a date', 'tz': ICT})
+            ctx = Context({"dt": "not a date", "tz": ICT})
             self.assertEqual(tpl.render(ctx), "not a date|||")
             # bad timezone value
             tpl = Template("{% load tz %}{{ dt|timezone:tz }}")
-            ctx = Context({'dt': datetime.datetime(2011, 9, 1, 13, 20, 30), 'tz': None})
+            ctx = Context({"dt": datetime.datetime(2011, 9, 1, 13, 20, 30), "tz": None})
             self.assertEqual(tpl.render(ctx), "")
-            ctx = Context({'dt': datetime.datetime(2011, 9, 1, 13, 20, 30), 'tz': 'not a tz'})
+            ctx = Context(
+                {"dt": datetime.datetime(2011, 9, 1, 13, 20, 30), "tz": "not a tz"}
+            )
             self.assertEqual(tpl.render(ctx), "")
 
     @requires_tz_support
@@ -979,14 +1121,16 @@ class TemplateTests(SimpleTestCase):
             "{% endtimezone %}"
             "{% endtimezone %}"
         )
-        ctx = Context({
-            'dt': datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC),
-            'tz1': ICT,
-            'tz2': None,
-        })
+        ctx = Context(
+            {
+                "dt": datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC),
+                "tz1": ICT,
+                "tz2": None,
+            }
+        )
         self.assertEqual(
             tpl.render(ctx),
-            "2011-09-01T13:20:30+03:00|2011-09-01T17:20:30+07:00|2011-09-01T13:20:30+03:00"
+            "2011-09-01T13:20:30+03:00|2011-09-01T17:20:30+07:00|2011-09-01T13:20:30+03:00",
         )
 
     def test_timezone_templatetag_with_iana(self):
@@ -996,19 +1140,23 @@ class TemplateTests(SimpleTestCase):
         tpl = Template("{% load tz %}{% timezone tz %}{{ dt }}{% endtimezone %}")
 
         # Use a IANA timezone as argument
-        for tz in get_timezones('Europe/Paris'):
+        for tz in get_timezones("Europe/Paris"):
             with self.subTest(repr(tz)):
-                ctx = Context({
-                    'dt': datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT),
-                    'tz': tz,
-                })
+                ctx = Context(
+                    {
+                        "dt": datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT),
+                        "tz": tz,
+                    }
+                )
                 self.assertEqual(tpl.render(ctx), "2011-09-01T12:20:30+02:00")
 
         # Use a IANA timezone name as argument
-        ctx = Context({
-            'dt': datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT),
-            'tz': 'Europe/Paris',
-        })
+        ctx = Context(
+            {
+                "dt": datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT),
+                "tz": "Europe/Paris",
+            }
+        )
         self.assertEqual(tpl.render(ctx), "2011-09-01T12:20:30+02:00")
 
     @ignore_warnings(category=RemovedInDjango50Warning)
@@ -1016,17 +1164,25 @@ class TemplateTests(SimpleTestCase):
         with self.assertRaises(TemplateSyntaxError):
             Template("{% load tz %}{% timezone %}{% endtimezone %}").render()
         with self.assertRaises(zoneinfo.ZoneInfoNotFoundError):
-            Template("{% load tz %}{% timezone tz %}{% endtimezone %}").render(Context({'tz': 'foobar'}))
+            Template("{% load tz %}{% timezone tz %}{% endtimezone %}").render(
+                Context({"tz": "foobar"})
+            )
         if pytz is not None:
-            with override_settings(USE_DEPRECATED_PYTZ=True), self.assertRaises(pytz.UnknownTimeZoneError):
-                Template("{% load tz %}{% timezone tz %}{% endtimezone %}").render(Context({'tz': 'foobar'}))
-
-    @skipIf(sys.platform == 'win32', "Windows uses non-standard time zone names")
+            with override_settings(USE_DEPRECATED_PYTZ=True), self.assertRaises(
+                pytz.UnknownTimeZoneError
+            ):
+                Template("{% load tz %}{% timezone tz %}{% endtimezone %}").render(
+                    Context({"tz": "foobar"})
+                )
+
+    @skipIf(sys.platform == "win32", "Windows uses non-standard time zone names")
     def test_get_current_timezone_templatetag(self):
         """
         Test the {% get_current_timezone %} templatetag.
         """
-        tpl = Template("{% load tz %}{% get_current_timezone as time_zone %}{{ time_zone }}")
+        tpl = Template(
+            "{% load tz %}{% get_current_timezone as time_zone %}{{ time_zone }}"
+        )
 
         self.assertEqual(tpl.render(Context()), "Africa/Nairobi")
         with timezone.override(UTC):
@@ -1037,16 +1193,18 @@ class TemplateTests(SimpleTestCase):
             "{% endtimezone %}{{ time_zone }}"
         )
 
-        self.assertEqual(tpl.render(Context({'tz': ICT})), "+0700")
+        self.assertEqual(tpl.render(Context({"tz": ICT})), "+0700")
         with timezone.override(UTC):
-            self.assertEqual(tpl.render(Context({'tz': ICT})), "+0700")
+            self.assertEqual(tpl.render(Context({"tz": ICT})), "+0700")
 
     def test_get_current_timezone_templatetag_with_iana(self):
         """
         Test the {% get_current_timezone %} templatetag with pytz.
         """
-        tpl = Template("{% load tz %}{% get_current_timezone as time_zone %}{{ time_zone }}")
-        for tz in get_timezones('Europe/Paris'):
+        tpl = Template(
+            "{% load tz %}{% get_current_timezone as time_zone %}{{ time_zone }}"
+        )
+        for tz in get_timezones("Europe/Paris"):
             with self.subTest(repr(tz)):
                 with timezone.override(tz):
                     self.assertEqual(tpl.render(Context()), "Europe/Paris")
@@ -1063,7 +1221,7 @@ class TemplateTests(SimpleTestCase):
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
             Template("{% load tz %}{% get_current_timezone %}").render()
 
-    @skipIf(sys.platform == 'win32', "Windows uses non-standard time zone names")
+    @skipIf(sys.platform == "win32", "Windows uses non-standard time zone names")
     def test_tz_template_context_processor(self):
         """
         Test the django.template.context_processors.tz template context processor.
@@ -1071,13 +1229,15 @@ class TemplateTests(SimpleTestCase):
         tpl = Template("{{ TIME_ZONE }}")
         context = Context()
         self.assertEqual(tpl.render(context), "")
-        request_context = RequestContext(HttpRequest(), processors=[context_processors.tz])
+        request_context = RequestContext(
+            HttpRequest(), processors=[context_processors.tz]
+        )
         self.assertEqual(tpl.render(request_context), "Africa/Nairobi")
 
     @requires_tz_support
     def test_date_and_time_template_filters(self):
         tpl = Template("{{ dt|date:'Y-m-d' }} at {{ dt|time:'H:i:s' }}")
-        ctx = Context({'dt': datetime.datetime(2011, 9, 1, 20, 20, 20, tzinfo=UTC)})
+        ctx = Context({"dt": datetime.datetime(2011, 9, 1, 20, 20, 20, tzinfo=UTC)})
         self.assertEqual(tpl.render(ctx), "2011-09-01 at 23:20:20")
         with timezone.override(ICT):
             self.assertEqual(tpl.render(ctx), "2011-09-02 at 03:20:20")
@@ -1087,7 +1247,7 @@ class TemplateTests(SimpleTestCase):
             "{% load tz %}{% localtime off %}{{ dt|date:'Y-m-d' }} at "
             "{{ dt|time:'H:i:s' }}{% endlocaltime %}"
         )
-        ctx = Context({'dt': datetime.datetime(2011, 9, 1, 20, 20, 20, tzinfo=UTC)})
+        ctx = Context({"dt": datetime.datetime(2011, 9, 1, 20, 20, 20, tzinfo=UTC)})
         self.assertEqual(tpl.render(ctx), "2011-09-01 at 20:20:20")
         with timezone.override(ICT):
             self.assertEqual(tpl.render(ctx), "2011-09-01 at 20:20:20")
@@ -1095,7 +1255,7 @@ class TemplateTests(SimpleTestCase):
     @requires_tz_support
     def test_now_template_tag_uses_current_time_zone(self):
         # Regression for #17343
-        tpl = Template("{% now \"O\" %}")
+        tpl = Template('{% now "O" %}')
         self.assertEqual(tpl.render(Context({})), "+0300")
         with timezone.override(ICT):
             self.assertEqual(tpl.render(Context({})), "+0700")
@@ -1104,7 +1264,9 @@ class TemplateTests(SimpleTestCase):
 # RemovedInDjango50Warning: When the deprecation ends, remove setUpClass() and
 # USE_L10N=False. The tests should remain because format-related settings will
 # take precedence over locale-dictated formats.
-@override_settings(DATETIME_FORMAT='c', TIME_ZONE='Africa/Nairobi', USE_L10N=False, USE_TZ=False)
+@override_settings(
+    DATETIME_FORMAT="c", TIME_ZONE="Africa/Nairobi", USE_L10N=False, USE_TZ=False
+)
 class LegacyFormsTests(TestCase):
     @classmethod
     def setUpClass(cls):
@@ -1112,35 +1274,45 @@ class LegacyFormsTests(TestCase):
             super().setUpClass()
 
     def test_form(self):
-        form = EventForm({'dt': '2011-09-01 13:20:30'})
+        form = EventForm({"dt": "2011-09-01 13:20:30"})
         self.assertTrue(form.is_valid())
-        self.assertEqual(form.cleaned_data['dt'], datetime.datetime(2011, 9, 1, 13, 20, 30))
+        self.assertEqual(
+            form.cleaned_data["dt"], datetime.datetime(2011, 9, 1, 13, 20, 30)
+        )
 
     def test_form_with_non_existent_time(self):
-        form = EventForm({'dt': '2011-03-27 02:30:00'})
-        for tz in get_timezones('Europe/Paris'):
+        form = EventForm({"dt": "2011-03-27 02:30:00"})
+        for tz in get_timezones("Europe/Paris"):
             with self.subTest(repr(tz)):
                 with timezone.override(tz):
                     # This is a bug.
                     self.assertTrue(form.is_valid())
-                    self.assertEqual(form.cleaned_data['dt'], datetime.datetime(2011, 3, 27, 2, 30, 0))
+                    self.assertEqual(
+                        form.cleaned_data["dt"],
+                        datetime.datetime(2011, 3, 27, 2, 30, 0),
+                    )
 
     def test_form_with_ambiguous_time(self):
-        form = EventForm({'dt': '2011-10-30 02:30:00'})
-        for tz in get_timezones('Europe/Paris'):
+        form = EventForm({"dt": "2011-10-30 02:30:00"})
+        for tz in get_timezones("Europe/Paris"):
             with self.subTest(repr(tz)):
                 with timezone.override(tz):
                     # This is a bug.
                     self.assertTrue(form.is_valid())
-                    self.assertEqual(form.cleaned_data['dt'], datetime.datetime(2011, 10, 30, 2, 30, 0))
+                    self.assertEqual(
+                        form.cleaned_data["dt"],
+                        datetime.datetime(2011, 10, 30, 2, 30, 0),
+                    )
 
     def test_split_form(self):
-        form = EventSplitForm({'dt_0': '2011-09-01', 'dt_1': '13:20:30'})
+        form = EventSplitForm({"dt_0": "2011-09-01", "dt_1": "13:20:30"})
         self.assertTrue(form.is_valid())
-        self.assertEqual(form.cleaned_data['dt'], datetime.datetime(2011, 9, 1, 13, 20, 30))
+        self.assertEqual(
+            form.cleaned_data["dt"], datetime.datetime(2011, 9, 1, 13, 20, 30)
+        )
 
     def test_model_form(self):
-        EventModelForm({'dt': '2011-09-01 13:20:30'}).save()
+        EventModelForm({"dt": "2011-09-01 13:20:30"}).save()
         e = Event.objects.get()
         self.assertEqual(e.dt, datetime.datetime(2011, 9, 1, 13, 20, 30))
 
@@ -1148,7 +1320,9 @@ class LegacyFormsTests(TestCase):
 # RemovedInDjango50Warning: When the deprecation ends, remove setUpClass() and
 # USE_L10N=False. The tests should remain because format-related settings will
 # take precedence over locale-dictated formats.
-@override_settings(DATETIME_FORMAT='c', TIME_ZONE='Africa/Nairobi', USE_L10N=False, USE_TZ=True)
+@override_settings(
+    DATETIME_FORMAT="c", TIME_ZONE="Africa/Nairobi", USE_L10N=False, USE_TZ=True
+)
 class NewFormsTests(TestCase):
     @classmethod
     def setUpClass(cls):
@@ -1157,73 +1331,88 @@ class NewFormsTests(TestCase):
 
     @requires_tz_support
     def test_form(self):
-        form = EventForm({'dt': '2011-09-01 13:20:30'})
+        form = EventForm({"dt": "2011-09-01 13:20:30"})
         self.assertTrue(form.is_valid())
-        self.assertEqual(form.cleaned_data['dt'], datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC))
+        self.assertEqual(
+            form.cleaned_data["dt"],
+            datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC),
+        )
 
     def test_form_with_other_timezone(self):
-        form = EventForm({'dt': '2011-09-01 17:20:30'})
+        form = EventForm({"dt": "2011-09-01 17:20:30"})
         with timezone.override(ICT):
             self.assertTrue(form.is_valid())
-            self.assertEqual(form.cleaned_data['dt'], datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC))
+            self.assertEqual(
+                form.cleaned_data["dt"],
+                datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC),
+            )
 
     def test_form_with_non_existent_time(self):
-        for tz in get_timezones('Europe/Paris'):
+        for tz in get_timezones("Europe/Paris"):
             with self.subTest(repr(tz)):
                 with timezone.override(tz):
-                    form = EventForm({'dt': '2011-03-27 02:30:00'})
+                    form = EventForm({"dt": "2011-03-27 02:30:00"})
                     self.assertFalse(form.is_valid())
                     self.assertEqual(
-                        form.errors['dt'], [
-                            '2011-03-27 02:30:00 couldn’t be interpreted in time zone '
-                            'Europe/Paris; it may be ambiguous or it may not exist.'
-                        ]
+                        form.errors["dt"],
+                        [
+                            "2011-03-27 02:30:00 couldn’t be interpreted in time zone "
+                            "Europe/Paris; it may be ambiguous or it may not exist."
+                        ],
                     )
 
     def test_form_with_ambiguous_time(self):
-        for tz in get_timezones('Europe/Paris'):
+        for tz in get_timezones("Europe/Paris"):
             with self.subTest(repr(tz)):
                 with timezone.override(tz):
-                    form = EventForm({'dt': '2011-10-30 02:30:00'})
+                    form = EventForm({"dt": "2011-10-30 02:30:00"})
                     self.assertFalse(form.is_valid())
                     self.assertEqual(
-                        form.errors['dt'], [
-                            '2011-10-30 02:30:00 couldn’t be interpreted in time zone '
-                            'Europe/Paris; it may be ambiguous or it may not exist.'
-                        ]
+                        form.errors["dt"],
+                        [
+                            "2011-10-30 02:30:00 couldn’t be interpreted in time zone "
+                            "Europe/Paris; it may be ambiguous or it may not exist."
+                        ],
                     )
 
     @requires_tz_support
     def test_split_form(self):
-        form = EventSplitForm({'dt_0': '2011-09-01', 'dt_1': '13:20:30'})
+        form = EventSplitForm({"dt_0": "2011-09-01", "dt_1": "13:20:30"})
         self.assertTrue(form.is_valid())
-        self.assertEqual(form.cleaned_data['dt'], datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC))
+        self.assertEqual(
+            form.cleaned_data["dt"],
+            datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC),
+        )
 
     @requires_tz_support
     def test_localized_form(self):
-        form = EventLocalizedForm(initial={'dt': datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT)})
+        form = EventLocalizedForm(
+            initial={"dt": datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT)}
+        )
         with timezone.override(ICT):
             self.assertIn("2011-09-01 17:20:30", str(form))
 
     @requires_tz_support
     def test_model_form(self):
-        EventModelForm({'dt': '2011-09-01 13:20:30'}).save()
+        EventModelForm({"dt": "2011-09-01 13:20:30"}).save()
         e = Event.objects.get()
         self.assertEqual(e.dt, datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC))
 
     @requires_tz_support
     def test_localized_model_form(self):
-        form = EventLocalizedModelForm(instance=Event(dt=datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT)))
+        form = EventLocalizedModelForm(
+            instance=Event(dt=datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT))
+        )
         with timezone.override(ICT):
             self.assertIn("2011-09-01 17:20:30", str(form))
 
 
 @override_settings(
-    DATETIME_FORMAT='c',
-    TIME_ZONE='Africa/Nairobi',
+    DATETIME_FORMAT="c",
+    TIME_ZONE="Africa/Nairobi",
     USE_L10N=False,
     USE_TZ=True,
-    ROOT_URLCONF='timezones.urls',
+    ROOT_URLCONF="timezones.urls",
 )
 class AdminTests(TestCase):
     @classmethod
@@ -1234,10 +1423,15 @@ class AdminTests(TestCase):
     @classmethod
     def setUpTestData(cls):
         cls.u1 = User.objects.create_user(
-            password='secret',
+            password="secret",
             last_login=datetime.datetime(2007, 5, 30, 13, 20, 10, tzinfo=UTC),
-            is_superuser=True, username='super', first_name='Super', last_name='User',
-            email='super@example.com', is_staff=True, is_active=True,
+            is_superuser=True,
+            username="super",
+            first_name="Super",
+            last_name="User",
+            email="super@example.com",
+            is_staff=True,
+            is_active=True,
             date_joined=datetime.datetime(2007, 5, 30, 13, 20, 10, tzinfo=UTC),
         )
 
@@ -1246,27 +1440,39 @@ class AdminTests(TestCase):
 
     @requires_tz_support
     def test_changelist(self):
-        e = Event.objects.create(dt=datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC))
-        response = self.client.get(reverse('admin_tz:timezones_event_changelist'))
+        e = Event.objects.create(
+            dt=datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC)
+        )
+        response = self.client.get(reverse("admin_tz:timezones_event_changelist"))
         self.assertContains(response, e.dt.astimezone(EAT).isoformat())
 
     def test_changelist_in_other_timezone(self):
-        e = Event.objects.create(dt=datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC))
+        e = Event.objects.create(
+            dt=datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC)
+        )
         with timezone.override(ICT):
-            response = self.client.get(reverse('admin_tz:timezones_event_changelist'))
+            response = self.client.get(reverse("admin_tz:timezones_event_changelist"))
         self.assertContains(response, e.dt.astimezone(ICT).isoformat())
 
     @requires_tz_support
     def test_change_editable(self):
-        e = Event.objects.create(dt=datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC))
-        response = self.client.get(reverse('admin_tz:timezones_event_change', args=(e.pk,)))
+        e = Event.objects.create(
+            dt=datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC)
+        )
+        response = self.client.get(
+            reverse("admin_tz:timezones_event_change", args=(e.pk,))
+        )
         self.assertContains(response, e.dt.astimezone(EAT).date().isoformat())
         self.assertContains(response, e.dt.astimezone(EAT).time().isoformat())
 
     def test_change_editable_in_other_timezone(self):
-        e = Event.objects.create(dt=datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC))
+        e = Event.objects.create(
+            dt=datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC)
+        )
         with timezone.override(ICT):
-            response = self.client.get(reverse('admin_tz:timezones_event_change', args=(e.pk,)))
+            response = self.client.get(
+                reverse("admin_tz:timezones_event_change", args=(e.pk,))
+            )
         self.assertContains(response, e.dt.astimezone(ICT).date().isoformat())
         self.assertContains(response, e.dt.astimezone(ICT).time().isoformat())
 
@@ -1275,7 +1481,9 @@ class AdminTests(TestCase):
         Timestamp.objects.create()
         # re-fetch the object for backends that lose microseconds (MySQL)
         t = Timestamp.objects.get()
-        response = self.client.get(reverse('admin_tz:timezones_timestamp_change', args=(t.pk,)))
+        response = self.client.get(
+            reverse("admin_tz:timezones_timestamp_change", args=(t.pk,))
+        )
         self.assertContains(response, t.created.astimezone(EAT).isoformat())
 
     def test_change_readonly_in_other_timezone(self):
@@ -1283,5 +1491,7 @@ class AdminTests(TestCase):
         # re-fetch the object for backends that lose microseconds (MySQL)
         t = Timestamp.objects.get()
         with timezone.override(ICT):
-            response = self.client.get(reverse('admin_tz:timezones_timestamp_change', args=(t.pk,)))
+            response = self.client.get(
+                reverse("admin_tz:timezones_timestamp_change", args=(t.pk,))
+            )
         self.assertContains(response, t.created.astimezone(ICT).isoformat())
diff --git a/tests/timezones/urls.py b/tests/timezones/urls.py
index 3955b5354f..d9e99f48c5 100644
--- a/tests/timezones/urls.py
+++ b/tests/timezones/urls.py
@@ -3,5 +3,5 @@ from django.urls import path
 from . import admin as tz_admin  # NOQA: register tz_admin
 
 urlpatterns = [
-    path('admin/', tz_admin.site.urls),
+    path("admin/", tz_admin.site.urls),
 ]