Refs #33476 -- Reformatted code with Black.

2 files changed, 144 insertions, 79 deletions

diff --git a/tests/select_related/models.py b/tests/select_related/models.py
index 7cb083fc20..d407dbdb11 100644
--- a/tests/select_related/models.py
+++ b/tests/select_related/models.py
@@ -7,9 +7,7 @@ isn't always a good idea, so the ``depth`` argument control how many "levels"
 the select-related behavior will traverse.
 """
 
-from django.contrib.contenttypes.fields import (
-    GenericForeignKey, GenericRelation,
-)
+from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
 from django.contrib.contenttypes.models import ContentType
 from django.db import models
 
@@ -54,13 +52,14 @@ class Species(models.Model):
     name = models.CharField(max_length=50)
     genus = models.ForeignKey(Genus, models.CASCADE)
 
+
 # and we'll invent a new thing so we have a model with two foreign keys
 
 
 class HybridSpecies(models.Model):
     name = models.CharField(max_length=50)
-    parent_1 = models.ForeignKey(Species, models.CASCADE, related_name='child_1')
-    parent_2 = models.ForeignKey(Species, models.CASCADE, related_name='child_2')
+    parent_1 = models.ForeignKey(Species, models.CASCADE, related_name="child_1")
+    parent_2 = models.ForeignKey(Species, models.CASCADE, related_name="child_2")
 
 
 class Topping(models.Model):
@@ -75,9 +74,11 @@ class Pizza(models.Model):
 class TaggedItem(models.Model):
     tag = models.CharField(max_length=30)
 
-    content_type = models.ForeignKey(ContentType, models.CASCADE, related_name='select_related_tagged_items')
+    content_type = models.ForeignKey(
+        ContentType, models.CASCADE, related_name="select_related_tagged_items"
+    )
     object_id = models.PositiveIntegerField()
-    content_object = GenericForeignKey('content_type', 'object_id')
+    content_object = GenericForeignKey("content_type", "object_id")
 
 
 class Bookmark(models.Model):
diff --git a/tests/select_related/tests.py b/tests/select_related/tests.py
index 6debf0d67b..3ac36dc7e4 100644
--- a/tests/select_related/tests.py
+++ b/tests/select_related/tests.py
@@ -2,13 +2,22 @@ from django.core.exceptions import FieldError
 from django.test import SimpleTestCase, TestCase
 
 from .models import (
-    Bookmark, Domain, Family, Genus, HybridSpecies, Kingdom, Klass, Order,
-    Phylum, Pizza, Species, TaggedItem,
+    Bookmark,
+    Domain,
+    Family,
+    Genus,
+    HybridSpecies,
+    Kingdom,
+    Klass,
+    Order,
+    Phylum,
+    Pizza,
+    Species,
+    TaggedItem,
 )
 
 
 class SelectRelatedTests(TestCase):
-
     @classmethod
     def create_tree(cls, stringtree):
         """
@@ -31,10 +40,18 @@ class SelectRelatedTests(TestCase):
 
     @classmethod
     def setUpTestData(cls):
-        cls.create_tree("Eukaryota Animalia Anthropoda Insecta Diptera Drosophilidae Drosophila melanogaster")
-        cls.create_tree("Eukaryota Animalia Chordata Mammalia Primates Hominidae Homo sapiens")
-        cls.create_tree("Eukaryota Plantae Magnoliophyta Magnoliopsida Fabales Fabaceae Pisum sativum")
-        cls.create_tree("Eukaryota Fungi Basidiomycota Homobasidiomycatae Agaricales Amanitacae Amanita muscaria")
+        cls.create_tree(
+            "Eukaryota Animalia Anthropoda Insecta Diptera Drosophilidae Drosophila melanogaster"
+        )
+        cls.create_tree(
+            "Eukaryota Animalia Chordata Mammalia Primates Hominidae Homo sapiens"
+        )
+        cls.create_tree(
+            "Eukaryota Plantae Magnoliophyta Magnoliopsida Fabales Fabaceae Pisum sativum"
+        )
+        cls.create_tree(
+            "Eukaryota Fungi Basidiomycota Homobasidiomycatae Agaricales Amanitacae Amanita muscaria"
+        )
 
     def test_access_fks_without_select_related(self):
         """
@@ -43,7 +60,7 @@ class SelectRelatedTests(TestCase):
         with self.assertNumQueries(8):
             fly = Species.objects.get(name="melanogaster")
             domain = fly.genus.family.order.klass.phylum.kingdom.domain
-            self.assertEqual(domain.name, 'Eukaryota')
+            self.assertEqual(domain.name, "Eukaryota")
 
     def test_access_fks_with_select_related(self):
         """
@@ -51,36 +68,40 @@ class SelectRelatedTests(TestCase):
         extra queries
         """
         with self.assertNumQueries(1):
-            person = (
-                Species.objects
-                .select_related('genus__family__order__klass__phylum__kingdom__domain')
-                .get(name="sapiens")
-            )
+            person = Species.objects.select_related(
+                "genus__family__order__klass__phylum__kingdom__domain"
+            ).get(name="sapiens")
             domain = person.genus.family.order.klass.phylum.kingdom.domain
-            self.assertEqual(domain.name, 'Eukaryota')
+            self.assertEqual(domain.name, "Eukaryota")
 
     def test_list_without_select_related(self):
         with self.assertNumQueries(9):
             world = Species.objects.all()
             families = [o.genus.family.name for o in world]
-            self.assertEqual(sorted(families), [
-                'Amanitacae',
-                'Drosophilidae',
-                'Fabaceae',
-                'Hominidae',
-            ])
+            self.assertEqual(
+                sorted(families),
+                [
+                    "Amanitacae",
+                    "Drosophilidae",
+                    "Fabaceae",
+                    "Hominidae",
+                ],
+            )
 
     def test_list_with_select_related(self):
         """select_related() applies to entire lists, not just items."""
         with self.assertNumQueries(1):
             world = Species.objects.all().select_related()
             families = [o.genus.family.name for o in world]
-            self.assertEqual(sorted(families), [
-                'Amanitacae',
-                'Drosophilidae',
-                'Fabaceae',
-                'Hominidae',
-            ])
+            self.assertEqual(
+                sorted(families),
+                [
+                    "Amanitacae",
+                    "Drosophilidae",
+                    "Fabaceae",
+                    "Hominidae",
+                ],
+            )
 
     def test_list_with_depth(self):
         """
@@ -89,14 +110,18 @@ class SelectRelatedTests(TestCase):
         well.
         """
         with self.assertNumQueries(5):
-            world = Species.objects.all().select_related('genus__family')
+            world = Species.objects.all().select_related("genus__family")
             orders = [o.genus.family.order.name for o in world]
-            self.assertEqual(sorted(orders), ['Agaricales', 'Diptera', 'Fabales', 'Primates'])
+            self.assertEqual(
+                sorted(orders), ["Agaricales", "Diptera", "Fabales", "Primates"]
+            )
 
     def test_select_related_with_extra(self):
-        s = (Species.objects.all()
-             .select_related()
-             .extra(select={'a': 'select_related_species.id + 10'})[0])
+        s = (
+            Species.objects.all()
+            .select_related()
+            .extra(select={"a": "select_related_species.id + 10"})[0]
+        )
         self.assertEqual(s.id + 10, s.a)
 
     def test_certain_fields(self):
@@ -108,9 +133,12 @@ class SelectRelatedTests(TestCase):
         'genus.family' models, leading to the same number of queries as before.
         """
         with self.assertNumQueries(1):
-            world = Species.objects.select_related('genus__family')
+            world = Species.objects.select_related("genus__family")
             families = [o.genus.family.name for o in world]
-            self.assertEqual(sorted(families), ['Amanitacae', 'Drosophilidae', 'Fabaceae', 'Hominidae'])
+            self.assertEqual(
+                sorted(families),
+                ["Amanitacae", "Drosophilidae", "Fabaceae", "Hominidae"],
+            )
 
     def test_more_certain_fields(self):
         """
@@ -118,39 +146,50 @@ class SelectRelatedTests(TestCase):
         'genus.family' models, leading to the same number of queries as before.
         """
         with self.assertNumQueries(2):
-            world = Species.objects.filter(genus__name='Amanita')\
-                .select_related('genus__family')
+            world = Species.objects.filter(genus__name="Amanita").select_related(
+                "genus__family"
+            )
             orders = [o.genus.family.order.name for o in world]
-            self.assertEqual(orders, ['Agaricales'])
+            self.assertEqual(orders, ["Agaricales"])
 
     def test_field_traversal(self):
         with self.assertNumQueries(1):
-            s = (Species.objects.all()
-                 .select_related('genus__family__order')
-                 .order_by('id')[0:1].get().genus.family.order.name)
-            self.assertEqual(s, 'Diptera')
+            s = (
+                Species.objects.all()
+                .select_related("genus__family__order")
+                .order_by("id")[0:1]
+                .get()
+                .genus.family.order.name
+            )
+            self.assertEqual(s, "Diptera")
 
     def test_none_clears_list(self):
-        queryset = Species.objects.select_related('genus').select_related(None)
+        queryset = Species.objects.select_related("genus").select_related(None)
         self.assertIs(queryset.query.select_related, False)
 
     def test_chaining(self):
         parent_1, parent_2 = Species.objects.all()[:2]
-        HybridSpecies.objects.create(name='hybrid', parent_1=parent_1, parent_2=parent_2)
-        queryset = HybridSpecies.objects.select_related('parent_1').select_related('parent_2')
+        HybridSpecies.objects.create(
+            name="hybrid", parent_1=parent_1, parent_2=parent_2
+        )
+        queryset = HybridSpecies.objects.select_related("parent_1").select_related(
+            "parent_2"
+        )
         with self.assertNumQueries(1):
             obj = queryset[0]
             self.assertEqual(obj.parent_1, parent_1)
             self.assertEqual(obj.parent_2, parent_2)
 
     def test_reverse_relation_caching(self):
-        species = Species.objects.select_related('genus').filter(name='melanogaster').first()
+        species = (
+            Species.objects.select_related("genus").filter(name="melanogaster").first()
+        )
         with self.assertNumQueries(0):
-            self.assertEqual(species.genus.name, 'Drosophila')
+            self.assertEqual(species.genus.name, "Drosophila")
         # The species_set reverse relation isn't cached.
         self.assertEqual(species.genus._state.fields_cache, {})
         with self.assertNumQueries(1):
-            self.assertEqual(species.genus.species_set.first().name, 'melanogaster')
+            self.assertEqual(species.genus.species_set.first().name, "melanogaster")
 
     def test_select_related_after_values(self):
         """
@@ -158,7 +197,7 @@ class SelectRelatedTests(TestCase):
         """
         message = "Cannot call select_related() after .values() or .values_list()"
         with self.assertRaisesMessage(TypeError, message):
-            list(Species.objects.values('name').select_related('genus'))
+            list(Species.objects.values("name").select_related("genus"))
 
     def test_select_related_after_values_list(self):
         """
@@ -166,7 +205,7 @@ class SelectRelatedTests(TestCase):
         """
         message = "Cannot call select_related() after .values() or .values_list()"
         with self.assertRaisesMessage(TypeError, message):
-            list(Species.objects.values_list('name').select_related('genus'))
+            list(Species.objects.values_list("name").select_related("genus"))
 
 
 class SelectRelatedValidationTests(SimpleTestCase):
@@ -174,44 +213,69 @@ class SelectRelatedValidationTests(SimpleTestCase):
     select_related() should thrown an error on fields that do not exist and
     non-relational fields.
     """
-    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_non_relational_field(self):
-        with self.assertRaisesMessage(FieldError, self.non_relational_error % ('name', 'genus')):
-            list(Species.objects.select_related('name__some_field'))
+        with self.assertRaisesMessage(
+            FieldError, self.non_relational_error % ("name", "genus")
+        ):
+            list(Species.objects.select_related("name__some_field"))
 
-        with self.assertRaisesMessage(FieldError, self.non_relational_error % ('name', 'genus')):
-            list(Species.objects.select_related('name'))
+        with self.assertRaisesMessage(
+            FieldError, self.non_relational_error % ("name", "genus")
+        ):
+            list(Species.objects.select_related("name"))
 
-        with self.assertRaisesMessage(FieldError, self.non_relational_error % ('name', '(none)')):
-            list(Domain.objects.select_related('name'))
+        with self.assertRaisesMessage(
+            FieldError, self.non_relational_error % ("name", "(none)")
+        ):
+            list(Domain.objects.select_related("name"))
 
     def test_non_relational_field_nested(self):
-        with self.assertRaisesMessage(FieldError, self.non_relational_error % ('name', 'family')):
-            list(Species.objects.select_related('genus__name'))
+        with self.assertRaisesMessage(
+            FieldError, self.non_relational_error % ("name", "family")
+        ):
+            list(Species.objects.select_related("genus__name"))
 
     def test_many_to_many_field(self):
-        with self.assertRaisesMessage(FieldError, self.invalid_error % ('toppings', '(none)')):
-            list(Pizza.objects.select_related('toppings'))
+        with self.assertRaisesMessage(
+            FieldError, self.invalid_error % ("toppings", "(none)")
+        ):
+            list(Pizza.objects.select_related("toppings"))
 
     def test_reverse_relational_field(self):
-        with self.assertRaisesMessage(FieldError, self.invalid_error % ('child_1', 'genus')):
-            list(Species.objects.select_related('child_1'))
+        with self.assertRaisesMessage(
+            FieldError, self.invalid_error % ("child_1", "genus")
+        ):
+            list(Species.objects.select_related("child_1"))
 
     def test_invalid_field(self):
-        with self.assertRaisesMessage(FieldError, self.invalid_error % ('invalid_field', 'genus')):
-            list(Species.objects.select_related('invalid_field'))
+        with self.assertRaisesMessage(
+            FieldError, self.invalid_error % ("invalid_field", "genus")
+        ):
+            list(Species.objects.select_related("invalid_field"))
 
-        with self.assertRaisesMessage(FieldError, self.invalid_error % ('related_invalid_field', 'family')):
-            list(Species.objects.select_related('genus__related_invalid_field'))
+        with self.assertRaisesMessage(
+            FieldError, self.invalid_error % ("related_invalid_field", "family")
+        ):
+            list(Species.objects.select_related("genus__related_invalid_field"))
 
-        with self.assertRaisesMessage(FieldError, self.invalid_error % ('invalid_field', '(none)')):
-            list(Domain.objects.select_related('invalid_field'))
+        with self.assertRaisesMessage(
+            FieldError, self.invalid_error % ("invalid_field", "(none)")
+        ):
+            list(Domain.objects.select_related("invalid_field"))
 
     def test_generic_relations(self):
-        with self.assertRaisesMessage(FieldError, self.invalid_error % ('tags', '')):
-            list(Bookmark.objects.select_related('tags'))
+        with self.assertRaisesMessage(FieldError, self.invalid_error % ("tags", "")):
+            list(Bookmark.objects.select_related("tags"))
 
-        with self.assertRaisesMessage(FieldError, self.invalid_error % ('content_object', 'content_type')):
-            list(TaggedItem.objects.select_related('content_object'))
+        with self.assertRaisesMessage(
+            FieldError, self.invalid_error % ("content_object", "content_type")
+        ):
+            list(TaggedItem.objects.select_related("content_object"))