Refs #33476 -- Reformatted code with Black.

2 files changed, 266 insertions, 139 deletions

diff --git a/tests/many_to_one/models.py b/tests/many_to_one/models.py
index 5f42f167c9..cca7e79817 100644
--- a/tests/many_to_one/models.py
+++ b/tests/many_to_one/models.py
@@ -21,7 +21,7 @@ class Article(models.Model):
     reporter = models.ForeignKey(Reporter, models.CASCADE)
 
     class Meta:
-        ordering = ('headline',)
+        ordering = ("headline",)
 
     def __str__(self):
         return self.headline
@@ -34,12 +34,14 @@ class Country(models.Model):
 
 class City(models.Model):
     id = models.BigAutoField(primary_key=True)
-    country = models.ForeignKey(Country, models.CASCADE, related_name='cities', null=True)
+    country = models.ForeignKey(
+        Country, models.CASCADE, related_name="cities", null=True
+    )
     name = models.CharField(max_length=50)
 
 
 class District(models.Model):
-    city = models.ForeignKey(City, models.CASCADE, related_name='districts', null=True)
+    city = models.ForeignKey(City, models.CASCADE, related_name="districts", null=True)
     name = models.CharField(max_length=50)
 
     def __str__(self):
@@ -54,18 +56,22 @@ class First(models.Model):
 
 
 class Second(models.Model):
-    first = models.ForeignKey(First, models.CASCADE, related_name='the_first')
+    first = models.ForeignKey(First, models.CASCADE, related_name="the_first")
 
 
 # Protect against repetition of #1839, #2415 and #2536.
 class Third(models.Model):
     name = models.CharField(max_length=20)
-    third = models.ForeignKey('self', models.SET_NULL, null=True, related_name='child_set')
+    third = models.ForeignKey(
+        "self", models.SET_NULL, null=True, related_name="child_set"
+    )
 
 
 class Parent(models.Model):
     name = models.CharField(max_length=20, unique=True)
-    bestchild = models.ForeignKey('Child', models.SET_NULL, null=True, related_name='favored_by')
+    bestchild = models.ForeignKey(
+        "Child", models.SET_NULL, null=True, related_name="favored_by"
+    )
 
 
 class ParentStringPrimaryKey(models.Model):
@@ -86,7 +92,9 @@ class ChildStringPrimaryKeyParent(models.Model):
 
 
 class ToFieldChild(models.Model):
-    parent = models.ForeignKey(Parent, models.CASCADE, to_field='name', related_name='to_field_children')
+    parent = models.ForeignKey(
+        Parent, models.CASCADE, to_field="name", related_name="to_field_children"
+    )
 
 
 # Multiple paths to the same model (#7110, #7125)
@@ -102,8 +110,8 @@ class Record(models.Model):
 
 
 class Relation(models.Model):
-    left = models.ForeignKey(Record, models.CASCADE, related_name='left_set')
-    right = models.ForeignKey(Record, models.CASCADE, related_name='right_set')
+    left = models.ForeignKey(Record, models.CASCADE, related_name="left_set")
+    right = models.ForeignKey(Record, models.CASCADE, related_name="right_set")
 
     def __str__(self):
         return "%s - %s" % (self.left.category.name, self.right.category.name)
diff --git a/tests/many_to_one/tests.py b/tests/many_to_one/tests.py
index 1e297b0ec4..8fca4d691f 100644
--- a/tests/many_to_one/tests.py
+++ b/tests/many_to_one/tests.py
@@ -7,9 +7,24 @@ from django.test import TestCase
 from django.utils.translation import gettext_lazy
 
 from .models import (
-    Article, Category, Child, ChildNullableParent, ChildStringPrimaryKeyParent,
-    City, Country, District, First, Parent, ParentStringPrimaryKey, Record,
-    Relation, Reporter, School, Student, Third, ToFieldChild,
+    Article,
+    Category,
+    Child,
+    ChildNullableParent,
+    ChildStringPrimaryKeyParent,
+    City,
+    Country,
+    District,
+    First,
+    Parent,
+    ParentStringPrimaryKey,
+    Record,
+    Relation,
+    Reporter,
+    School,
+    Student,
+    Third,
+    ToFieldChild,
 )
 
 
@@ -17,40 +32,58 @@ class ManyToOneTests(TestCase):
     @classmethod
     def setUpTestData(cls):
         # Create a few Reporters.
-        cls.r = Reporter(first_name='John', last_name='Smith', email='john@example.com')
+        cls.r = Reporter(first_name="John", last_name="Smith", email="john@example.com")
         cls.r.save()
-        cls.r2 = Reporter(first_name='Paul', last_name='Jones', email='paul@example.com')
+        cls.r2 = Reporter(
+            first_name="Paul", last_name="Jones", email="paul@example.com"
+        )
         cls.r2.save()
         # Create an Article.
-        cls.a = Article(headline='This is a test', pub_date=datetime.date(2005, 7, 27), reporter=cls.r)
+        cls.a = Article(
+            headline="This is a test",
+            pub_date=datetime.date(2005, 7, 27),
+            reporter=cls.r,
+        )
         cls.a.save()
 
     def test_get(self):
         # Article objects have access to their related Reporter objects.
         r = self.a.reporter
         self.assertEqual(r.id, self.r.id)
-        self.assertEqual((r.first_name, self.r.last_name), ('John', 'Smith'))
+        self.assertEqual((r.first_name, self.r.last_name), ("John", "Smith"))
 
     def test_create(self):
         # You can also instantiate an Article by passing the Reporter's ID
         # instead of a Reporter object.
-        a3 = Article(headline="Third article", pub_date=datetime.date(2005, 7, 27), reporter_id=self.r.id)
+        a3 = Article(
+            headline="Third article",
+            pub_date=datetime.date(2005, 7, 27),
+            reporter_id=self.r.id,
+        )
         a3.save()
         self.assertEqual(a3.reporter.id, self.r.id)
 
         # Similarly, the reporter ID can be a string.
-        a4 = Article(headline="Fourth article", pub_date=datetime.date(2005, 7, 27), reporter_id=str(self.r.id))
+        a4 = Article(
+            headline="Fourth article",
+            pub_date=datetime.date(2005, 7, 27),
+            reporter_id=str(self.r.id),
+        )
         a4.save()
         self.assertEqual(repr(a4.reporter), "<Reporter: John Smith>")
 
     def test_add(self):
         # Create an Article via the Reporter object.
-        new_article = self.r.article_set.create(headline="John's second story", pub_date=datetime.date(2005, 7, 29))
+        new_article = self.r.article_set.create(
+            headline="John's second story", pub_date=datetime.date(2005, 7, 29)
+        )
         self.assertEqual(repr(new_article), "<Article: John's second story>")
         self.assertEqual(new_article.reporter.id, self.r.id)
 
         # Create a new article, and add it to the article set.
-        new_article2 = Article(headline="Paul's story", pub_date=datetime.date(2006, 1, 17))
+        new_article2 = Article(
+            headline="Paul's story", pub_date=datetime.date(2006, 1, 17)
+        )
         msg = "<Article: Paul's story> instance isn't saved. Use bulk=False or save the object first."
         with self.assertRaisesMessage(ValueError, msg):
             self.r.article_set.add(new_article2)
@@ -69,7 +102,9 @@ class ManyToOneTests(TestCase):
 
         # Adding an object of the wrong type raises TypeError.
         with transaction.atomic():
-            with self.assertRaisesMessage(TypeError, "'Article' instance expected, got <Reporter:"):
+            with self.assertRaisesMessage(
+                TypeError, "'Article' instance expected, got <Reporter:"
+            ):
                 self.r.article_set.add(self.r2)
         self.assertSequenceEqual(
             self.r.article_set.all(),
@@ -77,8 +112,12 @@ class ManyToOneTests(TestCase):
         )
 
     def test_set(self):
-        new_article = self.r.article_set.create(headline="John's second story", pub_date=datetime.date(2005, 7, 29))
-        new_article2 = self.r2.article_set.create(headline="Paul's story", pub_date=datetime.date(2006, 1, 17))
+        new_article = self.r.article_set.create(
+            headline="John's second story", pub_date=datetime.date(2005, 7, 29)
+        )
+        new_article2 = self.r2.article_set.create(
+            headline="Paul's story", pub_date=datetime.date(2006, 1, 17)
+        )
 
         # Assign the article to the reporter.
         new_article2.reporter = self.r
@@ -117,8 +156,12 @@ class ManyToOneTests(TestCase):
             self.r2.article_set = []
 
     def test_assign(self):
-        new_article = self.r.article_set.create(headline="John's second story", pub_date=datetime.date(2005, 7, 29))
-        new_article2 = self.r2.article_set.create(headline="Paul's story", pub_date=datetime.date(2006, 1, 17))
+        new_article = self.r.article_set.create(
+            headline="John's second story", pub_date=datetime.date(2005, 7, 29)
+        )
+        new_article2 = self.r2.article_set.create(
+            headline="Paul's story", pub_date=datetime.date(2006, 1, 17)
+        )
 
         # Assign the article to the reporter directly using the descriptor.
         new_article2.reporter = self.r
@@ -148,13 +191,13 @@ class ManyToOneTests(TestCase):
         )
         self.assertSequenceEqual(self.r2.article_set.all(), [new_article2])
         # Reporter cannot be null - there should not be a clear or remove method
-        self.assertFalse(hasattr(self.r2.article_set, 'remove'))
-        self.assertFalse(hasattr(self.r2.article_set, 'clear'))
+        self.assertFalse(hasattr(self.r2.article_set, "remove"))
+        self.assertFalse(hasattr(self.r2.article_set, "clear"))
 
     def test_assign_fk_id_value(self):
-        parent = Parent.objects.create(name='jeff')
-        child1 = Child.objects.create(name='frank', parent=parent)
-        child2 = Child.objects.create(name='randy', parent=parent)
+        parent = Parent.objects.create(name="jeff")
+        child1 = Child.objects.create(name="frank", parent=parent)
+        child2 = Child.objects.create(name="randy", parent=parent)
         parent.bestchild = child1
         parent.save()
         parent.bestchild_id = child2.pk
@@ -168,8 +211,8 @@ class ManyToOneTests(TestCase):
         self.assertTrue(Parent.bestchild.is_cached(parent))
 
     def test_assign_fk_id_none(self):
-        parent = Parent.objects.create(name='jeff')
-        child = Child.objects.create(name='frank', parent=parent)
+        parent = Parent.objects.create(name="jeff")
+        child = Child.objects.create(name="frank", parent=parent)
         parent.bestchild = child
         parent.save()
         parent.bestchild_id = None
@@ -193,49 +236,62 @@ class ManyToOneTests(TestCase):
             self.r.article_set.all(),
             [new_article1, self.a],
         )
-        self.assertSequenceEqual(self.r.article_set.filter(headline__startswith='This'), [self.a])
+        self.assertSequenceEqual(
+            self.r.article_set.filter(headline__startswith="This"), [self.a]
+        )
         self.assertEqual(self.r.article_set.count(), 2)
         self.assertEqual(self.r2.article_set.count(), 1)
         # Get articles by id
         self.assertSequenceEqual(Article.objects.filter(id__exact=self.a.id), [self.a])
         self.assertSequenceEqual(Article.objects.filter(pk=self.a.id), [self.a])
         # Query on an article property
-        self.assertSequenceEqual(Article.objects.filter(headline__startswith='This'), [self.a])
+        self.assertSequenceEqual(
+            Article.objects.filter(headline__startswith="This"), [self.a]
+        )
         # The API automatically follows relationships as far as you need.
         # Use double underscores to separate relationships.
         # This works as many levels deep as you want. There's no limit.
         # Find all Articles for any Reporter whose first name is "John".
         self.assertSequenceEqual(
-            Article.objects.filter(reporter__first_name__exact='John'),
+            Article.objects.filter(reporter__first_name__exact="John"),
             [new_article1, self.a],
         )
         # Implied __exact also works
         self.assertSequenceEqual(
-            Article.objects.filter(reporter__first_name='John'),
+            Article.objects.filter(reporter__first_name="John"),
             [new_article1, self.a],
         )
         # Query twice over the related field.
         self.assertSequenceEqual(
-            Article.objects.filter(reporter__first_name__exact='John', reporter__last_name__exact='Smith'),
+            Article.objects.filter(
+                reporter__first_name__exact="John", reporter__last_name__exact="Smith"
+            ),
             [new_article1, self.a],
         )
         # The underlying query only makes one join when a related table is referenced twice.
-        queryset = Article.objects.filter(reporter__first_name__exact='John', reporter__last_name__exact='Smith')
+        queryset = Article.objects.filter(
+            reporter__first_name__exact="John", reporter__last_name__exact="Smith"
+        )
         self.assertNumQueries(1, list, queryset)
-        self.assertEqual(queryset.query.get_compiler(queryset.db).as_sql()[0].count('INNER JOIN'), 1)
+        self.assertEqual(
+            queryset.query.get_compiler(queryset.db).as_sql()[0].count("INNER JOIN"), 1
+        )
 
         # The automatically joined table has a predictable name.
         self.assertSequenceEqual(
-            Article.objects.filter(reporter__first_name__exact='John').extra(
-                where=["many_to_one_reporter.last_name='Smith'"]),
+            Article.objects.filter(reporter__first_name__exact="John").extra(
+                where=["many_to_one_reporter.last_name='Smith'"]
+            ),
             [new_article1, self.a],
         )
         # ... and should work fine with the string that comes out of forms.Form.cleaned_data
         self.assertQuerysetEqual(
-            (Article.objects
-                .filter(reporter__first_name__exact='John')
-                .extra(where=["many_to_one_reporter.last_name='%s'" % 'Smith'])),
-            [new_article1, self.a]
+            (
+                Article.objects.filter(reporter__first_name__exact="John").extra(
+                    where=["many_to_one_reporter.last_name='%s'" % "Smith"]
+                )
+            ),
+            [new_article1, self.a],
         )
         # Find all Articles for a Reporter.
         # Use direct ID check, pk check, and object comparison
@@ -268,7 +324,9 @@ class ManyToOneTests(TestCase):
         # then converted into a query
         self.assertSequenceEqual(
             Article.objects.filter(
-                reporter__in=Reporter.objects.filter(first_name='John').values('pk').query
+                reporter__in=Reporter.objects.filter(first_name="John")
+                .values("pk")
+                .query
             ).distinct(),
             [new_article1, self.a],
         )
@@ -286,69 +344,114 @@ class ManyToOneTests(TestCase):
         )
         john_smith = [self.r]
         # Reporters can be queried
-        self.assertSequenceEqual(Reporter.objects.filter(id__exact=self.r.id), john_smith)
+        self.assertSequenceEqual(
+            Reporter.objects.filter(id__exact=self.r.id), john_smith
+        )
         self.assertSequenceEqual(Reporter.objects.filter(pk=self.r.id), john_smith)
-        self.assertSequenceEqual(Reporter.objects.filter(first_name__startswith='John'), john_smith)
+        self.assertSequenceEqual(
+            Reporter.objects.filter(first_name__startswith="John"), john_smith
+        )
         # Reporters can query in opposite direction of ForeignKey definition
-        self.assertSequenceEqual(Reporter.objects.filter(article__id__exact=self.a.id), john_smith)
-        self.assertSequenceEqual(Reporter.objects.filter(article__pk=self.a.id), john_smith)
+        self.assertSequenceEqual(
+            Reporter.objects.filter(article__id__exact=self.a.id), john_smith
+        )
+        self.assertSequenceEqual(
+            Reporter.objects.filter(article__pk=self.a.id), john_smith
+        )
         self.assertSequenceEqual(Reporter.objects.filter(article=self.a.id), john_smith)
         self.assertSequenceEqual(Reporter.objects.filter(article=self.a), john_smith)
-        self.assertSequenceEqual(Reporter.objects.filter(article__in=[self.a.id, a3.id]).distinct(), john_smith)
-        self.assertSequenceEqual(Reporter.objects.filter(article__in=[self.a.id, a3]).distinct(), john_smith)
-        self.assertSequenceEqual(Reporter.objects.filter(article__in=[self.a, a3]).distinct(), john_smith)
+        self.assertSequenceEqual(
+            Reporter.objects.filter(article__in=[self.a.id, a3.id]).distinct(),
+            john_smith,
+        )
+        self.assertSequenceEqual(
+            Reporter.objects.filter(article__in=[self.a.id, a3]).distinct(), john_smith
+        )
+        self.assertSequenceEqual(
+            Reporter.objects.filter(article__in=[self.a, a3]).distinct(), john_smith
+        )
         self.assertCountEqual(
-            Reporter.objects.filter(article__headline__startswith='T'),
+            Reporter.objects.filter(article__headline__startswith="T"),
             [self.r, self.r],
         )
-        self.assertSequenceEqual(Reporter.objects.filter(article__headline__startswith='T').distinct(), john_smith)
+        self.assertSequenceEqual(
+            Reporter.objects.filter(article__headline__startswith="T").distinct(),
+            john_smith,
+        )
 
         # Counting in the opposite direction works in conjunction with distinct()
-        self.assertEqual(Reporter.objects.filter(article__headline__startswith='T').count(), 2)
-        self.assertEqual(Reporter.objects.filter(article__headline__startswith='T').distinct().count(), 1)
+        self.assertEqual(
+            Reporter.objects.filter(article__headline__startswith="T").count(), 2
+        )
+        self.assertEqual(
+            Reporter.objects.filter(article__headline__startswith="T")
+            .distinct()
+            .count(),
+            1,
+        )
 
         # Queries can go round in circles.
         self.assertCountEqual(
-            Reporter.objects.filter(article__reporter__first_name__startswith='John'),
+            Reporter.objects.filter(article__reporter__first_name__startswith="John"),
             [self.r, self.r, self.r],
         )
         self.assertSequenceEqual(
-            Reporter.objects.filter(article__reporter__first_name__startswith='John').distinct(),
-            john_smith
+            Reporter.objects.filter(
+                article__reporter__first_name__startswith="John"
+            ).distinct(),
+            john_smith,
+        )
+        self.assertSequenceEqual(
+            Reporter.objects.filter(article__reporter__exact=self.r).distinct(),
+            john_smith,
         )
-        self.assertSequenceEqual(Reporter.objects.filter(article__reporter__exact=self.r).distinct(), john_smith)
 
         # Implied __exact also works.
-        self.assertSequenceEqual(Reporter.objects.filter(article__reporter=self.r).distinct(), john_smith)
+        self.assertSequenceEqual(
+            Reporter.objects.filter(article__reporter=self.r).distinct(), john_smith
+        )
 
         # It's possible to use values() calls across many-to-one relations.
         # (Note, too, that we clear the ordering here so as not to drag the
         # 'headline' field into the columns being used to determine uniqueness)
-        d = {'reporter__first_name': 'John', 'reporter__last_name': 'Smith'}
-        qs = Article.objects.filter(
-            reporter=self.r,
-        ).distinct().order_by().values('reporter__first_name', 'reporter__last_name')
+        d = {"reporter__first_name": "John", "reporter__last_name": "Smith"}
+        qs = (
+            Article.objects.filter(
+                reporter=self.r,
+            )
+            .distinct()
+            .order_by()
+            .values("reporter__first_name", "reporter__last_name")
+        )
         self.assertEqual([d], list(qs))
 
     def test_select_related(self):
         # Article.objects.select_related().dates() works properly when there
         # are multiple Articles with the same date but different foreign-key
         # objects (Reporters).
-        r1 = Reporter.objects.create(first_name='Mike', last_name='Royko', email='royko@suntimes.com')
-        r2 = Reporter.objects.create(first_name='John', last_name='Kass', email='jkass@tribune.com')
-        Article.objects.create(headline='First', pub_date=datetime.date(1980, 4, 23), reporter=r1)
-        Article.objects.create(headline='Second', pub_date=datetime.date(1980, 4, 23), reporter=r2)
+        r1 = Reporter.objects.create(
+            first_name="Mike", last_name="Royko", email="royko@suntimes.com"
+        )
+        r2 = Reporter.objects.create(
+            first_name="John", last_name="Kass", email="jkass@tribune.com"
+        )
+        Article.objects.create(
+            headline="First", pub_date=datetime.date(1980, 4, 23), reporter=r1
+        )
+        Article.objects.create(
+            headline="Second", pub_date=datetime.date(1980, 4, 23), reporter=r2
+        )
         self.assertEqual(
-            list(Article.objects.select_related().dates('pub_date', 'day')),
-            [datetime.date(1980, 4, 23), datetime.date(2005, 7, 27)]
+            list(Article.objects.select_related().dates("pub_date", "day")),
+            [datetime.date(1980, 4, 23), datetime.date(2005, 7, 27)],
         )
         self.assertEqual(
-            list(Article.objects.select_related().dates('pub_date', 'month')),
-            [datetime.date(1980, 4, 1), datetime.date(2005, 7, 1)]
+            list(Article.objects.select_related().dates("pub_date", "month")),
+            [datetime.date(1980, 4, 1), datetime.date(2005, 7, 1)],
         )
         self.assertEqual(
-            list(Article.objects.select_related().dates('pub_date', 'year')),
-            [datetime.date(1980, 1, 1), datetime.date(2005, 1, 1)]
+            list(Article.objects.select_related().dates("pub_date", "year")),
+            [datetime.date(1980, 1, 1), datetime.date(2005, 1, 1)],
         )
 
     def test_delete(self):
@@ -376,7 +479,7 @@ class ManyToOneTests(TestCase):
             [new_article4, new_article1, new_article2, new_article3, self.a],
         )
         self.assertSequenceEqual(
-            Reporter.objects.order_by('first_name'),
+            Reporter.objects.order_by("first_name"),
             [self.r, self.r2],
         )
         self.r2.delete()
@@ -384,9 +487,9 @@ class ManyToOneTests(TestCase):
             Article.objects.all(),
             [new_article4, new_article1, new_article3, self.a],
         )
-        self.assertSequenceEqual(Reporter.objects.order_by('first_name'), [self.r])
+        self.assertSequenceEqual(Reporter.objects.order_by("first_name"), [self.r])
         # You can delete using a JOIN in the query.
-        Reporter.objects.filter(article__headline__startswith='This').delete()
+        Reporter.objects.filter(article__headline__startswith="This").delete()
         self.assertSequenceEqual(Reporter.objects.all(), [])
         self.assertSequenceEqual(Article.objects.all(), [])
 
@@ -416,12 +519,16 @@ class ManyToOneTests(TestCase):
         self.assertEqual(a3.reporter.id, self.r2.id)
 
         # Get should respect explicit foreign keys as well.
-        msg = 'get() returned more than one Article -- it returned 2!'
+        msg = "get() returned more than one Article -- it returned 2!"
         with self.assertRaisesMessage(MultipleObjectsReturned, msg):
             Article.objects.get(reporter_id=self.r.id)
         self.assertEqual(
             repr(a3),
-            repr(Article.objects.get(reporter_id=self.r2.id, pub_date=datetime.date(2011, 5, 7)))
+            repr(
+                Article.objects.get(
+                    reporter_id=self.r2.id, pub_date=datetime.date(2011, 5, 7)
+                )
+            ),
         )
 
     def test_deepcopy_and_circular_references(self):
@@ -431,8 +538,8 @@ class ManyToOneTests(TestCase):
         self.assertEqual(repr(deepcopy(self.r)), "<Reporter: John Smith>")
 
     def test_manager_class_caching(self):
-        r1 = Reporter.objects.create(first_name='Mike')
-        r2 = Reporter.objects.create(first_name='John')
+        r1 = Reporter.objects.create(first_name="Mike")
+        r2 = Reporter.objects.create(first_name="John")
 
         # Same twice
         self.assertIs(r1.article_set.__class__, r1.article_set.__class__)
@@ -441,21 +548,29 @@ class ManyToOneTests(TestCase):
         self.assertIs(r1.article_set.__class__, r2.article_set.__class__)
 
     def test_create_relation_with_gettext_lazy(self):
-        reporter = Reporter.objects.create(first_name='John', last_name='Smith', email='john.smith@example.com')
-        lazy = gettext_lazy('test')
+        reporter = Reporter.objects.create(
+            first_name="John", last_name="Smith", email="john.smith@example.com"
+        )
+        lazy = gettext_lazy("test")
         reporter.article_set.create(headline=lazy, pub_date=datetime.date(2011, 6, 10))
         notlazy = str(lazy)
         article = reporter.article_set.get()
         self.assertEqual(article.headline, notlazy)
 
     def test_values_list_exception(self):
-        expected_message = "Cannot resolve keyword 'notafield' into field. Choices are: %s"
-        reporter_fields = ', '.join(sorted(f.name for f in Reporter._meta.get_fields()))
+        expected_message = (
+            "Cannot resolve keyword 'notafield' into field. Choices are: %s"
+        )
+        reporter_fields = ", ".join(sorted(f.name for f in Reporter._meta.get_fields()))
         with self.assertRaisesMessage(FieldError, expected_message % reporter_fields):
-            Article.objects.values_list('reporter__notafield')
-        article_fields = ', '.join(['EXTRA'] + sorted(f.name for f in Article._meta.get_fields()))
+            Article.objects.values_list("reporter__notafield")
+        article_fields = ", ".join(
+            ["EXTRA"] + sorted(f.name for f in Article._meta.get_fields())
+        )
         with self.assertRaisesMessage(FieldError, expected_message % article_fields):
-            Article.objects.extra(select={'EXTRA': 'EXTRA_SELECT'}).values_list('notafield')
+            Article.objects.extra(select={"EXTRA": "EXTRA_SELECT"}).values_list(
+                "notafield"
+            )
 
     def test_fk_assignment_and_related_object_cache(self):
         # Tests of ForeignKey assignment and the related-object cache (see #6886).
@@ -471,7 +586,7 @@ class ManyToOneTests(TestCase):
         self.assertIs(c.parent, p)
 
         # But if we kill the cache, we get a new object.
-        del c._state.fields_cache['parent']
+        del c._state.fields_cache["parent"]
         self.assertIsNot(c.parent, p)
 
         # Assigning a new object results in that object getting cached immediately.
@@ -503,12 +618,12 @@ class ManyToOneTests(TestCase):
             setattr(c, "parent", First(id=1, second=1))
 
         # You can assign None to Child.parent during object creation.
-        Child(name='xyzzy', parent=None)
+        Child(name="xyzzy", parent=None)
 
         # But when trying to save a Child with parent=None, the database will
         # raise IntegrityError.
         with self.assertRaises(IntegrityError), transaction.atomic():
-            Child.objects.create(name='xyzzy', parent=None)
+            Child.objects.create(name="xyzzy", parent=None)
 
         # Creation using keyword argument should cache the related object.
         p = Parent.objects.get(name="Parent")
@@ -541,7 +656,7 @@ class ManyToOneTests(TestCase):
         self.assertEqual(child.parent, parent)
 
     def test_save_nullable_fk_after_parent_with_to_field(self):
-        parent = Parent(name='jeff')
+        parent = Parent(name="jeff")
         child = ToFieldChild(parent=parent)
         parent.save()
         child.save()
@@ -552,7 +667,7 @@ class ManyToOneTests(TestCase):
     def test_save_fk_after_parent_with_non_numeric_pk_set_on_child(self):
         parent = ParentStringPrimaryKey()
         child = ChildStringPrimaryKeyParent(parent=parent)
-        child.parent.name = 'jeff'
+        child.parent.name = "jeff"
         parent.save()
         child.save()
         child.refresh_from_db()
@@ -560,28 +675,28 @@ class ManyToOneTests(TestCase):
         self.assertEqual(child.parent_id, parent.name)
 
     def test_fk_to_bigautofield(self):
-        ch = City.objects.create(name='Chicago')
-        District.objects.create(city=ch, name='Far South')
-        District.objects.create(city=ch, name='North')
+        ch = City.objects.create(name="Chicago")
+        District.objects.create(city=ch, name="Far South")
+        District.objects.create(city=ch, name="North")
 
-        ny = City.objects.create(name='New York', id=2 ** 33)
-        District.objects.create(city=ny, name='Brooklyn')
-        District.objects.create(city=ny, name='Manhattan')
+        ny = City.objects.create(name="New York", id=2**33)
+        District.objects.create(city=ny, name="Brooklyn")
+        District.objects.create(city=ny, name="Manhattan")
 
     def test_fk_to_smallautofield(self):
-        us = Country.objects.create(name='United States')
-        City.objects.create(country=us, name='Chicago')
-        City.objects.create(country=us, name='New York')
+        us = Country.objects.create(name="United States")
+        City.objects.create(country=us, name="Chicago")
+        City.objects.create(country=us, name="New York")
 
-        uk = Country.objects.create(name='United Kingdom', id=2 ** 11)
-        City.objects.create(country=uk, name='London')
-        City.objects.create(country=uk, name='Edinburgh')
+        uk = Country.objects.create(name="United Kingdom", id=2**11)
+        City.objects.create(country=uk, name="London")
+        City.objects.create(country=uk, name="Edinburgh")
 
     def test_multiple_foreignkeys(self):
         # Test of multiple ForeignKeys to the same model (bug #7125).
-        c1 = Category.objects.create(name='First')
-        c2 = Category.objects.create(name='Second')
-        c3 = Category.objects.create(name='Third')
+        c1 = Category.objects.create(name="First")
+        c2 = Category.objects.create(name="Second")
+        c3 = Category.objects.create(name="Third")
         r1 = Record.objects.create(category=c1)
         r2 = Record.objects.create(category=c1)
         r3 = Record.objects.create(category=c2)
@@ -593,10 +708,14 @@ class ManyToOneTests(TestCase):
         Relation.objects.create(left=r5, right=r2)
         Relation.objects.create(left=r3, right=r2)
 
-        q1 = Relation.objects.filter(left__category__name__in=['First'], right__category__name__in=['Second'])
+        q1 = Relation.objects.filter(
+            left__category__name__in=["First"], right__category__name__in=["Second"]
+        )
         self.assertSequenceEqual(q1, [rel])
 
-        q2 = Category.objects.filter(record__left_set__right__category__name='Second').order_by('name')
+        q2 = Category.objects.filter(
+            record__left_set__right__category__name="Second"
+        ).order_by("name")
         self.assertSequenceEqual(q2, [c1, c2])
 
         p = Parent.objects.create(name="Parent")
@@ -609,12 +728,12 @@ class ManyToOneTests(TestCase):
         # Regression for #12190 -- Should be able to instantiate a FK outside
         # of a model, and interrogate its related field.
         cat = models.ForeignKey(Category, models.CASCADE)
-        self.assertEqual('id', cat.remote_field.get_related_field().name)
+        self.assertEqual("id", cat.remote_field.get_related_field().name)
 
     def test_relation_unsaved(self):
         # The <field>_set manager does not join on Null value fields (#17541)
-        Third.objects.create(name='Third 1')
-        Third.objects.create(name='Third 2')
+        Third.objects.create(name="Third 1")
+        Third.objects.create(name="Third 2")
         th = Third(name="testing")
         # The object isn't saved and thus the relation field is null - we won't even
         # execute a query in this case.
@@ -642,7 +761,7 @@ class ManyToOneTests(TestCase):
         # allow it.
         self.assertEqual(private_student.school, private_school)
 
-        School._meta.base_manager_name = 'objects'
+        School._meta.base_manager_name = "objects"
         School._meta._expire_cache()
         try:
             private_student = Student.objects.get(pk=private_student.pk)
@@ -656,47 +775,47 @@ class ManyToOneTests(TestCase):
         # The exception raised on attribute access when a related object
         # doesn't exist should be an instance of a subclass of `AttributeError`
         # refs #21563
-        self.assertFalse(hasattr(Article(), 'reporter'))
+        self.assertFalse(hasattr(Article(), "reporter"))
 
     def test_clear_after_prefetch(self):
-        c = City.objects.create(name='Musical City')
-        d = District.objects.create(name='Ladida', city=c)
-        city = City.objects.prefetch_related('districts').get(id=c.id)
+        c = City.objects.create(name="Musical City")
+        d = District.objects.create(name="Ladida", city=c)
+        city = City.objects.prefetch_related("districts").get(id=c.id)
         self.assertSequenceEqual(city.districts.all(), [d])
         city.districts.clear()
         self.assertSequenceEqual(city.districts.all(), [])
 
     def test_remove_after_prefetch(self):
-        c = City.objects.create(name='Musical City')
-        d = District.objects.create(name='Ladida', city=c)
-        city = City.objects.prefetch_related('districts').get(id=c.id)
+        c = City.objects.create(name="Musical City")
+        d = District.objects.create(name="Ladida", city=c)
+        city = City.objects.prefetch_related("districts").get(id=c.id)
         self.assertSequenceEqual(city.districts.all(), [d])
         city.districts.remove(d)
         self.assertSequenceEqual(city.districts.all(), [])
 
     def test_add_after_prefetch(self):
-        c = City.objects.create(name='Musical City')
-        District.objects.create(name='Ladida', city=c)
-        d2 = District.objects.create(name='Ladidu')
-        city = City.objects.prefetch_related('districts').get(id=c.id)
+        c = City.objects.create(name="Musical City")
+        District.objects.create(name="Ladida", city=c)
+        d2 = District.objects.create(name="Ladidu")
+        city = City.objects.prefetch_related("districts").get(id=c.id)
         self.assertEqual(city.districts.count(), 1)
         city.districts.add(d2)
         self.assertEqual(city.districts.count(), 2)
 
     def test_set_after_prefetch(self):
-        c = City.objects.create(name='Musical City')
-        District.objects.create(name='Ladida', city=c)
-        d2 = District.objects.create(name='Ladidu')
-        city = City.objects.prefetch_related('districts').get(id=c.id)
+        c = City.objects.create(name="Musical City")
+        District.objects.create(name="Ladida", city=c)
+        d2 = District.objects.create(name="Ladidu")
+        city = City.objects.prefetch_related("districts").get(id=c.id)
         self.assertEqual(city.districts.count(), 1)
         city.districts.set([d2])
         self.assertSequenceEqual(city.districts.all(), [d2])
 
     def test_add_then_remove_after_prefetch(self):
-        c = City.objects.create(name='Musical City')
-        District.objects.create(name='Ladida', city=c)
-        d2 = District.objects.create(name='Ladidu')
-        city = City.objects.prefetch_related('districts').get(id=c.id)
+        c = City.objects.create(name="Musical City")
+        District.objects.create(name="Ladida", city=c)
+        d2 = District.objects.create(name="Ladidu")
+        city = City.objects.prefetch_related("districts").get(id=c.id)
         self.assertEqual(city.districts.count(), 1)
         city.districts.add(d2)
         self.assertEqual(city.districts.count(), 2)
@@ -714,21 +833,21 @@ class ManyToOneTests(TestCase):
         self.assertEqual(self.a.reporter, self.r2)
 
     def test_cached_foreign_key_with_to_field_not_cleared_by_save(self):
-        parent = Parent.objects.create(name='a')
+        parent = Parent.objects.create(name="a")
         child = ToFieldChild.objects.create(parent=parent)
         with self.assertNumQueries(0):
             self.assertIs(child.parent, parent)
 
     def test_reverse_foreign_key_instance_to_field_caching(self):
-        parent = Parent.objects.create(name='a')
+        parent = Parent.objects.create(name="a")
         ToFieldChild.objects.create(parent=parent)
         child = parent.to_field_children.get()
         with self.assertNumQueries(0):
             self.assertIs(child.parent, parent)
 
     def test_add_remove_set_by_pk_raises(self):
-        usa = Country.objects.create(name='United States')
-        chicago = City.objects.create(name='Chicago')
+        usa = Country.objects.create(name="United States")
+        chicago = City.objects.create(name="Chicago")
         msg = "'City' instance expected, got %s" % chicago.pk
         with self.assertRaisesMessage(TypeError, msg):
             usa.cities.add(chicago.pk)