Refs #33476 -- Reformatted code with Black.

3 files changed, 71 insertions, 47 deletions

diff --git a/tests/m2m_through_regress/models.py b/tests/m2m_through_regress/models.py
index 7042e31d0f..db724e43d2 100644
--- a/tests/m2m_through_regress/models.py
+++ b/tests/m2m_through_regress/models.py
@@ -4,16 +4,16 @@ from django.db import models
 
 # Forward declared intermediate model
 class Membership(models.Model):
-    person = models.ForeignKey('Person', models.CASCADE)
-    group = models.ForeignKey('Group', models.CASCADE)
+    person = models.ForeignKey("Person", models.CASCADE)
+    group = models.ForeignKey("Group", models.CASCADE)
     price = models.IntegerField(default=100)
 
 
 # using custom id column to test ticket #11107
 class UserMembership(models.Model):
-    id = models.AutoField(db_column='usermembership_id', primary_key=True)
+    id = models.AutoField(db_column="usermembership_id", primary_key=True)
     user = models.ForeignKey(User, models.CASCADE)
-    group = models.ForeignKey('Group', models.CASCADE)
+    group = models.ForeignKey("Group", models.CASCADE)
     price = models.IntegerField(default=100)
 
 
@@ -28,7 +28,7 @@ class Group(models.Model):
     name = models.CharField(max_length=128)
     # Membership object defined as a class
     members = models.ManyToManyField(Person, through=Membership)
-    user_members = models.ManyToManyField(User, through='UserMembership')
+    user_members = models.ManyToManyField(User, through="UserMembership")
 
     def __str__(self):
         return self.name
@@ -37,7 +37,7 @@ class Group(models.Model):
 # Using to_field on the through model
 class Car(models.Model):
     make = models.CharField(max_length=20, unique=True, null=True)
-    drivers = models.ManyToManyField('Driver', through='CarDriver')
+    drivers = models.ManyToManyField("Driver", through="CarDriver")
 
     def __str__(self):
         return str(self.make)
@@ -47,15 +47,15 @@ class Driver(models.Model):
     name = models.CharField(max_length=20, unique=True, null=True)
 
     class Meta:
-        ordering = ('name',)
+        ordering = ("name",)
 
     def __str__(self):
         return str(self.name)
 
 
 class CarDriver(models.Model):
-    car = models.ForeignKey('Car', models.CASCADE, to_field='make')
-    driver = models.ForeignKey('Driver', models.CASCADE, to_field='name')
+    car = models.ForeignKey("Car", models.CASCADE, to_field="make")
+    driver = models.ForeignKey("Driver", models.CASCADE, to_field="name")
 
     def __str__(self):
         return "pk=%s car=%s driver=%s" % (str(self.pk), self.car, self.driver)
@@ -64,13 +64,13 @@ class CarDriver(models.Model):
 # Through models using multi-table inheritance
 class Event(models.Model):
     name = models.CharField(max_length=50, unique=True)
-    people = models.ManyToManyField('Person', through='IndividualCompetitor')
+    people = models.ManyToManyField("Person", through="IndividualCompetitor")
     special_people = models.ManyToManyField(
-        'Person',
-        through='ProxiedIndividualCompetitor',
-        related_name='special_event_set',
+        "Person",
+        through="ProxiedIndividualCompetitor",
+        related_name="special_event_set",
     )
-    teams = models.ManyToManyField('Group', through='CompetingTeam')
+    teams = models.ManyToManyField("Group", through="CompetingTeam")
 
 
 class Competitor(models.Model):
diff --git a/tests/m2m_through_regress/test_multitable.py b/tests/m2m_through_regress/test_multitable.py
index b354be979e..ae3a4060e6 100644
--- a/tests/m2m_through_regress/test_multitable.py
+++ b/tests/m2m_through_regress/test_multitable.py
@@ -1,21 +1,26 @@
 from django.test import TestCase
 
 from .models import (
-    CompetingTeam, Event, Group, IndividualCompetitor, Membership, Person,
+    CompetingTeam,
+    Event,
+    Group,
+    IndividualCompetitor,
+    Membership,
+    Person,
 )
 
 
 class MultiTableTests(TestCase):
     @classmethod
     def setUpTestData(cls):
-        cls.alice = Person.objects.create(name='Alice')
-        cls.bob = Person.objects.create(name='Bob')
-        cls.chris = Person.objects.create(name='Chris')
-        cls.dan = Person.objects.create(name='Dan')
-        cls.team_alpha = Group.objects.create(name='Alpha')
+        cls.alice = Person.objects.create(name="Alice")
+        cls.bob = Person.objects.create(name="Bob")
+        cls.chris = Person.objects.create(name="Chris")
+        cls.dan = Person.objects.create(name="Dan")
+        cls.team_alpha = Group.objects.create(name="Alpha")
         Membership.objects.create(person=cls.alice, group=cls.team_alpha)
         Membership.objects.create(person=cls.bob, group=cls.team_alpha)
-        cls.event = Event.objects.create(name='Exposition Match')
+        cls.event = Event.objects.create(name="Exposition Match")
         IndividualCompetitor.objects.create(event=cls.event, person=cls.chris)
         IndividualCompetitor.objects.create(event=cls.event, person=cls.dan)
         CompetingTeam.objects.create(event=cls.event, team=cls.team_alpha)
@@ -37,13 +42,20 @@ class MultiTableTests(TestCase):
         self.assertCountEqual(result, [self.event])
 
     def test_m2m_prefetch_proxied(self):
-        result = Event.objects.filter(name='Exposition Match').prefetch_related('special_people')
+        result = Event.objects.filter(name="Exposition Match").prefetch_related(
+            "special_people"
+        )
         with self.assertNumQueries(2):
             self.assertCountEqual(result, [self.event])
-            self.assertEqual(sorted(p.name for p in result[0].special_people.all()), ['Chris', 'Dan'])
+            self.assertEqual(
+                sorted(p.name for p in result[0].special_people.all()), ["Chris", "Dan"]
+            )
 
     def test_m2m_prefetch_reverse_proxied(self):
-        result = Person.objects.filter(name='Dan').prefetch_related('special_event_set')
+        result = Person.objects.filter(name="Dan").prefetch_related("special_event_set")
         with self.assertNumQueries(2):
             self.assertCountEqual(result, [self.dan])
-            self.assertEqual([event.name for event in result[0].special_event_set.all()], ['Exposition Match'])
+            self.assertEqual(
+                [event.name for event in result[0].special_event_set.all()],
+                ["Exposition Match"],
+            )
diff --git a/tests/m2m_through_regress/tests.py b/tests/m2m_through_regress/tests.py
index 93d2260054..1c362657db 100644
--- a/tests/m2m_through_regress/tests.py
+++ b/tests/m2m_through_regress/tests.py
@@ -4,9 +4,7 @@ from django.contrib.auth.models import User
 from django.core import management
 from django.test import TestCase
 
-from .models import (
-    Car, CarDriver, Driver, Group, Membership, Person, UserMembership,
-)
+from .models import Car, CarDriver, Driver, Group, Membership, Person, UserMembership
 
 
 class M2MThroughTestCase(TestCase):
@@ -23,8 +21,12 @@ class M2MThroughTestCase(TestCase):
 
         # normal intermediate model
         cls.bob_rock = Membership.objects.create(person=cls.bob, group=cls.rock)
-        cls.bob_roll = Membership.objects.create(person=cls.bob, group=cls.roll, price=50)
-        cls.jim_rock = Membership.objects.create(person=cls.jim, group=cls.rock, price=50)
+        cls.bob_roll = Membership.objects.create(
+            person=cls.bob, group=cls.roll, price=50
+        )
+        cls.jim_rock = Membership.objects.create(
+            person=cls.jim, group=cls.rock, price=50
+        )
 
         # intermediate model with custom id column
         cls.frank_rock = UserMembership.objects.create(user=cls.frank, group=cls.rock)
@@ -72,18 +74,24 @@ class M2MThroughSerializationTestCase(TestCase):
         pks = {"p_pk": self.bob.pk, "g_pk": self.roll.pk, "m_pk": self.bob_roll.pk}
 
         out = StringIO()
-        management.call_command("dumpdata", "m2m_through_regress", format="json", stdout=out)
+        management.call_command(
+            "dumpdata", "m2m_through_regress", format="json", stdout=out
+        )
         self.assertJSONEqual(
             out.getvalue().strip(),
             '[{"pk": %(m_pk)s, "model": "m2m_through_regress.membership", "fields": {"person": %(p_pk)s, "price": '
             '100, "group": %(g_pk)s}}, {"pk": %(p_pk)s, "model": "m2m_through_regress.person", "fields": {"name": '
             '"Bob"}}, {"pk": %(g_pk)s, "model": "m2m_through_regress.group", "fields": {"name": "Roll"}}]'
-            % pks
+            % pks,
         )
 
         out = StringIO()
-        management.call_command("dumpdata", "m2m_through_regress", format="xml", indent=2, stdout=out)
-        self.assertXMLEqual(out.getvalue().strip(), """
+        management.call_command(
+            "dumpdata", "m2m_through_regress", format="xml", indent=2, stdout=out
+        )
+        self.assertXMLEqual(
+            out.getvalue().strip(),
+            """
 <?xml version="1.0" encoding="utf-8"?>
 <django-objects version="1.0">
   <object pk="%(m_pk)s" model="m2m_through_regress.membership">
@@ -98,7 +106,9 @@ class M2MThroughSerializationTestCase(TestCase):
     <field type="CharField" name="name">Roll</field>
   </object>
 </django-objects>
-        """.strip() % pks)
+        """.strip()
+            % pks,
+        )
 
 
 class ToFieldThroughTests(TestCase):
@@ -138,7 +148,7 @@ class ToFieldThroughTests(TestCase):
     def test_add(self):
         self.assertSequenceEqual(self.car.drivers.all(), [self.driver])
         # Yikes - barney is going to drive...
-        self.car.drivers._add_items('car', 'driver', self.unused_driver)
+        self.car.drivers._add_items("car", "driver", self.unused_driver)
         self.assertSequenceEqual(
             self.car.drivers.all(),
             [self.unused_driver, self.driver],
@@ -148,7 +158,7 @@ class ToFieldThroughTests(TestCase):
         nullcar = Car(make=None)
         msg = (
             '"<Car: None>" needs to have a value for field "make" before this '
-            'many-to-many relationship can be used.'
+            "many-to-many relationship can be used."
         )
         with self.assertRaisesMessage(ValueError, msg):
             nullcar.drivers.all()
@@ -159,43 +169,43 @@ class ToFieldThroughTests(TestCase):
             "many-to-many relationship can be used."
         )
         with self.assertRaisesMessage(ValueError, msg):
-            Car(make='Ford').drivers.all()
+            Car(make="Ford").drivers.all()
 
     def test_add_related_null(self):
         nulldriver = Driver.objects.create(name=None)
         msg = 'Cannot add "<Driver: None>": the value for field "driver" is None'
         with self.assertRaisesMessage(ValueError, msg):
-            self.car.drivers._add_items('car', 'driver', nulldriver)
+            self.car.drivers._add_items("car", "driver", nulldriver)
 
     def test_add_reverse(self):
         car2 = Car.objects.create(make="Honda")
         self.assertCountEqual(self.driver.car_set.all(), [self.car])
-        self.driver.car_set._add_items('driver', 'car', car2)
+        self.driver.car_set._add_items("driver", "car", car2)
         self.assertCountEqual(self.driver.car_set.all(), [self.car, car2])
 
     def test_add_null_reverse(self):
         nullcar = Car.objects.create(make=None)
         msg = 'Cannot add "<Car: None>": the value for field "car" is None'
         with self.assertRaisesMessage(ValueError, msg):
-            self.driver.car_set._add_items('driver', 'car', nullcar)
+            self.driver.car_set._add_items("driver", "car", nullcar)
 
     def test_add_null_reverse_related(self):
         nulldriver = Driver.objects.create(name=None)
         msg = (
             '"<Driver: None>" needs to have a value for field "name" before '
-            'this many-to-many relationship can be used.'
+            "this many-to-many relationship can be used."
         )
         with self.assertRaisesMessage(ValueError, msg):
-            nulldriver.car_set._add_items('driver', 'car', self.car)
+            nulldriver.car_set._add_items("driver", "car", self.car)
 
     def test_remove(self):
         self.assertSequenceEqual(self.car.drivers.all(), [self.driver])
-        self.car.drivers._remove_items('car', 'driver', self.driver)
+        self.car.drivers._remove_items("car", "driver", self.driver)
         self.assertSequenceEqual(self.car.drivers.all(), [])
 
     def test_remove_reverse(self):
         self.assertSequenceEqual(self.driver.car_set.all(), [self.car])
-        self.driver.car_set._remove_items('driver', 'car', self.car)
+        self.driver.car_set._remove_items("driver", "car", self.car)
         self.assertSequenceEqual(self.driver.car_set.all(), [])
 
 
@@ -208,10 +218,12 @@ class ThroughLoadDataTestCase(TestCase):
         phantom auto-generated m2m table (#11107).
         """
         out = StringIO()
-        management.call_command("dumpdata", "m2m_through_regress", format="json", stdout=out)
+        management.call_command(
+            "dumpdata", "m2m_through_regress", format="json", stdout=out
+        )
         self.assertJSONEqual(
             out.getvalue().strip(),
             '[{"pk": 1, "model": "m2m_through_regress.usermembership", "fields": {"price": 100, "group": 1, "user"'
             ': 1}}, {"pk": 1, "model": "m2m_through_regress.person", "fields": {"name": "Guido"}}, {"pk": 1, '
-            '"model": "m2m_through_regress.group", "fields": {"name": "Python Core Group"}}]'
+            '"model": "m2m_through_regress.group", "fields": {"name": "Python Core Group"}}]',
         )