Refs #33476 -- Reformatted code with Black.

2 files changed, 131 insertions, 68 deletions

diff --git a/tests/select_related_onetoone/models.py b/tests/select_related_onetoone/models.py
index aefa3518a9..5ffb6bfd8c 100644
--- a/tests/select_related_onetoone/models.py
+++ b/tests/select_related_onetoone/models.py
@@ -70,7 +70,9 @@ class Child4(Child1):
 class LinkedList(models.Model):
     name = models.CharField(max_length=50)
     previous_item = models.OneToOneField(
-        'self', models.CASCADE,
-        related_name='next_item',
-        blank=True, null=True,
+        "self",
+        models.CASCADE,
+        related_name="next_item",
+        blank=True,
+        null=True,
     )
diff --git a/tests/select_related_onetoone/tests.py b/tests/select_related_onetoone/tests.py
index a7eee5efb8..8bdfb83fe8 100644
--- a/tests/select_related_onetoone/tests.py
+++ b/tests/select_related_onetoone/tests.py
@@ -3,8 +3,20 @@ from django.db.models import FilteredRelation
 from django.test import SimpleTestCase, TestCase
 
 from .models import (
-    AdvancedUserStat, Child1, Child2, Child3, Child4, Image, LinkedList,
-    Parent1, Parent2, Product, StatDetails, User, UserProfile, UserStat,
+    AdvancedUserStat,
+    Child1,
+    Child2,
+    Child3,
+    Child4,
+    Image,
+    LinkedList,
+    Parent1,
+    Parent2,
+    Product,
+    StatDetails,
+    User,
+    UserProfile,
+    UserStat,
     UserStatResult,
 )
 
@@ -14,13 +26,15 @@ class ReverseSelectRelatedTestCase(TestCase):
     def setUpTestData(cls):
         user = User.objects.create(username="test")
         UserProfile.objects.create(user=user, state="KS", city="Lawrence")
-        results = UserStatResult.objects.create(results='first results')
+        results = UserStatResult.objects.create(results="first results")
         userstat = UserStat.objects.create(user=user, posts=150, results=results)
         StatDetails.objects.create(base_stats=userstat, comments=259)
 
         user2 = User.objects.create(username="bob")
-        results2 = UserStatResult.objects.create(results='moar results')
-        advstat = AdvancedUserStat.objects.create(user=user2, posts=200, karma=5, results=results2)
+        results2 = UserStatResult.objects.create(results="moar results")
+        advstat = AdvancedUserStat.objects.create(
+            user=user2, posts=200, karma=5, results=results2
+        )
         StatDetails.objects.create(base_stats=advstat, comments=250)
         p1 = Parent1(name1="Only Parent1")
         p1.save()
@@ -40,30 +54,36 @@ class ReverseSelectRelatedTestCase(TestCase):
         with self.assertNumQueries(1):
             u = User.objects.select_related("userstat__results").get(username="test")
             self.assertEqual(u.userstat.posts, 150)
-            self.assertEqual(u.userstat.results.results, 'first results')
+            self.assertEqual(u.userstat.results.results, "first results")
 
     def test_follow_two(self):
         with self.assertNumQueries(1):
-            u = User.objects.select_related("userprofile", "userstat").get(username="test")
+            u = User.objects.select_related("userprofile", "userstat").get(
+                username="test"
+            )
             self.assertEqual(u.userprofile.state, "KS")
             self.assertEqual(u.userstat.posts, 150)
 
     def test_follow_two_next_level(self):
         with self.assertNumQueries(1):
-            u = User.objects.select_related("userstat__results", "userstat__statdetails").get(username="test")
-            self.assertEqual(u.userstat.results.results, 'first results')
+            u = User.objects.select_related(
+                "userstat__results", "userstat__statdetails"
+            ).get(username="test")
+            self.assertEqual(u.userstat.results.results, "first results")
             self.assertEqual(u.userstat.statdetails.comments, 259)
 
     def test_forward_and_back(self):
         with self.assertNumQueries(1):
-            stat = UserStat.objects.select_related("user__userprofile").get(user__username="test")
-            self.assertEqual(stat.user.userprofile.state, 'KS')
+            stat = UserStat.objects.select_related("user__userprofile").get(
+                user__username="test"
+            )
+            self.assertEqual(stat.user.userprofile.state, "KS")
             self.assertEqual(stat.user.userstat.posts, 150)
 
     def test_back_and_forward(self):
         with self.assertNumQueries(1):
             u = User.objects.select_related("userstat").get(username="test")
-            self.assertEqual(u.userstat.user.username, 'test')
+            self.assertEqual(u.userstat.user.username, "test")
 
     def test_not_followed_by_default(self):
         with self.assertNumQueries(2):
@@ -72,17 +92,21 @@ class ReverseSelectRelatedTestCase(TestCase):
 
     def test_follow_from_child_class(self):
         with self.assertNumQueries(1):
-            stat = AdvancedUserStat.objects.select_related('user', 'statdetails').get(posts=200)
+            stat = AdvancedUserStat.objects.select_related("user", "statdetails").get(
+                posts=200
+            )
             self.assertEqual(stat.statdetails.comments, 250)
-            self.assertEqual(stat.user.username, 'bob')
+            self.assertEqual(stat.user.username, "bob")
 
     def test_follow_inheritance(self):
         with self.assertNumQueries(1):
-            stat = UserStat.objects.select_related('user', 'advanceduserstat').get(posts=200)
+            stat = UserStat.objects.select_related("user", "advanceduserstat").get(
+                posts=200
+            )
             self.assertEqual(stat.advanceduserstat.posts, 200)
-            self.assertEqual(stat.user.username, 'bob')
+            self.assertEqual(stat.user.username, "bob")
         with self.assertNumQueries(0):
-            self.assertEqual(stat.advanceduserstat.user.username, 'bob')
+            self.assertEqual(stat.advanceduserstat.user.username, "bob")
 
     def test_nullable_relation(self):
         im = Image.objects.create(name="imag1")
@@ -90,8 +114,12 @@ class ReverseSelectRelatedTestCase(TestCase):
         p2 = Product.objects.create(name="Talking Django Plushie")
 
         with self.assertNumQueries(1):
-            result = sorted(Product.objects.select_related("image"), key=lambda x: x.name)
-            self.assertEqual([p.name for p in result], ["Django Plushie", "Talking Django Plushie"])
+            result = sorted(
+                Product.objects.select_related("image"), key=lambda x: x.name
+            )
+            self.assertEqual(
+                [p.name for p in result], ["Django Plushie", "Talking Django Plushie"]
+            )
 
             self.assertEqual(p1.image, im)
             # Check for ticket #13839
@@ -103,7 +131,7 @@ class ReverseSelectRelatedTestCase(TestCase):
         for missing objects on a reverse 1-1 relation.
         """
         with self.assertNumQueries(1):
-            user = User.objects.select_related('userprofile').get(username='bob')
+            user = User.objects.select_related("userprofile").get(username="bob")
             with self.assertRaises(UserProfile.DoesNotExist):
                 user.userprofile
 
@@ -115,31 +143,33 @@ class ReverseSelectRelatedTestCase(TestCase):
         Image.objects.create(name="imag1")
 
         with self.assertNumQueries(1):
-            image = Image.objects.select_related('product').get()
+            image = Image.objects.select_related("product").get()
             with self.assertRaises(Product.DoesNotExist):
                 image.product
 
     def test_parent_only(self):
         with self.assertNumQueries(1):
-            p = Parent1.objects.select_related('child1').get(name1="Only Parent1")
+            p = Parent1.objects.select_related("child1").get(name1="Only Parent1")
         with self.assertNumQueries(0):
             with self.assertRaises(Child1.DoesNotExist):
                 p.child1
 
     def test_multiple_subclass(self):
         with self.assertNumQueries(1):
-            p = Parent1.objects.select_related('child1').get(name1="Child1 Parent1")
-            self.assertEqual(p.child1.name2, 'Child1 Parent2')
+            p = Parent1.objects.select_related("child1").get(name1="Child1 Parent1")
+            self.assertEqual(p.child1.name2, "Child1 Parent2")
 
     def test_onetoone_with_subclass(self):
         with self.assertNumQueries(1):
-            p = Parent2.objects.select_related('child2').get(name2="Child2 Parent2")
-            self.assertEqual(p.child2.name1, 'Child2 Parent1')
+            p = Parent2.objects.select_related("child2").get(name2="Child2 Parent2")
+            self.assertEqual(p.child2.name1, "Child2 Parent1")
 
     def test_onetoone_with_two_subclasses(self):
         with self.assertNumQueries(1):
-            p = Parent2.objects.select_related('child2', "child2__child3").get(name2="Child2 Parent2")
-            self.assertEqual(p.child2.name1, 'Child2 Parent1')
+            p = Parent2.objects.select_related("child2", "child2__child3").get(
+                name2="Child2 Parent2"
+            )
+            self.assertEqual(p.child2.name1, "Child2 Parent1")
             with self.assertRaises(Child3.DoesNotExist):
                 p.child2.child3
         p3 = Parent2(name2="Child3 Parent2")
@@ -147,24 +177,30 @@ class ReverseSelectRelatedTestCase(TestCase):
         c2 = Child3(name1="Child3 Parent1", parent2=p3, value=2, value3=3)
         c2.save()
         with self.assertNumQueries(1):
-            p = Parent2.objects.select_related('child2', "child2__child3").get(name2="Child3 Parent2")
-            self.assertEqual(p.child2.name1, 'Child3 Parent1')
+            p = Parent2.objects.select_related("child2", "child2__child3").get(
+                name2="Child3 Parent2"
+            )
+            self.assertEqual(p.child2.name1, "Child3 Parent1")
             self.assertEqual(p.child2.child3.value3, 3)
             self.assertEqual(p.child2.child3.value, p.child2.value)
             self.assertEqual(p.child2.name1, p.child2.child3.name1)
 
     def test_multiinheritance_two_subclasses(self):
         with self.assertNumQueries(1):
-            p = Parent1.objects.select_related('child1', 'child1__child4').get(name1="Child1 Parent1")
-            self.assertEqual(p.child1.name2, 'Child1 Parent2')
+            p = Parent1.objects.select_related("child1", "child1__child4").get(
+                name1="Child1 Parent1"
+            )
+            self.assertEqual(p.child1.name2, "Child1 Parent2")
             self.assertEqual(p.child1.name1, p.name1)
             with self.assertRaises(Child4.DoesNotExist):
                 p.child1.child4
-        Child4(name1='n1', name2='n2', value=1, value4=4).save()
+        Child4(name1="n1", name2="n2", value=1, value4=4).save()
         with self.assertNumQueries(1):
-            p = Parent2.objects.select_related('child1', 'child1__child4').get(name2="n2")
-            self.assertEqual(p.name2, 'n2')
-            self.assertEqual(p.child1.name1, 'n1')
+            p = Parent2.objects.select_related("child1", "child1__child4").get(
+                name2="n2"
+            )
+            self.assertEqual(p.name2, "n2")
+            self.assertEqual(p.child1.name1, "n1")
             self.assertEqual(p.child1.name2, p.name2)
             self.assertEqual(p.child1.value, 1)
             self.assertEqual(p.child1.child4.name1, p.child1.name1)
@@ -173,25 +209,35 @@ class ReverseSelectRelatedTestCase(TestCase):
             self.assertEqual(p.child1.child4.value4, 4)
 
     def test_inheritance_deferred(self):
-        c = Child4.objects.create(name1='n1', name2='n2', value=1, value4=4)
+        c = Child4.objects.create(name1="n1", name2="n2", value=1, value4=4)
         with self.assertNumQueries(1):
-            p = Parent2.objects.select_related('child1').only(
-                'id2', 'child1__value').get(name2="n2")
+            p = (
+                Parent2.objects.select_related("child1")
+                .only("id2", "child1__value")
+                .get(name2="n2")
+            )
             self.assertEqual(p.id2, c.id2)
             self.assertEqual(p.child1.value, 1)
-        p = Parent2.objects.select_related('child1').only(
-            'id2', 'child1__value').get(name2="n2")
+        p = (
+            Parent2.objects.select_related("child1")
+            .only("id2", "child1__value")
+            .get(name2="n2")
+        )
         with self.assertNumQueries(1):
-            self.assertEqual(p.name2, 'n2')
-        p = Parent2.objects.select_related('child1').only(
-            'id2', 'child1__value').get(name2="n2")
+            self.assertEqual(p.name2, "n2")
+        p = (
+            Parent2.objects.select_related("child1")
+            .only("id2", "child1__value")
+            .get(name2="n2")
+        )
         with self.assertNumQueries(1):
-            self.assertEqual(p.child1.name2, 'n2')
+            self.assertEqual(p.child1.name2, "n2")
 
     def test_inheritance_deferred2(self):
-        c = Child4.objects.create(name1='n1', name2='n2', value=1, value4=4)
-        qs = Parent2.objects.select_related('child1', 'child1__child4').only(
-            'id2', 'child1__value', 'child1__child4__value4')
+        c = Child4.objects.create(name1="n1", name2="n2", value=1, value4=4)
+        qs = Parent2.objects.select_related("child1", "child1__child4").only(
+            "id2", "child1__value", "child1__child4__value4"
+        )
         with self.assertNumQueries(1):
             p = qs.get(name2="n2")
             self.assertEqual(p.id2, c.id2)
@@ -200,18 +246,18 @@ class ReverseSelectRelatedTestCase(TestCase):
             self.assertEqual(p.child1.child4.id2, c.id2)
         p = qs.get(name2="n2")
         with self.assertNumQueries(1):
-            self.assertEqual(p.child1.name2, 'n2')
+            self.assertEqual(p.child1.name2, "n2")
         p = qs.get(name2="n2")
         with self.assertNumQueries(0):
-            self.assertEqual(p.child1.name1, 'n1')
-            self.assertEqual(p.child1.child4.name1, 'n1')
+            self.assertEqual(p.child1.name1, "n1")
+            self.assertEqual(p.child1.child4.name1, "n1")
 
     def test_self_relation(self):
-        item1 = LinkedList.objects.create(name='item1')
-        LinkedList.objects.create(name='item2', previous_item=item1)
+        item1 = LinkedList.objects.create(name="item1")
+        LinkedList.objects.create(name="item2", previous_item=item1)
         with self.assertNumQueries(1):
-            item1_db = LinkedList.objects.select_related('next_item').get(name='item1')
-            self.assertEqual(item1_db.next_item.name, 'item2')
+            item1_db = LinkedList.objects.select_related("next_item").get(name="item1")
+            self.assertEqual(item1_db.next_item.name, "item2")
 
 
 class ReverseSelectRelatedValidationTests(SimpleTestCase):
@@ -219,19 +265,34 @@ class ReverseSelectRelatedValidationTests(SimpleTestCase):
     Rverse related fields should be listed in the validation message when an
     invalid field is given in select_related().
     """
-    non_relational_error = "Non-relational field given in select_related: '%s'. Choices are: %s"
-    invalid_error = "Invalid field name(s) given in select_related: '%s'. Choices are: %s"
+
+    non_relational_error = (
+        "Non-relational field given in select_related: '%s'. Choices are: %s"
+    )
+    invalid_error = (
+        "Invalid field name(s) given in select_related: '%s'. Choices are: %s"
+    )
 
     def test_reverse_related_validation(self):
-        fields = 'userprofile, userstat'
+        fields = "userprofile, userstat"
 
-        with self.assertRaisesMessage(FieldError, self.invalid_error % ('foobar', fields)):
-            list(User.objects.select_related('foobar'))
+        with self.assertRaisesMessage(
+            FieldError, self.invalid_error % ("foobar", fields)
+        ):
+            list(User.objects.select_related("foobar"))
 
-        with self.assertRaisesMessage(FieldError, self.non_relational_error % ('username', fields)):
-            list(User.objects.select_related('username'))
+        with self.assertRaisesMessage(
+            FieldError, self.non_relational_error % ("username", fields)
+        ):
+            list(User.objects.select_related("username"))
 
     def test_reverse_related_validation_with_filtered_relation(self):
-        fields = 'userprofile, userstat, relation'
-        with self.assertRaisesMessage(FieldError, self.invalid_error % ('foobar', fields)):
-            list(User.objects.annotate(relation=FilteredRelation('userprofile')).select_related('foobar'))
+        fields = "userprofile, userstat, relation"
+        with self.assertRaisesMessage(
+            FieldError, self.invalid_error % ("foobar", fields)
+        ):
+            list(
+                User.objects.annotate(
+                    relation=FilteredRelation("userprofile")
+                ).select_related("foobar")
+            )