Refs #33476 -- Reformatted code with Black.

2 files changed, 67 insertions, 51 deletions

diff --git a/tests/defer/models.py b/tests/defer/models.py
index fea673643b..6de2e2af97 100644
--- a/tests/defer/models.py
+++ b/tests/defer/models.py
@@ -52,8 +52,9 @@ class ShadowParent(models.Model):
     overridden, the field value, rather than the scalar value must still be
     used when the field is deferred.
     """
-    name = 'aphrodite'
+
+    name = "aphrodite"
 
 
 class ShadowChild(ShadowParent):
-    name = models.CharField(default='adonis', max_length=6)
+    name = models.CharField(default="adonis", max_length=6)
diff --git a/tests/defer/tests.py b/tests/defer/tests.py
index d897c5fa42..244564bf69 100644
--- a/tests/defer/tests.py
+++ b/tests/defer/tests.py
@@ -2,7 +2,12 @@ from django.core.exceptions import FieldError
 from django.test import TestCase
 
 from .models import (
-    BigChild, Child, ChildProxy, Primary, RefreshPrimaryProxy, Secondary,
+    BigChild,
+    Child,
+    ChildProxy,
+    Primary,
+    RefreshPrimaryProxy,
+    Secondary,
     ShadowChild,
 )
 
@@ -43,22 +48,22 @@ class DeferTests(AssertionMixin, TestCase):
         # You can use 'pk' with reverse foreign key lookups.
         # The related_id is always set even if it's not fetched from the DB,
         # so pk and related_id are not deferred.
-        self.assert_delayed(self.s1.primary_set.all().only('pk')[0], 2)
+        self.assert_delayed(self.s1.primary_set.all().only("pk")[0], 2)
 
     def test_defer_only_chaining(self):
         qs = Primary.objects.all()
         self.assert_delayed(qs.only("name", "value").defer("name")[0], 2)
         self.assert_delayed(qs.defer("name").only("value", "name")[0], 2)
-        self.assert_delayed(qs.defer('name').only('name').only('value')[0], 2)
+        self.assert_delayed(qs.defer("name").only("name").only("value")[0], 2)
         self.assert_delayed(qs.defer("name").only("value")[0], 2)
         self.assert_delayed(qs.only("name").defer("value")[0], 2)
-        self.assert_delayed(qs.only('name').defer('name').defer('value')[0], 1)
-        self.assert_delayed(qs.only('name').defer('name', 'value')[0], 1)
+        self.assert_delayed(qs.only("name").defer("name").defer("value")[0], 1)
+        self.assert_delayed(qs.only("name").defer("name", "value")[0], 1)
 
     def test_defer_only_clear(self):
         qs = Primary.objects.all()
-        self.assert_delayed(qs.only('name').defer('name')[0], 0)
-        self.assert_delayed(qs.defer('name').only('name')[0], 0)
+        self.assert_delayed(qs.only("name").defer("name")[0], 0)
+        self.assert_delayed(qs.defer("name").only("name")[0], 0)
 
     def test_defer_on_an_already_deferred_field(self):
         qs = Primary.objects.all()
@@ -72,7 +77,7 @@ class DeferTests(AssertionMixin, TestCase):
         self.assert_delayed(qs.only("name").defer(None)[0], 0)
 
     def test_only_none_raises_error(self):
-        msg = 'Cannot pass None as an argument to only().'
+        msg = "Cannot pass None as an argument to only()."
         with self.assertRaisesMessage(TypeError, msg):
             Primary.objects.only(None)
 
@@ -84,20 +89,26 @@ class DeferTests(AssertionMixin, TestCase):
     def test_defer_values_does_not_defer(self):
         # User values() won't defer anything (you get the full list of
         # dictionaries back), but it still works.
-        self.assertEqual(Primary.objects.defer("name").values()[0], {
-            "id": self.p1.id,
-            "name": "p1",
-            "value": "xx",
-            "related_id": self.s1.id,
-        })
+        self.assertEqual(
+            Primary.objects.defer("name").values()[0],
+            {
+                "id": self.p1.id,
+                "name": "p1",
+                "value": "xx",
+                "related_id": self.s1.id,
+            },
+        )
 
     def test_only_values_does_not_defer(self):
-        self.assertEqual(Primary.objects.only("name").values()[0], {
-            "id": self.p1.id,
-            "name": "p1",
-            "value": "xx",
-            "related_id": self.s1.id,
-        })
+        self.assertEqual(
+            Primary.objects.only("name").values()[0],
+            {
+                "id": self.p1.id,
+                "name": "p1",
+                "value": "xx",
+                "related_id": self.s1.id,
+            },
+        )
 
     def test_get(self):
         # Using defer() and only() with get() is also valid.
@@ -106,7 +117,9 @@ class DeferTests(AssertionMixin, TestCase):
         self.assert_delayed(qs.only("name").get(pk=self.p1.pk), 2)
 
     def test_defer_with_select_related(self):
-        obj = Primary.objects.select_related().defer("related__first", "related__second")[0]
+        obj = Primary.objects.select_related().defer(
+            "related__first", "related__second"
+        )[0]
         self.assert_delayed(obj.related, 2)
         self.assert_delayed(obj, 0)
 
@@ -119,16 +132,16 @@ class DeferTests(AssertionMixin, TestCase):
 
     def test_defer_select_related_raises_invalid_query(self):
         msg = (
-            'Field Primary.related cannot be both deferred and traversed '
-            'using select_related at the same time.'
+            "Field Primary.related cannot be both deferred and traversed "
+            "using select_related at the same time."
         )
         with self.assertRaisesMessage(FieldError, msg):
             Primary.objects.defer("related").select_related("related")[0]
 
     def test_only_select_related_raises_invalid_query(self):
         msg = (
-            'Field Primary.related cannot be both deferred and traversed using '
-            'select_related at the same time.'
+            "Field Primary.related cannot be both deferred and traversed using "
+            "select_related at the same time."
         )
         with self.assertRaisesMessage(FieldError, msg):
             Primary.objects.only("name").select_related("related")[0]
@@ -148,8 +161,10 @@ class DeferTests(AssertionMixin, TestCase):
         obj.name = "a new name"
         obj.save()
         self.assertQuerysetEqual(
-            Primary.objects.all(), [
-                "p1", "a new name",
+            Primary.objects.all(),
+            [
+                "p1",
+                "a new name",
             ],
             lambda p: p.name,
             ordered=False,
@@ -176,8 +191,8 @@ class DeferTests(AssertionMixin, TestCase):
 
     def test_defer_of_overridden_scalar(self):
         ShadowChild.objects.create()
-        obj = ShadowChild.objects.defer('name').get()
-        self.assertEqual(obj.name, 'adonis')
+        obj = ShadowChild.objects.defer("name").get()
+        self.assertEqual(obj.name, "adonis")
 
 
 class BigChildDeferTests(AssertionMixin, TestCase):
@@ -231,14 +246,14 @@ class TestDefer2(AssertionMixin, TestCase):
         Ensure select_related together with only on a proxy model behaves
         as expected. See #17876.
         """
-        related = Secondary.objects.create(first='x1', second='x2')
-        ChildProxy.objects.create(name='p1', value='xx', related=related)
-        children = ChildProxy.objects.all().select_related().only('id', 'name')
+        related = Secondary.objects.create(first="x1", second="x2")
+        ChildProxy.objects.create(name="p1", value="xx", related=related)
+        children = ChildProxy.objects.all().select_related().only("id", "name")
         self.assertEqual(len(children), 1)
         child = children[0]
         self.assert_delayed(child, 2)
-        self.assertEqual(child.name, 'p1')
-        self.assertEqual(child.value, 'xx')
+        self.assertEqual(child.name, "p1")
+        self.assertEqual(child.value, "xx")
 
     def test_defer_inheritance_pk_chaining(self):
         """
@@ -247,40 +262,40 @@ class TestDefer2(AssertionMixin, TestCase):
         fetched parent model PK if it happens to be available.
         """
         s1 = Secondary.objects.create(first="x1", second="y1")
-        bc = BigChild.objects.create(name='b1', value='foo', related=s1, other='bar')
-        bc_deferred = BigChild.objects.only('name').get(pk=bc.pk)
+        bc = BigChild.objects.create(name="b1", value="foo", related=s1, other="bar")
+        bc_deferred = BigChild.objects.only("name").get(pk=bc.pk)
         with self.assertNumQueries(0):
             bc_deferred.id
         self.assertEqual(bc_deferred.pk, bc_deferred.id)
 
     def test_eq(self):
         s1 = Secondary.objects.create(first="x1", second="y1")
-        s1_defer = Secondary.objects.only('pk').get(pk=s1.pk)
+        s1_defer = Secondary.objects.only("pk").get(pk=s1.pk)
         self.assertEqual(s1, s1_defer)
         self.assertEqual(s1_defer, s1)
 
     def test_refresh_not_loading_deferred_fields(self):
         s = Secondary.objects.create()
-        rf = Primary.objects.create(name='foo', value='bar', related=s)
-        rf2 = Primary.objects.only('related', 'value').get()
-        rf.name = 'new foo'
-        rf.value = 'new bar'
+        rf = Primary.objects.create(name="foo", value="bar", related=s)
+        rf2 = Primary.objects.only("related", "value").get()
+        rf.name = "new foo"
+        rf.value = "new bar"
         rf.save()
         with self.assertNumQueries(1):
             rf2.refresh_from_db()
-            self.assertEqual(rf2.value, 'new bar')
+            self.assertEqual(rf2.value, "new bar")
         with self.assertNumQueries(1):
-            self.assertEqual(rf2.name, 'new foo')
+            self.assertEqual(rf2.name, "new foo")
 
     def test_custom_refresh_on_deferred_loading(self):
         s = Secondary.objects.create()
-        rf = RefreshPrimaryProxy.objects.create(name='foo', value='bar', related=s)
-        rf2 = RefreshPrimaryProxy.objects.only('related').get()
-        rf.name = 'new foo'
-        rf.value = 'new bar'
+        rf = RefreshPrimaryProxy.objects.create(name="foo", value="bar", related=s)
+        rf2 = RefreshPrimaryProxy.objects.only("related").get()
+        rf.name = "new foo"
+        rf.value = "new bar"
         rf.save()
         with self.assertNumQueries(1):
             # Customized refresh_from_db() reloads all deferred fields on
             # access of any of them.
-            self.assertEqual(rf2.name, 'new foo')
-            self.assertEqual(rf2.value, 'new bar')
+            self.assertEqual(rf2.name, "new foo")
+            self.assertEqual(rf2.value, "new bar")