Refs #33476 -- Reformatted code with Black.

2 files changed, 184 insertions, 144 deletions

diff --git a/tests/extra_regress/models.py b/tests/extra_regress/models.py
index 2847f8172b..2122bae7ae 100644
--- a/tests/extra_regress/models.py
+++ b/tests/extra_regress/models.py
@@ -6,12 +6,14 @@ from django.db import models
 
 
 class RevisionableModel(models.Model):
-    base = models.ForeignKey('self', models.SET_NULL, null=True)
+    base = models.ForeignKey("self", models.SET_NULL, null=True)
     title = models.CharField(blank=True, max_length=255)
     when = models.DateTimeField(default=datetime.datetime.now)
 
     def save(self, *args, force_insert=None, force_update=None, **kwargs):
-        super().save(*args, force_insert=force_insert, force_update=force_update, **kwargs)
+        super().save(
+            *args, force_insert=force_insert, force_update=force_update, **kwargs
+        )
         if not self.base:
             self.base = self
             super().save(*args, **kwargs)
@@ -33,4 +35,4 @@ class TestObject(models.Model):
     third = models.CharField(max_length=20)
 
     def __str__(self):
-        return 'TestObject: %s,%s,%s' % (self.first, self.second, self.third)
+        return "TestObject: %s,%s,%s" % (self.first, self.second, self.third)
diff --git a/tests/extra_regress/tests.py b/tests/extra_regress/tests.py
index d459ae6344..51ba601c1d 100644
--- a/tests/extra_regress/tests.py
+++ b/tests/extra_regress/tests.py
@@ -7,13 +7,10 @@ from .models import Order, RevisionableModel, TestObject
 
 
 class ExtraRegressTests(TestCase):
-
     @classmethod
     def setUpTestData(cls):
         cls.u = User.objects.create_user(
-            username="fred",
-            password="secret",
-            email="fred@example.com"
+            username="fred", password="secret", email="fred@example.com"
         )
 
     def test_regression_7314_7372(self):
@@ -21,8 +18,7 @@ class ExtraRegressTests(TestCase):
         Regression tests for #7314 and #7372
         """
         rm = RevisionableModel.objects.create(
-            title='First Revision',
-            when=datetime.datetime(2008, 9, 28, 10, 30, 0)
+            title="First Revision", when=datetime.datetime(2008, 9, 28, 10, 30, 0)
         )
         self.assertEqual(rm.pk, rm.base.pk)
 
@@ -31,53 +27,60 @@ class ExtraRegressTests(TestCase):
         rm.when = datetime.datetime(2008, 9, 28, 14, 25, 0)
         rm2.save()
 
-        self.assertEqual(rm2.title, 'Second Revision')
-        self.assertEqual(rm2.base.title, 'First Revision')
+        self.assertEqual(rm2.title, "Second Revision")
+        self.assertEqual(rm2.base.title, "First Revision")
 
         self.assertNotEqual(rm2.pk, rm.pk)
         self.assertEqual(rm2.base.pk, rm.pk)
 
         # Queryset to match most recent revision:
         qs = RevisionableModel.objects.extra(
-            where=["%(table)s.id IN (SELECT MAX(rev.id) FROM %(table)s rev GROUP BY rev.base_id)" % {
-                'table': RevisionableModel._meta.db_table,
-            }]
+            where=[
+                "%(table)s.id IN (SELECT MAX(rev.id) FROM %(table)s rev GROUP BY rev.base_id)"
+                % {
+                    "table": RevisionableModel._meta.db_table,
+                }
+            ]
         )
 
         self.assertQuerysetEqual(
-            qs, [('Second Revision', 'First Revision')],
-            transform=lambda r: (r.title, r.base.title)
+            qs,
+            [("Second Revision", "First Revision")],
+            transform=lambda r: (r.title, r.base.title),
         )
 
         # Queryset to search for string in title:
         qs2 = RevisionableModel.objects.filter(title__contains="Revision")
         self.assertQuerysetEqual(
-            qs2, [
-                ('First Revision', 'First Revision'),
-                ('Second Revision', 'First Revision'),
+            qs2,
+            [
+                ("First Revision", "First Revision"),
+                ("Second Revision", "First Revision"),
             ],
             transform=lambda r: (r.title, r.base.title),
-            ordered=False
+            ordered=False,
         )
 
         # Following queryset should return the most recent revision:
         self.assertQuerysetEqual(
             qs & qs2,
-            [('Second Revision', 'First Revision')],
+            [("Second Revision", "First Revision")],
             transform=lambda r: (r.title, r.base.title),
-            ordered=False
+            ordered=False,
         )
 
     def test_extra_stay_tied(self):
         # Extra select parameters should stay tied to their corresponding
         # select portions. Applies when portions are updated or otherwise
         # moved around.
-        qs = User.objects.extra(select={'alpha': '%s', 'beta': "2", 'gamma': '%s'}, select_params=(1, 3))
+        qs = User.objects.extra(
+            select={"alpha": "%s", "beta": "2", "gamma": "%s"}, select_params=(1, 3)
+        )
         qs = qs.extra(select={"beta": 4})
         qs = qs.extra(select={"alpha": "%s"}, select_params=[5])
         self.assertEqual(
-            list(qs.filter(id=self.u.id).values('alpha', 'beta', 'gamma')),
-            [{'alpha': 5, 'beta': 4, 'gamma': 3}]
+            list(qs.filter(id=self.u.id).values("alpha", "beta", "gamma")),
+            [{"alpha": 5, "beta": 4, "gamma": 3}],
         )
 
     def test_regression_7957(self):
@@ -87,17 +90,21 @@ class ExtraRegressTests(TestCase):
         internal dictionary must remain sorted.
         """
         self.assertEqual(
-            (User.objects
-                .extra(select={"alpha": "%s"}, select_params=(1,))
-                .extra(select={"beta": "%s"}, select_params=(2,))[0].alpha),
-            1
+            (
+                User.objects.extra(select={"alpha": "%s"}, select_params=(1,))
+                .extra(select={"beta": "%s"}, select_params=(2,))[0]
+                .alpha
+            ),
+            1,
         )
 
         self.assertEqual(
-            (User.objects
-                .extra(select={"beta": "%s"}, select_params=(1,))
-                .extra(select={"alpha": "%s"}, select_params=(2,))[0].alpha),
-            2
+            (
+                User.objects.extra(select={"beta": "%s"}, select_params=(1,))
+                .extra(select={"alpha": "%s"}, select_params=(2,))[0]
+                .alpha
+            ),
+            2,
         )
 
     def test_regression_7961(self):
@@ -107,9 +114,12 @@ class ExtraRegressTests(TestCase):
         query as well.
         """
         self.assertEqual(
-            list(User.objects.extra(select={"alpha": "%s"}, select_params=(-6,))
-                 .filter(id=self.u.id).values_list('id', flat=True)),
-            [self.u.id]
+            list(
+                User.objects.extra(select={"alpha": "%s"}, select_params=(-6,))
+                .filter(id=self.u.id)
+                .values_list("id", flat=True)
+            ),
+            [self.u.id],
         )
 
     def test_regression_8063(self):
@@ -117,7 +127,7 @@ class ExtraRegressTests(TestCase):
         Regression test for #8063: limiting a query shouldn't discard any
         extra() bits.
         """
-        qs = User.objects.all().extra(where=['id=%s'], params=[self.u.id])
+        qs = User.objects.all().extra(where=["id=%s"], params=[self.u.id])
         self.assertSequenceEqual(qs, [self.u])
         self.assertSequenceEqual(qs[:1], [self.u])
 
@@ -129,10 +139,12 @@ class ExtraRegressTests(TestCase):
         should still be present because of the extra() call.
         """
         self.assertQuerysetEqual(
-            (Order.objects
-                .extra(where=["username=%s"], params=["fred"], tables=["auth_user"])
-                .order_by('created_by')),
-            []
+            (
+                Order.objects.extra(
+                    where=["username=%s"], params=["fred"], tables=["auth_user"]
+                ).order_by("created_by")
+            ),
+            [],
         )
 
     def test_regression_8819(self):
@@ -141,15 +153,21 @@ class ExtraRegressTests(TestCase):
         should be available to extra(order_by=...).
         """
         self.assertSequenceEqual(
-            User.objects.filter(pk=self.u.id).extra(select={'extra_field': 1}).distinct(),
+            User.objects.filter(pk=self.u.id)
+            .extra(select={"extra_field": 1})
+            .distinct(),
             [self.u],
         )
         self.assertSequenceEqual(
-            User.objects.filter(pk=self.u.id).extra(select={'extra_field': 1}, order_by=['extra_field']),
+            User.objects.filter(pk=self.u.id).extra(
+                select={"extra_field": 1}, order_by=["extra_field"]
+            ),
             [self.u],
         )
         self.assertSequenceEqual(
-            User.objects.filter(pk=self.u.id).extra(select={'extra_field': 1}, order_by=['extra_field']).distinct(),
+            User.objects.filter(pk=self.u.id)
+            .extra(select={"extra_field": 1}, order_by=["extra_field"])
+            .distinct(),
             [self.u],
         )
 
@@ -160,12 +178,13 @@ class ExtraRegressTests(TestCase):
         the result and cause incorrect SQL to be produced otherwise.
         """
         RevisionableModel.objects.create(
-            title='First Revision',
-            when=datetime.datetime(2008, 9, 28, 10, 30, 0)
+            title="First Revision", when=datetime.datetime(2008, 9, 28, 10, 30, 0)
         )
 
         self.assertSequenceEqual(
-            RevisionableModel.objects.extra(select={"the_answer": 'id'}).datetimes('when', 'month'),
+            RevisionableModel.objects.extra(select={"the_answer": "id"}).datetimes(
+                "when", "month"
+            ),
             [datetime.datetime(2008, 9, 1, 0, 0)],
         )
 
@@ -174,179 +193,193 @@ class ExtraRegressTests(TestCase):
         Regression test for #10256... If there is a values() clause, Extra
         columns are only returned if they are explicitly mentioned.
         """
-        obj = TestObject(first='first', second='second', third='third')
+        obj = TestObject(first="first", second="second", third="third")
         obj.save()
 
         self.assertEqual(
             list(
-                TestObject.objects
-                .extra(select={'foo': 'first', 'bar': 'second', 'whiz': 'third'})
-                .values()
+                TestObject.objects.extra(
+                    select={"foo": "first", "bar": "second", "whiz": "third"}
+                ).values()
             ),
-            [{
-                'bar': 'second', 'third': 'third', 'second': 'second', 'whiz': 'third', 'foo': 'first',
-                'id': obj.pk, 'first': 'first'
-            }]
+            [
+                {
+                    "bar": "second",
+                    "third": "third",
+                    "second": "second",
+                    "whiz": "third",
+                    "foo": "first",
+                    "id": obj.pk,
+                    "first": "first",
+                }
+            ],
         )
 
         # Extra clauses after an empty values clause are still included
         self.assertEqual(
             list(
-                TestObject.objects
-                .values()
-                .extra(select={'foo': 'first', 'bar': 'second', 'whiz': 'third'})
+                TestObject.objects.values().extra(
+                    select={"foo": "first", "bar": "second", "whiz": "third"}
+                )
             ),
-            [{
-                'bar': 'second', 'third': 'third', 'second': 'second', 'whiz': 'third', 'foo': 'first',
-                'id': obj.pk, 'first': 'first'
-            }]
+            [
+                {
+                    "bar": "second",
+                    "third": "third",
+                    "second": "second",
+                    "whiz": "third",
+                    "foo": "first",
+                    "id": obj.pk,
+                    "first": "first",
+                }
+            ],
         )
 
         # Extra columns are ignored if not mentioned in the values() clause
         self.assertEqual(
             list(
-                TestObject.objects
-                .extra(select={'foo': 'first', 'bar': 'second', 'whiz': 'third'})
-                .values('first', 'second')
+                TestObject.objects.extra(
+                    select={"foo": "first", "bar": "second", "whiz": "third"}
+                ).values("first", "second")
             ),
-            [{'second': 'second', 'first': 'first'}]
+            [{"second": "second", "first": "first"}],
         )
 
         # Extra columns after a non-empty values() clause are ignored
         self.assertEqual(
             list(
-                TestObject.objects
-                .values('first', 'second')
-                .extra(select={'foo': 'first', 'bar': 'second', 'whiz': 'third'})
+                TestObject.objects.values("first", "second").extra(
+                    select={"foo": "first", "bar": "second", "whiz": "third"}
+                )
             ),
-            [{'second': 'second', 'first': 'first'}]
+            [{"second": "second", "first": "first"}],
         )
 
         # Extra columns can be partially returned
         self.assertEqual(
             list(
-                TestObject.objects
-                .extra(select={'foo': 'first', 'bar': 'second', 'whiz': 'third'})
-                .values('first', 'second', 'foo')
+                TestObject.objects.extra(
+                    select={"foo": "first", "bar": "second", "whiz": "third"}
+                ).values("first", "second", "foo")
             ),
-            [{'second': 'second', 'foo': 'first', 'first': 'first'}]
+            [{"second": "second", "foo": "first", "first": "first"}],
         )
 
         # Also works if only extra columns are included
         self.assertEqual(
             list(
-                TestObject.objects
-                .extra(select={'foo': 'first', 'bar': 'second', 'whiz': 'third'})
-                .values('foo', 'whiz')
+                TestObject.objects.extra(
+                    select={"foo": "first", "bar": "second", "whiz": "third"}
+                ).values("foo", "whiz")
             ),
-            [{'foo': 'first', 'whiz': 'third'}]
+            [{"foo": "first", "whiz": "third"}],
         )
 
         # Values list works the same way
         # All columns are returned for an empty values_list()
         self.assertEqual(
             list(
-                TestObject.objects
-                .extra(select={'foo': 'first', 'bar': 'second', 'whiz': 'third'})
-                .values_list()
+                TestObject.objects.extra(
+                    select={"foo": "first", "bar": "second", "whiz": "third"}
+                ).values_list()
             ),
-            [('first', 'second', 'third', obj.pk, 'first', 'second', 'third')]
+            [("first", "second", "third", obj.pk, "first", "second", "third")],
         )
 
         # Extra columns after an empty values_list() are still included
         self.assertEqual(
             list(
-                TestObject.objects
-                .values_list()
-                .extra(select={'foo': 'first', 'bar': 'second', 'whiz': 'third'})
+                TestObject.objects.values_list().extra(
+                    select={"foo": "first", "bar": "second", "whiz": "third"}
+                )
             ),
-            [('first', 'second', 'third', obj.pk, 'first', 'second', 'third')]
+            [("first", "second", "third", obj.pk, "first", "second", "third")],
         )
 
         # Extra columns ignored completely if not mentioned in values_list()
         self.assertEqual(
             list(
-                TestObject.objects
-                .extra(select={'foo': 'first', 'bar': 'second', 'whiz': 'third'})
-                .values_list('first', 'second')
+                TestObject.objects.extra(
+                    select={"foo": "first", "bar": "second", "whiz": "third"}
+                ).values_list("first", "second")
             ),
-            [('first', 'second')]
+            [("first", "second")],
         )
 
         # Extra columns after a non-empty values_list() clause are ignored completely
         self.assertEqual(
             list(
-                TestObject.objects
-                .values_list('first', 'second')
-                .extra(select={'foo': 'first', 'bar': 'second', 'whiz': 'third'})
+                TestObject.objects.values_list("first", "second").extra(
+                    select={"foo": "first", "bar": "second", "whiz": "third"}
+                )
             ),
-            [('first', 'second')]
+            [("first", "second")],
         )
 
         self.assertEqual(
             list(
-                TestObject.objects
-                .extra(select={'foo': 'first', 'bar': 'second', 'whiz': 'third'})
-                .values_list('second', flat=True)
+                TestObject.objects.extra(
+                    select={"foo": "first", "bar": "second", "whiz": "third"}
+                ).values_list("second", flat=True)
             ),
-            ['second']
+            ["second"],
         )
 
         # Only the extra columns specified in the values_list() are returned
         self.assertEqual(
             list(
-                TestObject.objects
-                .extra(select={'foo': 'first', 'bar': 'second', 'whiz': 'third'})
-                .values_list('first', 'second', 'whiz')
+                TestObject.objects.extra(
+                    select={"foo": "first", "bar": "second", "whiz": "third"}
+                ).values_list("first", "second", "whiz")
             ),
-            [('first', 'second', 'third')]
+            [("first", "second", "third")],
         )
 
         # ...also works if only extra columns are included
         self.assertEqual(
             list(
-                TestObject.objects
-                .extra(select={'foo': 'first', 'bar': 'second', 'whiz': 'third'})
-                .values_list('foo', 'whiz')
+                TestObject.objects.extra(
+                    select={"foo": "first", "bar": "second", "whiz": "third"}
+                ).values_list("foo", "whiz")
             ),
-            [('first', 'third')]
+            [("first", "third")],
         )
 
         self.assertEqual(
             list(
-                TestObject.objects
-                .extra(select={'foo': 'first', 'bar': 'second', 'whiz': 'third'})
-                .values_list('whiz', flat=True)
+                TestObject.objects.extra(
+                    select={"foo": "first", "bar": "second", "whiz": "third"}
+                ).values_list("whiz", flat=True)
             ),
-            ['third']
+            ["third"],
         )
 
         # ... and values are returned in the order they are specified
         self.assertEqual(
             list(
-                TestObject.objects
-                .extra(select={'foo': 'first', 'bar': 'second', 'whiz': 'third'})
-                .values_list('whiz', 'foo')
+                TestObject.objects.extra(
+                    select={"foo": "first", "bar": "second", "whiz": "third"}
+                ).values_list("whiz", "foo")
             ),
-            [('third', 'first')]
+            [("third", "first")],
         )
 
         self.assertEqual(
             list(
-                TestObject.objects
-                .extra(select={'foo': 'first', 'bar': 'second', 'whiz': 'third'})
-                .values_list('first', 'id')
+                TestObject.objects.extra(
+                    select={"foo": "first", "bar": "second", "whiz": "third"}
+                ).values_list("first", "id")
             ),
-            [('first', obj.pk)]
+            [("first", obj.pk)],
         )
 
         self.assertEqual(
             list(
-                TestObject.objects
-                .extra(select={'foo': 'first', 'bar': 'second', 'whiz': 'third'})
-                .values_list('whiz', 'first', 'bar', 'id')
+                TestObject.objects.extra(
+                    select={"foo": "first", "bar": "second", "whiz": "third"}
+                ).values_list("whiz", "first", "bar", "id")
             ),
-            [('third', 'first', 'second', obj.pk)]
+            [("third", "first", "second", obj.pk)],
         )
 
     def test_regression_10847(self):
@@ -356,35 +389,36 @@ class ExtraRegressTests(TestCase):
         producing correct output without requiring full evaluation and
         execution of the inner query.
         """
-        obj = TestObject(first='first', second='second', third='third')
+        obj = TestObject(first="first", second="second", third="third")
         obj.save()
 
         self.assertEqual(
-            list(TestObject.objects.extra(select={'extra': 1}).values('pk')),
-            [{'pk': obj.pk}]
+            list(TestObject.objects.extra(select={"extra": 1}).values("pk")),
+            [{"pk": obj.pk}],
         )
 
         self.assertSequenceEqual(
             TestObject.objects.filter(
-                pk__in=TestObject.objects.extra(select={'extra': 1}).values('pk')
+                pk__in=TestObject.objects.extra(select={"extra": 1}).values("pk")
             ),
             [obj],
         )
 
         self.assertEqual(
-            list(TestObject.objects.values('pk').extra(select={'extra': 1})),
-            [{'pk': obj.pk}]
+            list(TestObject.objects.values("pk").extra(select={"extra": 1})),
+            [{"pk": obj.pk}],
         )
 
         self.assertSequenceEqual(
             TestObject.objects.filter(
-                pk__in=TestObject.objects.values('pk').extra(select={'extra': 1})
+                pk__in=TestObject.objects.values("pk").extra(select={"extra": 1})
             ),
             [obj],
         )
 
         self.assertSequenceEqual(
-            TestObject.objects.filter(pk=obj.pk) | TestObject.objects.extra(where=["id > %s"], params=[obj.pk]),
+            TestObject.objects.filter(pk=obj.pk)
+            | TestObject.objects.extra(where=["id > %s"], params=[obj.pk]),
             [obj],
         )
 
@@ -394,20 +428,20 @@ class ExtraRegressTests(TestCase):
         contain OR operations.
         """
         # Test Case 1: should appear in queryset.
-        t1 = TestObject.objects.create(first='a', second='a', third='a')
+        t1 = TestObject.objects.create(first="a", second="a", third="a")
         # Test Case 2: should appear in queryset.
-        t2 = TestObject.objects.create(first='b', second='a', third='a')
+        t2 = TestObject.objects.create(first="b", second="a", third="a")
         # Test Case 3: should not appear in queryset, bug case.
-        t = TestObject(first='a', second='a', third='b')
+        t = TestObject(first="a", second="a", third="b")
         t.save()
         # Test Case 4: should not appear in queryset.
-        t = TestObject(first='b', second='a', third='b')
+        t = TestObject(first="b", second="a", third="b")
         t.save()
         # Test Case 5: should not appear in queryset.
-        t = TestObject(first='b', second='b', third='a')
+        t = TestObject(first="b", second="b", third="a")
         t.save()
         # Test Case 6: should not appear in queryset, bug case.
-        t = TestObject(first='a', second='b', third='b')
+        t = TestObject(first="a", second="b", third="b")
         t.save()
 
         self.assertCountEqual(
@@ -418,14 +452,18 @@ class ExtraRegressTests(TestCase):
         )
 
     def test_extra_values_distinct_ordering(self):
-        t1 = TestObject.objects.create(first='a', second='a', third='a')
-        t2 = TestObject.objects.create(first='a', second='b', third='b')
-        qs = TestObject.objects.extra(
-            select={'second_extra': 'second'}
-        ).values_list('id', flat=True).distinct()
-        self.assertSequenceEqual(qs.order_by('second_extra'), [t1.pk, t2.pk])
-        self.assertSequenceEqual(qs.order_by('-second_extra'), [t2.pk, t1.pk])
+        t1 = TestObject.objects.create(first="a", second="a", third="a")
+        t2 = TestObject.objects.create(first="a", second="b", third="b")
+        qs = (
+            TestObject.objects.extra(select={"second_extra": "second"})
+            .values_list("id", flat=True)
+            .distinct()
+        )
+        self.assertSequenceEqual(qs.order_by("second_extra"), [t1.pk, t2.pk])
+        self.assertSequenceEqual(qs.order_by("-second_extra"), [t2.pk, t1.pk])
         # Note: the extra ordering must appear in select clause, so we get two
         # non-distinct results here (this is on purpose, see #7070).
         # Extra select doesn't appear in result values.
-        self.assertSequenceEqual(qs.order_by('-second_extra').values_list('first'), [('a',), ('a',)])
+        self.assertSequenceEqual(
+            qs.order_by("-second_extra").values_list("first"), [("a",), ("a",)]
+        )