Refs #33476 -- Reformatted code with Black.

9 files changed, 425 insertions, 300 deletions

diff --git a/tests/foreign_object/models/__init__.py b/tests/foreign_object/models/__init__.py
index 652a2a30a1..69778d3ddd 100644
--- a/tests/foreign_object/models/__init__.py
+++ b/tests/foreign_object/models/__init__.py
@@ -1,12 +1,21 @@
-from .article import (
-    Article, ArticleIdea, ArticleTag, ArticleTranslation, NewsArticle,
-)
+from .article import Article, ArticleIdea, ArticleTag, ArticleTranslation, NewsArticle
 from .customers import Address, Contact, Customer
 from .empty_join import SlugPage
 from .person import Country, Friendship, Group, Membership, Person
 
 __all__ = [
-    'Address', 'Article', 'ArticleIdea', 'ArticleTag', 'ArticleTranslation',
-    'Contact', 'Country', 'Customer', 'Friendship', 'Group', 'Membership',
-    'NewsArticle', 'Person', 'SlugPage',
+    "Address",
+    "Article",
+    "ArticleIdea",
+    "ArticleTag",
+    "ArticleTranslation",
+    "Contact",
+    "Country",
+    "Customer",
+    "Friendship",
+    "Group",
+    "Membership",
+    "NewsArticle",
+    "Person",
+    "SlugPage",
 ]
diff --git a/tests/foreign_object/models/article.py b/tests/foreign_object/models/article.py
index a892ce299d..dedeb8fb2d 100644
--- a/tests/foreign_object/models/article.py
+++ b/tests/foreign_object/models/article.py
@@ -7,6 +7,7 @@ class ArticleTranslationDescriptor(ForwardManyToOneDescriptor):
     """
     The set of articletranslation should not set any local fields.
     """
+
     def __set__(self, instance, value):
         if instance is None:
             raise AttributeError("%s must be accessed via instance" % self.field.name)
@@ -22,7 +23,7 @@ class ColConstraint:
 
     def as_sql(self, compiler, connection):
         qn = compiler.quote_name_unless_alias
-        return '%s.%s = %%s' % (qn(self.alias), qn(self.col)), [self.value]
+        return "%s.%s = %%s" % (qn(self.alias), qn(self.col)), [self.value]
 
 
 class ActiveTranslationField(models.ForeignObject):
@@ -30,13 +31,14 @@ class ActiveTranslationField(models.ForeignObject):
     This field will allow querying and fetching the currently active translation
     for Article from ArticleTranslation.
     """
+
     requires_unique_target = False
 
     def get_extra_restriction(self, alias, related_alias):
-        return ColConstraint(alias, 'lang', get_language())
+        return ColConstraint(alias, "lang", get_language())
 
     def get_extra_descriptor_filter(self, instance):
-        return {'lang': get_language()}
+        return {"lang": get_language()}
 
     def contribute_to_class(self, cls, name):
         super().contribute_to_class(cls, name)
@@ -50,18 +52,18 @@ class ActiveTranslationFieldWithQ(ActiveTranslationField):
 
 class Article(models.Model):
     active_translation = ActiveTranslationField(
-        'ArticleTranslation',
-        from_fields=['id'],
-        to_fields=['article'],
-        related_name='+',
+        "ArticleTranslation",
+        from_fields=["id"],
+        to_fields=["article"],
+        related_name="+",
         on_delete=models.CASCADE,
         null=True,
     )
     active_translation_q = ActiveTranslationFieldWithQ(
-        'ArticleTranslation',
-        from_fields=['id'],
-        to_fields=['article'],
-        related_name='+',
+        "ArticleTranslation",
+        from_fields=["id"],
+        to_fields=["article"],
+        related_name="+",
         on_delete=models.CASCADE,
         null=True,
     )
@@ -71,7 +73,7 @@ class Article(models.Model):
         try:
             return self.active_translation.title
         except ArticleTranslation.DoesNotExist:
-            return '[No translation found]'
+            return "[No translation found]"
 
 
 class NewsArticle(Article):
@@ -86,15 +88,15 @@ class ArticleTranslation(models.Model):
     abstract = models.TextField(null=True)
 
     class Meta:
-        unique_together = ('article', 'lang')
+        unique_together = ("article", "lang")
 
 
 class ArticleTag(models.Model):
     article = models.ForeignKey(
         Article,
         models.CASCADE,
-        related_name='tags',
-        related_query_name='tag',
+        related_name="tags",
+        related_query_name="tag",
     )
     name = models.CharField(max_length=255)
 
@@ -102,7 +104,7 @@ class ArticleTag(models.Model):
 class ArticleIdea(models.Model):
     articles = models.ManyToManyField(
         Article,
-        related_name='ideas',
-        related_query_name='idea_things',
+        related_name="ideas",
+        related_query_name="idea_things",
     )
     name = models.CharField(max_length=255)
diff --git a/tests/foreign_object/models/customers.py b/tests/foreign_object/models/customers.py
index 7e1a3ac370..91ac091524 100644
--- a/tests/foreign_object/models/customers.py
+++ b/tests/foreign_object/models/customers.py
@@ -7,7 +7,7 @@ class Address(models.Model):
 
     class Meta:
         unique_together = [
-            ('company', 'customer_id'),
+            ("company", "customer_id"),
         ]
 
 
@@ -15,15 +15,17 @@ class Customer(models.Model):
     company = models.CharField(max_length=1)
     customer_id = models.IntegerField()
     address = models.ForeignObject(
-        Address, models.CASCADE, null=True,
+        Address,
+        models.CASCADE,
+        null=True,
         # order mismatches the Contact ForeignObject.
-        from_fields=['company', 'customer_id'],
-        to_fields=['company', 'customer_id'],
+        from_fields=["company", "customer_id"],
+        to_fields=["company", "customer_id"],
     )
 
     class Meta:
         unique_together = [
-            ('company', 'customer_id'),
+            ("company", "customer_id"),
         ]
 
 
@@ -31,7 +33,9 @@ class Contact(models.Model):
     company_code = models.CharField(max_length=1)
     customer_code = models.IntegerField()
     customer = models.ForeignObject(
-        Customer, models.CASCADE, related_name='contacts',
-        to_fields=['customer_id', 'company'],
-        from_fields=['customer_code', 'company_code'],
+        Customer,
+        models.CASCADE,
+        related_name="contacts",
+        to_fields=["customer_id", "company"],
+        from_fields=["customer_code", "company_code"],
     )
diff --git a/tests/foreign_object/models/empty_join.py b/tests/foreign_object/models/empty_join.py
index da151ae8e7..9c0ada378c 100644
--- a/tests/foreign_object/models/empty_join.py
+++ b/tests/foreign_object/models/empty_join.py
@@ -9,6 +9,7 @@ class CustomForeignObjectRel(models.ForeignObjectRel):
     Define some extra Field methods so this Rel acts more like a Field, which
     lets us use ReverseManyToOneDescriptor in both directions.
     """
+
     @property
     def foreign_related_fields(self):
         return tuple(lhs_field for lhs_field, rhs_field in self.field.related_fields)
@@ -23,6 +24,7 @@ class StartsWithRelation(models.ForeignObject):
     the default equality operator. This is logically a many-to-many relation
     and creates a ReverseManyToOneDescriptor in both directions.
     """
+
     auto_created = False
 
     many_to_many = False
@@ -33,7 +35,7 @@ class StartsWithRelation(models.ForeignObject):
     rel_class = CustomForeignObjectRel
 
     def __init__(self, *args, **kwargs):
-        kwargs['on_delete'] = models.DO_NOTHING
+        kwargs["on_delete"] = models.DO_NOTHING
         super().__init__(*args, **kwargs)
 
     @property
@@ -54,28 +56,32 @@ class StartsWithRelation(models.ForeignObject):
     def get_path_info(self, filtered_relation=None):
         to_opts = self.remote_field.model._meta
         from_opts = self.model._meta
-        return [PathInfo(
-            from_opts=from_opts,
-            to_opts=to_opts,
-            target_fields=(to_opts.pk,),
-            join_field=self,
-            m2m=False,
-            direct=False,
-            filtered_relation=filtered_relation,
-        )]
+        return [
+            PathInfo(
+                from_opts=from_opts,
+                to_opts=to_opts,
+                target_fields=(to_opts.pk,),
+                join_field=self,
+                m2m=False,
+                direct=False,
+                filtered_relation=filtered_relation,
+            )
+        ]
 
     def get_reverse_path_info(self, filtered_relation=None):
         to_opts = self.model._meta
         from_opts = self.remote_field.model._meta
-        return [PathInfo(
-            from_opts=from_opts,
-            to_opts=to_opts,
-            target_fields=(to_opts.pk,),
-            join_field=self.remote_field,
-            m2m=False,
-            direct=False,
-            filtered_relation=filtered_relation,
-        )]
+        return [
+            PathInfo(
+                from_opts=from_opts,
+                to_opts=to_opts,
+                target_fields=(to_opts.pk,),
+                join_field=self.remote_field,
+                m2m=False,
+                direct=False,
+                filtered_relation=filtered_relation,
+            )
+        ]
 
     def contribute_to_class(self, cls, name, private_only=False):
         super().contribute_to_class(cls, name, private_only)
@@ -87,6 +93,7 @@ class BrokenContainsRelation(StartsWithRelation):
     This model is designed to yield no join conditions and
     raise an exception in ``Join.as_sql()``.
     """
+
     def get_extra_restriction(self, alias, related_alias):
         return None
 
@@ -94,19 +101,19 @@ class BrokenContainsRelation(StartsWithRelation):
 class SlugPage(models.Model):
     slug = models.CharField(max_length=20, unique=True)
     descendants = StartsWithRelation(
-        'self',
-        from_fields=['slug'],
-        to_fields=['slug'],
-        related_name='ascendants',
+        "self",
+        from_fields=["slug"],
+        to_fields=["slug"],
+        related_name="ascendants",
     )
     containers = BrokenContainsRelation(
-        'self',
-        from_fields=['slug'],
-        to_fields=['slug'],
+        "self",
+        from_fields=["slug"],
+        to_fields=["slug"],
     )
 
     class Meta:
-        ordering = ['slug']
+        ordering = ["slug"]
 
     def __str__(self):
-        return 'SlugPage %s' % self.slug
+        return "SlugPage %s" % self.slug
diff --git a/tests/foreign_object/models/person.py b/tests/foreign_object/models/person.py
index cd04d1eeda..33063e728a 100644
--- a/tests/foreign_object/models/person.py
+++ b/tests/foreign_object/models/person.py
@@ -19,14 +19,14 @@ class Person(models.Model):
     # Relation Fields
     person_country = models.ForeignObject(
         Country,
-        from_fields=['person_country_id'],
-        to_fields=['id'],
+        from_fields=["person_country_id"],
+        to_fields=["id"],
         on_delete=models.CASCADE,
     )
-    friends = models.ManyToManyField('self', through='Friendship', symmetrical=False)
+    friends = models.ManyToManyField("self", through="Friendship", symmetrical=False)
 
     class Meta:
-        ordering = ('name',)
+        ordering = ("name",)
 
     def __str__(self):
         return self.name
@@ -36,10 +36,12 @@ class Group(models.Model):
     # Table Column Fields
     name = models.CharField(max_length=128)
     group_country = models.ForeignKey(Country, models.CASCADE)
-    members = models.ManyToManyField(Person, related_name='groups', through='Membership')
+    members = models.ManyToManyField(
+        Person, related_name="groups", through="Membership"
+    )
 
     class Meta:
-        ordering = ('name',)
+        ordering = ("name",)
 
     def __str__(self):
         return self.name
@@ -56,28 +58,30 @@ class Membership(models.Model):
     # Relation Fields
     person = models.ForeignObject(
         Person,
-        from_fields=['person_id', 'membership_country'],
-        to_fields=['id', 'person_country_id'],
+        from_fields=["person_id", "membership_country"],
+        to_fields=["id", "person_country_id"],
         on_delete=models.CASCADE,
     )
     group = models.ForeignObject(
         Group,
-        from_fields=['group_id', 'membership_country'],
-        to_fields=['id', 'group_country'],
+        from_fields=["group_id", "membership_country"],
+        to_fields=["id", "group_country"],
         on_delete=models.CASCADE,
     )
 
     class Meta:
-        ordering = ('date_joined', 'invite_reason')
+        ordering = ("date_joined", "invite_reason")
 
     def __str__(self):
-        group_name = self.group.name if self.group_id else 'NULL'
+        group_name = self.group.name if self.group_id else "NULL"
         return "%s is a member of %s" % (self.person.name, group_name)
 
 
 class Friendship(models.Model):
     # Table Column Fields
-    from_friend_country = models.ForeignKey(Country, models.CASCADE, related_name="from_friend_country")
+    from_friend_country = models.ForeignKey(
+        Country, models.CASCADE, related_name="from_friend_country"
+    )
     from_friend_id = models.IntegerField()
     to_friend_country_id = models.IntegerField()
     to_friend_id = models.IntegerField()
@@ -86,23 +90,23 @@ class Friendship(models.Model):
     from_friend = models.ForeignObject(
         Person,
         on_delete=models.CASCADE,
-        from_fields=['from_friend_country', 'from_friend_id'],
-        to_fields=['person_country_id', 'id'],
-        related_name='from_friend',
+        from_fields=["from_friend_country", "from_friend_id"],
+        to_fields=["person_country_id", "id"],
+        related_name="from_friend",
     )
 
     to_friend_country = models.ForeignObject(
         Country,
-        from_fields=['to_friend_country_id'],
-        to_fields=['id'],
-        related_name='to_friend_country',
+        from_fields=["to_friend_country_id"],
+        to_fields=["id"],
+        related_name="to_friend_country",
         on_delete=models.CASCADE,
     )
 
     to_friend = models.ForeignObject(
         Person,
-        from_fields=['to_friend_country_id', 'to_friend_id'],
-        to_fields=['person_country_id', 'id'],
-        related_name='to_friend',
+        from_fields=["to_friend_country_id", "to_friend_id"],
+        to_fields=["person_country_id", "id"],
+        related_name="to_friend",
         on_delete=models.CASCADE,
     )
diff --git a/tests/foreign_object/test_agnostic_order_trimjoin.py b/tests/foreign_object/test_agnostic_order_trimjoin.py
index d3b7184be6..c5b8f66e7b 100644
--- a/tests/foreign_object/test_agnostic_order_trimjoin.py
+++ b/tests/foreign_object/test_agnostic_order_trimjoin.py
@@ -6,7 +6,6 @@ from .models import Address, Contact, Customer
 
 
 class TestLookupQuery(TestCase):
-
     @classmethod
     def setUpTestData(cls):
         cls.address = Address.objects.create(company=1, customer_id=20)
@@ -17,12 +16,12 @@ class TestLookupQuery(TestCase):
         self.assertQuerysetEqual(
             Address.objects.filter(customer__contacts=self.contact1),
             [self.address.id],
-            attrgetter('id')
+            attrgetter("id"),
         )
 
     def test_deep_mixed_backward(self):
         self.assertQuerysetEqual(
             Contact.objects.filter(customer__address=self.address),
             [self.contact1.id],
-            attrgetter('id')
+            attrgetter("id"),
         )
diff --git a/tests/foreign_object/test_empty_join.py b/tests/foreign_object/test_empty_join.py
index 83300fd25b..39ef257842 100644
--- a/tests/foreign_object/test_empty_join.py
+++ b/tests/foreign_object/test_empty_join.py
@@ -7,12 +7,12 @@ class RestrictedConditionsTests(TestCase):
     @classmethod
     def setUpTestData(cls):
         slugs = [
-            'a',
-            'a/a',
-            'a/b',
-            'a/b/a',
-            'x',
-            'x/y/z',
+            "a",
+            "a/a",
+            "a/b",
+            "a/b/a",
+            "x",
+            "x/y/z",
         ]
         SlugPage.objects.bulk_create([SlugPage(slug=slug) for slug in slugs])
 
@@ -21,28 +21,28 @@ class RestrictedConditionsTests(TestCase):
         It's possible to create a working related field that doesn't
         use any joining columns, as long as an extra restriction is supplied.
         """
-        a = SlugPage.objects.get(slug='a')
+        a = SlugPage.objects.get(slug="a")
         self.assertEqual(
             [p.slug for p in SlugPage.objects.filter(ascendants=a)],
-            ['a', 'a/a', 'a/b', 'a/b/a'],
+            ["a", "a/a", "a/b", "a/b/a"],
         )
         self.assertEqual(
             [p.slug for p in a.descendants.all()],
-            ['a', 'a/a', 'a/b', 'a/b/a'],
+            ["a", "a/a", "a/b", "a/b/a"],
         )
 
-        aba = SlugPage.objects.get(slug='a/b/a')
+        aba = SlugPage.objects.get(slug="a/b/a")
         self.assertEqual(
             [p.slug for p in SlugPage.objects.filter(descendants__in=[aba])],
-            ['a', 'a/b', 'a/b/a'],
+            ["a", "a/b", "a/b/a"],
         )
         self.assertEqual(
             [p.slug for p in aba.ascendants.all()],
-            ['a', 'a/b', 'a/b/a'],
+            ["a", "a/b", "a/b/a"],
         )
 
     def test_empty_join_conditions(self):
-        x = SlugPage.objects.get(slug='x')
+        x = SlugPage.objects.get(slug="x")
         message = "Join generated an empty ON clause."
         with self.assertRaisesMessage(ValueError, message):
             list(SlugPage.objects.filter(containers=x))
diff --git a/tests/foreign_object/test_forms.py b/tests/foreign_object/test_forms.py
index 32a8fc3876..61f8f42295 100644
--- a/tests/foreign_object/test_forms.py
+++ b/tests/foreign_object/test_forms.py
@@ -12,18 +12,18 @@ class FormsTests(TestCase):
     class ArticleForm(forms.ModelForm):
         class Meta:
             model = Article
-            fields = '__all__'
+            fields = "__all__"
 
     def test_foreign_object_form(self):
         # A very crude test checking that the non-concrete fields do not get form fields.
         form = FormsTests.ArticleForm()
-        self.assertIn('id_pub_date', form.as_table())
-        self.assertNotIn('active_translation', form.as_table())
-        form = FormsTests.ArticleForm(data={'pub_date': str(datetime.date.today())})
+        self.assertIn("id_pub_date", form.as_table())
+        self.assertNotIn("active_translation", form.as_table())
+        form = FormsTests.ArticleForm(data={"pub_date": str(datetime.date.today())})
         self.assertTrue(form.is_valid())
         a = form.save()
         self.assertEqual(a.pub_date, datetime.date.today())
-        form = FormsTests.ArticleForm(instance=a, data={'pub_date': '2013-01-01'})
+        form = FormsTests.ArticleForm(instance=a, data={"pub_date": "2013-01-01"})
         a2 = form.save()
         self.assertEqual(a.pk, a2.pk)
         self.assertEqual(a2.pub_date, datetime.date(2013, 1, 1))
diff --git a/tests/foreign_object/tests.py b/tests/foreign_object/tests.py
index 8b61c87e5d..9022fbf9c5 100644
--- a/tests/foreign_object/tests.py
+++ b/tests/foreign_object/tests.py
@@ -10,8 +10,16 @@ from django.test.utils import isolate_apps
 from django.utils import translation
 
 from .models import (
-    Article, ArticleIdea, ArticleTag, ArticleTranslation, Country, Friendship,
-    Group, Membership, NewsArticle, Person,
+    Article,
+    ArticleIdea,
+    ArticleTag,
+    ArticleTranslation,
+    Country,
+    Friendship,
+    Group,
+    Membership,
+    NewsArticle,
+    Person,
 )
 
 # Note that these tests are testing internal implementation details.
@@ -25,25 +33,28 @@ class MultiColumnFKTests(TestCase):
         cls.usa = Country.objects.create(name="United States of America")
         cls.soviet_union = Country.objects.create(name="Soviet Union")
         # Creating People
-        cls.bob = Person.objects.create(name='Bob', person_country=cls.usa)
-        cls.jim = Person.objects.create(name='Jim', person_country=cls.usa)
-        cls.george = Person.objects.create(name='George', person_country=cls.usa)
+        cls.bob = Person.objects.create(name="Bob", person_country=cls.usa)
+        cls.jim = Person.objects.create(name="Jim", person_country=cls.usa)
+        cls.george = Person.objects.create(name="George", person_country=cls.usa)
 
-        cls.jane = Person.objects.create(name='Jane', person_country=cls.soviet_union)
-        cls.mark = Person.objects.create(name='Mark', person_country=cls.soviet_union)
-        cls.sam = Person.objects.create(name='Sam', person_country=cls.soviet_union)
+        cls.jane = Person.objects.create(name="Jane", person_country=cls.soviet_union)
+        cls.mark = Person.objects.create(name="Mark", person_country=cls.soviet_union)
+        cls.sam = Person.objects.create(name="Sam", person_country=cls.soviet_union)
 
         # Creating Groups
-        cls.kgb = Group.objects.create(name='KGB', group_country=cls.soviet_union)
-        cls.cia = Group.objects.create(name='CIA', group_country=cls.usa)
-        cls.republican = Group.objects.create(name='Republican', group_country=cls.usa)
-        cls.democrat = Group.objects.create(name='Democrat', group_country=cls.usa)
+        cls.kgb = Group.objects.create(name="KGB", group_country=cls.soviet_union)
+        cls.cia = Group.objects.create(name="CIA", group_country=cls.usa)
+        cls.republican = Group.objects.create(name="Republican", group_country=cls.usa)
+        cls.democrat = Group.objects.create(name="Democrat", group_country=cls.usa)
 
     def test_get_succeeds_on_multicolumn_match(self):
         # Membership objects have access to their related Person if both
         # country_ids match between them
         membership = Membership.objects.create(
-            membership_country_id=self.usa.id, person_id=self.bob.id, group_id=self.cia.id)
+            membership_country_id=self.usa.id,
+            person_id=self.bob.id,
+            group_id=self.cia.id,
+        )
 
         person = membership.person
         self.assertEqual((person.id, person.name), (self.bob.id, "Bob"))
@@ -52,20 +63,28 @@ class MultiColumnFKTests(TestCase):
         # Membership objects returns DoesNotExist error when there is no
         # Person with the same id and country_id
         membership = Membership.objects.create(
-            membership_country_id=self.usa.id, person_id=self.jane.id, group_id=self.cia.id)
+            membership_country_id=self.usa.id,
+            person_id=self.jane.id,
+            group_id=self.cia.id,
+        )
 
         with self.assertRaises(Person.DoesNotExist):
-            getattr(membership, 'person')
+            getattr(membership, "person")
 
     def test_reverse_query_returns_correct_result(self):
         # Creating a valid membership because it has the same country has the person
         Membership.objects.create(
-            membership_country_id=self.usa.id, person_id=self.bob.id, group_id=self.cia.id)
+            membership_country_id=self.usa.id,
+            person_id=self.bob.id,
+            group_id=self.cia.id,
+        )
 
         # Creating an invalid membership because it has a different country has the person
         Membership.objects.create(
-            membership_country_id=self.soviet_union.id, person_id=self.bob.id,
-            group_id=self.republican.id)
+            membership_country_id=self.soviet_union.id,
+            person_id=self.bob.id,
+            group_id=self.republican.id,
+        )
 
         with self.assertNumQueries(1):
             membership = self.bob.membership_set.get()
@@ -76,20 +95,27 @@ class MultiColumnFKTests(TestCase):
 
         # Creating a to valid memberships
         Membership.objects.create(
-            membership_country_id=self.usa.id, person_id=self.bob.id, group_id=self.cia.id)
+            membership_country_id=self.usa.id,
+            person_id=self.bob.id,
+            group_id=self.cia.id,
+        )
         Membership.objects.create(
-            membership_country_id=self.usa.id, person_id=self.jim.id,
-            group_id=self.cia.id)
+            membership_country_id=self.usa.id,
+            person_id=self.jim.id,
+            group_id=self.cia.id,
+        )
 
         # Creating an invalid membership
-        Membership.objects.create(membership_country_id=self.soviet_union.id,
-                                  person_id=self.george.id, group_id=self.cia.id)
+        Membership.objects.create(
+            membership_country_id=self.soviet_union.id,
+            person_id=self.george.id,
+            group_id=self.cia.id,
+        )
 
         self.assertQuerysetEqual(
-            Membership.objects.filter(person__name__contains='o'), [
-                self.bob.id
-            ],
-            attrgetter("person_id")
+            Membership.objects.filter(person__name__contains="o"),
+            [self.bob.id],
+            attrgetter("person_id"),
         )
 
     def test_reverse_query_filters_correctly(self):
@@ -99,191 +125,228 @@ class MultiColumnFKTests(TestCase):
 
         # Creating a to valid memberships
         Membership.objects.create(
-            membership_country_id=self.usa.id, person_id=self.bob.id,
-            group_id=self.cia.id, date_joined=timemark - timedelta)
+            membership_country_id=self.usa.id,
+            person_id=self.bob.id,
+            group_id=self.cia.id,
+            date_joined=timemark - timedelta,
+        )
         Membership.objects.create(
-            membership_country_id=self.usa.id, person_id=self.jim.id,
-            group_id=self.cia.id, date_joined=timemark + timedelta)
+            membership_country_id=self.usa.id,
+            person_id=self.jim.id,
+            group_id=self.cia.id,
+            date_joined=timemark + timedelta,
+        )
 
         # Creating an invalid membership
         Membership.objects.create(
-            membership_country_id=self.soviet_union.id, person_id=self.george.id,
-            group_id=self.cia.id, date_joined=timemark + timedelta)
+            membership_country_id=self.soviet_union.id,
+            person_id=self.george.id,
+            group_id=self.cia.id,
+            date_joined=timemark + timedelta,
+        )
 
         self.assertQuerysetEqual(
-            Person.objects.filter(membership__date_joined__gte=timemark), [
-                'Jim'
-            ],
-            attrgetter('name')
+            Person.objects.filter(membership__date_joined__gte=timemark),
+            ["Jim"],
+            attrgetter("name"),
         )
 
     def test_forward_in_lookup_filters_correctly(self):
-        Membership.objects.create(membership_country_id=self.usa.id, person_id=self.bob.id,
-                                  group_id=self.cia.id)
-        Membership.objects.create(membership_country_id=self.usa.id, person_id=self.jim.id,
-                                  group_id=self.cia.id)
+        Membership.objects.create(
+            membership_country_id=self.usa.id,
+            person_id=self.bob.id,
+            group_id=self.cia.id,
+        )
+        Membership.objects.create(
+            membership_country_id=self.usa.id,
+            person_id=self.jim.id,
+            group_id=self.cia.id,
+        )
 
         # Creating an invalid membership
         Membership.objects.create(
-            membership_country_id=self.soviet_union.id, person_id=self.george.id,
-            group_id=self.cia.id)
+            membership_country_id=self.soviet_union.id,
+            person_id=self.george.id,
+            group_id=self.cia.id,
+        )
 
         self.assertQuerysetEqual(
-            Membership.objects.filter(person__in=[self.george, self.jim]), [
+            Membership.objects.filter(person__in=[self.george, self.jim]),
+            [
                 self.jim.id,
             ],
-            attrgetter('person_id')
+            attrgetter("person_id"),
         )
         self.assertQuerysetEqual(
-            Membership.objects.filter(person__in=Person.objects.filter(name='Jim')), [
+            Membership.objects.filter(person__in=Person.objects.filter(name="Jim")),
+            [
                 self.jim.id,
             ],
-            attrgetter('person_id')
+            attrgetter("person_id"),
         )
 
     def test_double_nested_query(self):
-        m1 = Membership.objects.create(membership_country_id=self.usa.id, person_id=self.bob.id,
-                                       group_id=self.cia.id)
-        m2 = Membership.objects.create(membership_country_id=self.usa.id, person_id=self.jim.id,
-                                       group_id=self.cia.id)
-        Friendship.objects.create(from_friend_country_id=self.usa.id, from_friend_id=self.bob.id,
-                                  to_friend_country_id=self.usa.id, to_friend_id=self.jim.id)
+        m1 = Membership.objects.create(
+            membership_country_id=self.usa.id,
+            person_id=self.bob.id,
+            group_id=self.cia.id,
+        )
+        m2 = Membership.objects.create(
+            membership_country_id=self.usa.id,
+            person_id=self.jim.id,
+            group_id=self.cia.id,
+        )
+        Friendship.objects.create(
+            from_friend_country_id=self.usa.id,
+            from_friend_id=self.bob.id,
+            to_friend_country_id=self.usa.id,
+            to_friend_id=self.jim.id,
+        )
         self.assertSequenceEqual(
             Membership.objects.filter(
                 person__in=Person.objects.filter(
-                    from_friend__in=Friendship.objects.filter(to_friend__in=Person.objects.all())
+                    from_friend__in=Friendship.objects.filter(
+                        to_friend__in=Person.objects.all()
+                    )
                 )
             ),
-            [m1]
+            [m1],
         )
         self.assertSequenceEqual(
             Membership.objects.exclude(
                 person__in=Person.objects.filter(
-                    from_friend__in=Friendship.objects.filter(to_friend__in=Person.objects.all())
+                    from_friend__in=Friendship.objects.filter(
+                        to_friend__in=Person.objects.all()
+                    )
                 )
             ),
-            [m2]
+            [m2],
         )
 
     def test_select_related_foreignkey_forward_works(self):
-        Membership.objects.create(membership_country=self.usa, person=self.bob, group=self.cia)
-        Membership.objects.create(membership_country=self.usa, person=self.jim, group=self.democrat)
+        Membership.objects.create(
+            membership_country=self.usa, person=self.bob, group=self.cia
+        )
+        Membership.objects.create(
+            membership_country=self.usa, person=self.jim, group=self.democrat
+        )
 
         with self.assertNumQueries(1):
-            people = [m.person for m in Membership.objects.select_related('person').order_by('pk')]
+            people = [
+                m.person
+                for m in Membership.objects.select_related("person").order_by("pk")
+            ]
 
-        normal_people = [m.person for m in Membership.objects.all().order_by('pk')]
+        normal_people = [m.person for m in Membership.objects.all().order_by("pk")]
         self.assertEqual(people, normal_people)
 
     def test_prefetch_foreignkey_forward_works(self):
-        Membership.objects.create(membership_country=self.usa, person=self.bob, group=self.cia)
-        Membership.objects.create(membership_country=self.usa, person=self.jim, group=self.democrat)
+        Membership.objects.create(
+            membership_country=self.usa, person=self.bob, group=self.cia
+        )
+        Membership.objects.create(
+            membership_country=self.usa, person=self.jim, group=self.democrat
+        )
 
         with self.assertNumQueries(2):
             people = [
-                m.person for m in Membership.objects.prefetch_related('person').order_by('pk')]
+                m.person
+                for m in Membership.objects.prefetch_related("person").order_by("pk")
+            ]
 
-        normal_people = [m.person for m in Membership.objects.order_by('pk')]
+        normal_people = [m.person for m in Membership.objects.order_by("pk")]
         self.assertEqual(people, normal_people)
 
     def test_prefetch_foreignkey_reverse_works(self):
-        Membership.objects.create(membership_country=self.usa, person=self.bob, group=self.cia)
-        Membership.objects.create(membership_country=self.usa, person=self.jim, group=self.democrat)
+        Membership.objects.create(
+            membership_country=self.usa, person=self.bob, group=self.cia
+        )
+        Membership.objects.create(
+            membership_country=self.usa, person=self.jim, group=self.democrat
+        )
         with self.assertNumQueries(2):
             membership_sets = [
                 list(p.membership_set.all())
-                for p in Person.objects.prefetch_related('membership_set').order_by('pk')]
+                for p in Person.objects.prefetch_related("membership_set").order_by(
+                    "pk"
+                )
+            ]
 
         with self.assertNumQueries(7):
             normal_membership_sets = [
-                list(p.membership_set.all())
-                for p in Person.objects.order_by('pk')
+                list(p.membership_set.all()) for p in Person.objects.order_by("pk")
             ]
         self.assertEqual(membership_sets, normal_membership_sets)
 
     def test_m2m_through_forward_returns_valid_members(self):
         # We start out by making sure that the Group 'CIA' has no members.
-        self.assertQuerysetEqual(
-            self.cia.members.all(),
-            []
-        )
+        self.assertQuerysetEqual(self.cia.members.all(), [])
 
-        Membership.objects.create(membership_country=self.usa, person=self.bob, group=self.cia)
-        Membership.objects.create(membership_country=self.usa, person=self.jim, group=self.cia)
+        Membership.objects.create(
+            membership_country=self.usa, person=self.bob, group=self.cia
+        )
+        Membership.objects.create(
+            membership_country=self.usa, person=self.jim, group=self.cia
+        )
 
         # Let's check to make sure that it worked.  Bob and Jim should be members of the CIA.
 
         self.assertQuerysetEqual(
-            self.cia.members.all(), [
-                'Bob',
-                'Jim'
-            ], attrgetter("name")
+            self.cia.members.all(), ["Bob", "Jim"], attrgetter("name")
         )
 
     def test_m2m_through_reverse_returns_valid_members(self):
         # We start out by making sure that Bob is in no groups.
-        self.assertQuerysetEqual(
-            self.bob.groups.all(),
-            []
-        )
+        self.assertQuerysetEqual(self.bob.groups.all(), [])
 
-        Membership.objects.create(membership_country=self.usa, person=self.bob, group=self.cia)
-        Membership.objects.create(membership_country=self.usa, person=self.bob,
-                                  group=self.republican)
+        Membership.objects.create(
+            membership_country=self.usa, person=self.bob, group=self.cia
+        )
+        Membership.objects.create(
+            membership_country=self.usa, person=self.bob, group=self.republican
+        )
 
         # Bob should be in the CIA and a Republican
         self.assertQuerysetEqual(
-            self.bob.groups.all(), [
-                'CIA',
-                'Republican'
-            ], attrgetter("name")
+            self.bob.groups.all(), ["CIA", "Republican"], attrgetter("name")
         )
 
     def test_m2m_through_forward_ignores_invalid_members(self):
         # We start out by making sure that the Group 'CIA' has no members.
-        self.assertQuerysetEqual(
-            self.cia.members.all(),
-            []
-        )
+        self.assertQuerysetEqual(self.cia.members.all(), [])
 
         # Something adds jane to group CIA but Jane is in Soviet Union which isn't CIA's country
-        Membership.objects.create(membership_country=self.usa, person=self.jane, group=self.cia)
+        Membership.objects.create(
+            membership_country=self.usa, person=self.jane, group=self.cia
+        )
 
         # There should still be no members in CIA
-        self.assertQuerysetEqual(
-            self.cia.members.all(),
-            []
-        )
+        self.assertQuerysetEqual(self.cia.members.all(), [])
 
     def test_m2m_through_reverse_ignores_invalid_members(self):
         # We start out by making sure that Jane has no groups.
-        self.assertQuerysetEqual(
-            self.jane.groups.all(),
-            []
-        )
+        self.assertQuerysetEqual(self.jane.groups.all(), [])
 
         # Something adds jane to group CIA but Jane is in Soviet Union which isn't CIA's country
-        Membership.objects.create(membership_country=self.usa, person=self.jane, group=self.cia)
+        Membership.objects.create(
+            membership_country=self.usa, person=self.jane, group=self.cia
+        )
 
         # Jane should still not be in any groups
-        self.assertQuerysetEqual(
-            self.jane.groups.all(),
-            []
-        )
+        self.assertQuerysetEqual(self.jane.groups.all(), [])
 
     def test_m2m_through_on_self_works(self):
-        self.assertQuerysetEqual(
-            self.jane.friends.all(),
-            []
-        )
+        self.assertQuerysetEqual(self.jane.friends.all(), [])
 
         Friendship.objects.create(
-            from_friend_country=self.jane.person_country, from_friend=self.jane,
-            to_friend_country=self.george.person_country, to_friend=self.george)
+            from_friend_country=self.jane.person_country,
+            from_friend=self.jane,
+            to_friend_country=self.george.person_country,
+            to_friend=self.george,
+        )
 
         self.assertQuerysetEqual(
-            self.jane.friends.all(),
-            ['George'], attrgetter("name")
+            self.jane.friends.all(), ["George"], attrgetter("name")
         )
 
     def test_m2m_through_on_self_ignores_mismatch_columns(self):
@@ -292,74 +355,102 @@ class MultiColumnFKTests(TestCase):
         # Note that we use ids instead of instances. This is because instances on ForeignObject
         # properties will set all related field off of the given instance
         Friendship.objects.create(
-            from_friend_id=self.jane.id, to_friend_id=self.george.id,
+            from_friend_id=self.jane.id,
+            to_friend_id=self.george.id,
             to_friend_country_id=self.jane.person_country_id,
-            from_friend_country_id=self.george.person_country_id)
+            from_friend_country_id=self.george.person_country_id,
+        )
 
         self.assertQuerysetEqual(self.jane.friends.all(), [])
 
     def test_prefetch_related_m2m_forward_works(self):
-        Membership.objects.create(membership_country=self.usa, person=self.bob, group=self.cia)
-        Membership.objects.create(membership_country=self.usa, person=self.jim, group=self.democrat)
+        Membership.objects.create(
+            membership_country=self.usa, person=self.bob, group=self.cia
+        )
+        Membership.objects.create(
+            membership_country=self.usa, person=self.jim, group=self.democrat
+        )
 
         with self.assertNumQueries(2):
-            members_lists = [list(g.members.all())
-                             for g in Group.objects.prefetch_related('members')]
+            members_lists = [
+                list(g.members.all()) for g in Group.objects.prefetch_related("members")
+            ]
 
         normal_members_lists = [list(g.members.all()) for g in Group.objects.all()]
         self.assertEqual(members_lists, normal_members_lists)
 
     def test_prefetch_related_m2m_reverse_works(self):
-        Membership.objects.create(membership_country=self.usa, person=self.bob, group=self.cia)
-        Membership.objects.create(membership_country=self.usa, person=self.jim, group=self.democrat)
+        Membership.objects.create(
+            membership_country=self.usa, person=self.bob, group=self.cia
+        )
+        Membership.objects.create(
+            membership_country=self.usa, person=self.jim, group=self.democrat
+        )
 
         with self.assertNumQueries(2):
-            groups_lists = [list(p.groups.all()) for p in Person.objects.prefetch_related('groups')]
+            groups_lists = [
+                list(p.groups.all()) for p in Person.objects.prefetch_related("groups")
+            ]
 
         normal_groups_lists = [list(p.groups.all()) for p in Person.objects.all()]
         self.assertEqual(groups_lists, normal_groups_lists)
 
-    @translation.override('fi')
+    @translation.override("fi")
     def test_translations(self):
         a1 = Article.objects.create(pub_date=datetime.date.today())
-        at1_fi = ArticleTranslation(article=a1, lang='fi', title='Otsikko', body='Diipadaapa')
+        at1_fi = ArticleTranslation(
+            article=a1, lang="fi", title="Otsikko", body="Diipadaapa"
+        )
         at1_fi.save()
-        at2_en = ArticleTranslation(article=a1, lang='en', title='Title', body='Lalalalala')
+        at2_en = ArticleTranslation(
+            article=a1, lang="en", title="Title", body="Lalalalala"
+        )
         at2_en.save()
 
         self.assertEqual(Article.objects.get(pk=a1.pk).active_translation, at1_fi)
 
         with self.assertNumQueries(1):
-            fetched = Article.objects.select_related('active_translation').get(
-                active_translation__title='Otsikko')
-            self.assertEqual(fetched.active_translation.title, 'Otsikko')
+            fetched = Article.objects.select_related("active_translation").get(
+                active_translation__title="Otsikko"
+            )
+            self.assertEqual(fetched.active_translation.title, "Otsikko")
         a2 = Article.objects.create(pub_date=datetime.date.today())
-        at2_fi = ArticleTranslation(article=a2, lang='fi', title='Atsikko', body='Diipadaapa',
-                                    abstract='dipad')
+        at2_fi = ArticleTranslation(
+            article=a2, lang="fi", title="Atsikko", body="Diipadaapa", abstract="dipad"
+        )
         at2_fi.save()
         a3 = Article.objects.create(pub_date=datetime.date.today())
-        at3_en = ArticleTranslation(article=a3, lang='en', title='A title', body='lalalalala',
-                                    abstract='lala')
+        at3_en = ArticleTranslation(
+            article=a3, lang="en", title="A title", body="lalalalala", abstract="lala"
+        )
         at3_en.save()
         # Test model initialization with active_translation field.
         a3 = Article(id=a3.id, pub_date=a3.pub_date, active_translation=at3_en)
         a3.save()
         self.assertEqual(
-            list(Article.objects.filter(active_translation__abstract=None)),
-            [a1, a3])
+            list(Article.objects.filter(active_translation__abstract=None)), [a1, a3]
+        )
         self.assertEqual(
-            list(Article.objects.filter(active_translation__abstract=None,
-                                        active_translation__pk__isnull=False)),
-            [a1])
+            list(
+                Article.objects.filter(
+                    active_translation__abstract=None,
+                    active_translation__pk__isnull=False,
+                )
+            ),
+            [a1],
+        )
 
-        with translation.override('en'):
+        with translation.override("en"):
             self.assertEqual(
                 list(Article.objects.filter(active_translation__abstract=None)),
-                [a1, a2])
+                [a1, a2],
+            )
 
     def test_foreign_key_raises_informative_does_not_exist(self):
         referrer = ArticleTranslation()
-        with self.assertRaisesMessage(Article.DoesNotExist, 'ArticleTranslation has no article'):
+        with self.assertRaisesMessage(
+            Article.DoesNotExist, "ArticleTranslation has no article"
+        ):
             referrer.article
 
     def test_foreign_key_related_query_name(self):
@@ -389,29 +480,37 @@ class MultiColumnFKTests(TestCase):
         with self.assertRaisesMessage(FieldError, msg):
             Article.objects.filter(ideas__name="idea1")
 
-    @translation.override('fi')
+    @translation.override("fi")
     def test_inheritance(self):
         na = NewsArticle.objects.create(pub_date=datetime.date.today())
         ArticleTranslation.objects.create(
-            article=na, lang="fi", title="foo", body="bar")
+            article=na, lang="fi", title="foo", body="bar"
+        )
         self.assertSequenceEqual(
-            NewsArticle.objects.select_related('active_translation'),
-            [na]
+            NewsArticle.objects.select_related("active_translation"), [na]
         )
         with self.assertNumQueries(1):
             self.assertEqual(
-                NewsArticle.objects.select_related(
-                    'active_translation')[0].active_translation.title,
-                "foo")
+                NewsArticle.objects.select_related("active_translation")[
+                    0
+                ].active_translation.title,
+                "foo",
+            )
 
-    @skipUnlessDBFeature('has_bulk_insert')
+    @skipUnlessDBFeature("has_bulk_insert")
     def test_batch_create_foreign_object(self):
-        objs = [Person(name="abcd_%s" % i, person_country=self.usa) for i in range(0, 5)]
+        objs = [
+            Person(name="abcd_%s" % i, person_country=self.usa) for i in range(0, 5)
+        ]
         Person.objects.bulk_create(objs, 10)
 
     def test_isnull_lookup(self):
-        m1 = Membership.objects.create(membership_country=self.usa, person=self.bob, group_id=None)
-        m2 = Membership.objects.create(membership_country=self.usa, person=self.bob, group=self.cia)
+        m1 = Membership.objects.create(
+            membership_country=self.usa, person=self.bob, group_id=None
+        )
+        m2 = Membership.objects.create(
+            membership_country=self.usa, person=self.bob, group=self.cia
+        )
         self.assertSequenceEqual(
             Membership.objects.filter(group__isnull=True),
             [m1],
@@ -423,15 +522,14 @@ class MultiColumnFKTests(TestCase):
 
 
 class TestModelCheckTests(SimpleTestCase):
-
-    @isolate_apps('foreign_object')
+    @isolate_apps("foreign_object")
     def test_check_composite_foreign_object(self):
         class Parent(models.Model):
             a = models.PositiveIntegerField()
             b = models.PositiveIntegerField()
 
             class Meta:
-                unique_together = (('a', 'b'),)
+                unique_together = (("a", "b"),)
 
         class Child(models.Model):
             a = models.PositiveIntegerField()
@@ -440,14 +538,14 @@ class TestModelCheckTests(SimpleTestCase):
             parent = models.ForeignObject(
                 Parent,
                 on_delete=models.SET_NULL,
-                from_fields=('a', 'b'),
-                to_fields=('a', 'b'),
-                related_name='children',
+                from_fields=("a", "b"),
+                to_fields=("a", "b"),
+                related_name="children",
             )
 
-        self.assertEqual(Child._meta.get_field('parent').check(from_model=Child), [])
+        self.assertEqual(Child._meta.get_field("parent").check(from_model=Child), [])
 
-    @isolate_apps('foreign_object')
+    @isolate_apps("foreign_object")
     def test_check_subset_composite_foreign_object(self):
         class Parent(models.Model):
             a = models.PositiveIntegerField()
@@ -455,7 +553,7 @@ class TestModelCheckTests(SimpleTestCase):
             c = models.PositiveIntegerField()
 
             class Meta:
-                unique_together = (('a', 'b'),)
+                unique_together = (("a", "b"),)
 
         class Child(models.Model):
             a = models.PositiveIntegerField()
@@ -465,25 +563,27 @@ class TestModelCheckTests(SimpleTestCase):
             parent = models.ForeignObject(
                 Parent,
                 on_delete=models.SET_NULL,
-                from_fields=('a', 'b', 'c'),
-                to_fields=('a', 'b', 'c'),
-                related_name='children',
+                from_fields=("a", "b", "c"),
+                to_fields=("a", "b", "c"),
+                related_name="children",
             )
 
-        self.assertEqual(Child._meta.get_field('parent').check(from_model=Child), [])
+        self.assertEqual(Child._meta.get_field("parent").check(from_model=Child), [])
 
 
 class TestExtraJoinFilterQ(TestCase):
-    @translation.override('fi')
+    @translation.override("fi")
     def test_extra_join_filter_q(self):
         a = Article.objects.create(pub_date=datetime.datetime.today())
-        ArticleTranslation.objects.create(article=a, lang='fi', title='title', body='body')
+        ArticleTranslation.objects.create(
+            article=a, lang="fi", title="title", body="body"
+        )
         qs = Article.objects.all()
         with self.assertNumQueries(2):
-            self.assertEqual(qs[0].active_translation_q.title, 'title')
-        qs = qs.select_related('active_translation_q')
+            self.assertEqual(qs[0].active_translation_q.title, "title")
+        qs = qs.select_related("active_translation_q")
         with self.assertNumQueries(1):
-            self.assertEqual(qs[0].active_translation_q.title, 'title')
+            self.assertEqual(qs[0].active_translation_q.title, "title")
 
 
 class TestCachedPathInfo(TestCase):
@@ -492,7 +592,7 @@ class TestCachedPathInfo(TestCase):
         The path_infos and reverse_path_infos attributes are equivalent to
         calling the get_<method>() with no arguments.
         """
-        foreign_object = Membership._meta.get_field('person')
+        foreign_object = Membership._meta.get_field("person")
         self.assertEqual(
             foreign_object.path_infos,
             foreign_object.get_path_info(),
@@ -507,51 +607,51 @@ class TestCachedPathInfo(TestCase):
         Shallow copying a ForeignObject (or a ForeignObjectRel) removes the
         object's direct cached PathInfo values.
         """
-        foreign_object = Membership._meta.get_field('person')
+        foreign_object = Membership._meta.get_field("person")
         # Trigger storage of cached_property into ForeignObject's __dict__.
         foreign_object.path_infos
         foreign_object.reverse_path_infos
         # The ForeignObjectRel doesn't have reverse_path_infos.
         foreign_object.remote_field.path_infos
-        self.assertIn('path_infos', foreign_object.__dict__)
-        self.assertIn('reverse_path_infos', foreign_object.__dict__)
-        self.assertIn('path_infos', foreign_object.remote_field.__dict__)
+        self.assertIn("path_infos", foreign_object.__dict__)
+        self.assertIn("reverse_path_infos", foreign_object.__dict__)
+        self.assertIn("path_infos", foreign_object.remote_field.__dict__)
         # Cached value is removed via __getstate__() on ForeignObjectRel
         # because no __copy__() method exists, so __reduce_ex__() is used.
         remote_field_copy = copy.copy(foreign_object.remote_field)
-        self.assertNotIn('path_infos', remote_field_copy.__dict__)
+        self.assertNotIn("path_infos", remote_field_copy.__dict__)
         # Cached values are removed via __copy__() on ForeignObject for
         # consistency of behavior.
         foreign_object_copy = copy.copy(foreign_object)
-        self.assertNotIn('path_infos', foreign_object_copy.__dict__)
-        self.assertNotIn('reverse_path_infos', foreign_object_copy.__dict__)
+        self.assertNotIn("path_infos", foreign_object_copy.__dict__)
+        self.assertNotIn("reverse_path_infos", foreign_object_copy.__dict__)
         # ForeignObjectRel's remains because it's part of a shallow copy.
-        self.assertIn('path_infos', foreign_object_copy.remote_field.__dict__)
+        self.assertIn("path_infos", foreign_object_copy.remote_field.__dict__)
 
     def test_deepcopy_removes_cached_values(self):
         """
         Deep copying a ForeignObject removes the object's cached PathInfo
         values, including those of the related ForeignObjectRel.
         """
-        foreign_object = Membership._meta.get_field('person')
+        foreign_object = Membership._meta.get_field("person")
         # Trigger storage of cached_property into ForeignObject's __dict__.
         foreign_object.path_infos
         foreign_object.reverse_path_infos
         # The ForeignObjectRel doesn't have reverse_path_infos.
         foreign_object.remote_field.path_infos
-        self.assertIn('path_infos', foreign_object.__dict__)
-        self.assertIn('reverse_path_infos', foreign_object.__dict__)
-        self.assertIn('path_infos', foreign_object.remote_field.__dict__)
+        self.assertIn("path_infos", foreign_object.__dict__)
+        self.assertIn("reverse_path_infos", foreign_object.__dict__)
+        self.assertIn("path_infos", foreign_object.remote_field.__dict__)
         # Cached value is removed via __getstate__() on ForeignObjectRel
         # because no __deepcopy__() method exists, so __reduce_ex__() is used.
         remote_field_copy = copy.deepcopy(foreign_object.remote_field)
-        self.assertNotIn('path_infos', remote_field_copy.__dict__)
+        self.assertNotIn("path_infos", remote_field_copy.__dict__)
         # Field.__deepcopy__() internally uses __copy__() on both the
         # ForeignObject and ForeignObjectRel, so all cached values are removed.
         foreign_object_copy = copy.deepcopy(foreign_object)
-        self.assertNotIn('path_infos', foreign_object_copy.__dict__)
-        self.assertNotIn('reverse_path_infos', foreign_object_copy.__dict__)
-        self.assertNotIn('path_infos', foreign_object_copy.remote_field.__dict__)
+        self.assertNotIn("path_infos", foreign_object_copy.__dict__)
+        self.assertNotIn("reverse_path_infos", foreign_object_copy.__dict__)
+        self.assertNotIn("path_infos", foreign_object_copy.remote_field.__dict__)
 
     def test_pickling_foreignobjectrel(self):
         """
@@ -561,12 +661,12 @@ class TestCachedPathInfo(TestCase):
         both use that, but ForeignObject implements __reduce__() and __copy__()
         separately, so doesn't share the same behaviour.
         """
-        foreign_object_rel = Membership._meta.get_field('person').remote_field
+        foreign_object_rel = Membership._meta.get_field("person").remote_field
         # Trigger storage of cached_property into ForeignObjectRel's __dict__.
         foreign_object_rel.path_infos
-        self.assertIn('path_infos', foreign_object_rel.__dict__)
+        self.assertIn("path_infos", foreign_object_rel.__dict__)
         foreign_object_rel_restored = pickle.loads(pickle.dumps(foreign_object_rel))
-        self.assertNotIn('path_infos', foreign_object_rel_restored.__dict__)
+        self.assertNotIn("path_infos", foreign_object_rel_restored.__dict__)
 
     def test_pickling_foreignobject(self):
         """
@@ -576,12 +676,12 @@ class TestCachedPathInfo(TestCase):
         attributes within the same process, because of the way
         Field.__reduce__() is used for restoring values.
         """
-        foreign_object = Membership._meta.get_field('person')
+        foreign_object = Membership._meta.get_field("person")
         # Trigger storage of cached_property into ForeignObjectRel's __dict__
         foreign_object.path_infos
         foreign_object.reverse_path_infos
-        self.assertIn('path_infos', foreign_object.__dict__)
-        self.assertIn('reverse_path_infos', foreign_object.__dict__)
+        self.assertIn("path_infos", foreign_object.__dict__)
+        self.assertIn("reverse_path_infos", foreign_object.__dict__)
         foreign_object_restored = pickle.loads(pickle.dumps(foreign_object))
-        self.assertIn('path_infos', foreign_object_restored.__dict__)
-        self.assertIn('reverse_path_infos', foreign_object_restored.__dict__)
+        self.assertIn("path_infos", foreign_object_restored.__dict__)
+        self.assertIn("reverse_path_infos", foreign_object_restored.__dict__)