Refs #33476 -- Reformatted code with Black.

12 files changed, 484 insertions, 290 deletions

diff --git a/tests/serializers/models/base.py b/tests/serializers/models/base.py
index 0004099f19..af9ca2b20a 100644
--- a/tests/serializers/models/base.py
+++ b/tests/serializers/models/base.py
@@ -10,7 +10,6 @@ from django.db import models
 
 
 class CategoryMetaDataManager(models.Manager):
-
     def get_by_natural_key(self, kind, name):
         return self.get(kind=kind, name=name)
 
@@ -22,10 +21,10 @@ class CategoryMetaData(models.Model):
     objects = CategoryMetaDataManager()
 
     class Meta:
-        unique_together = (('kind', 'name'),)
+        unique_together = (("kind", "name"),)
 
     def __str__(self):
-        return '[%s:%s]=%s' % (self.kind, self.name, self.value)
+        return "[%s:%s]=%s" % (self.kind, self.name, self.value)
 
     def natural_key(self):
         return (self.kind, self.name)
@@ -33,10 +32,12 @@ class CategoryMetaData(models.Model):
 
 class Category(models.Model):
     name = models.CharField(max_length=20)
-    meta_data = models.ForeignKey(CategoryMetaData, models.SET_NULL, null=True, default=None)
+    meta_data = models.ForeignKey(
+        CategoryMetaData, models.SET_NULL, null=True, default=None
+    )
 
     class Meta:
-        ordering = ('name',)
+        ordering = ("name",)
 
     def __str__(self):
         return self.name
@@ -46,7 +47,7 @@ class Author(models.Model):
     name = models.CharField(max_length=20)
 
     class Meta:
-        ordering = ('name',)
+        ordering = ("name",)
 
     def __str__(self):
         return self.name
@@ -60,7 +61,7 @@ class Article(models.Model):
     meta_data = models.ManyToManyField(CategoryMetaData)
 
     class Meta:
-        ordering = ('pub_date',)
+        ordering = ("pub_date",)
 
     def __str__(self):
         return self.headline
@@ -78,7 +79,7 @@ class Actor(models.Model):
     name = models.CharField(max_length=20, primary_key=True)
 
     class Meta:
-        ordering = ('name',)
+        ordering = ("name",)
 
     def __str__(self):
         return self.name
@@ -87,10 +88,10 @@ class Actor(models.Model):
 class Movie(models.Model):
     actor = models.ForeignKey(Actor, models.CASCADE)
     title = models.CharField(max_length=50)
-    price = models.DecimalField(max_digits=6, decimal_places=2, default=Decimal('0.00'))
+    price = models.DecimalField(max_digits=6, decimal_places=2, default=Decimal("0.00"))
 
     class Meta:
-        ordering = ('title',)
+        ordering = ("title",)
 
     def __str__(self):
         return self.title
@@ -112,7 +113,6 @@ class Team:
 
 
 class TeamField(models.CharField):
-
     def __init__(self):
         super().__init__(max_length=100)
 
@@ -132,7 +132,7 @@ class TeamField(models.CharField):
 
     def deconstruct(self):
         name, path, args, kwargs = super().deconstruct()
-        del kwargs['max_length']
+        del kwargs["max_length"]
         return name, path, args, kwargs
 
 
@@ -142,7 +142,7 @@ class Player(models.Model):
     team = TeamField()
 
     def __str__(self):
-        return '%s (%d) playing for %s' % (self.name, self.rank, self.team.to_string())
+        return "%s (%d) playing for %s" % (self.name, self.rank, self.team.to_string())
 
 
 class BaseModel(models.Model):
diff --git a/tests/serializers/models/data.py b/tests/serializers/models/data.py
index 94c4a215fc..3d863a3fb2 100644
--- a/tests/serializers/models/data.py
+++ b/tests/serializers/models/data.py
@@ -6,9 +6,7 @@ The basic idea is to have a model for each Django data type.
 """
 import uuid
 
-from django.contrib.contenttypes.fields import (
-    GenericForeignKey, GenericRelation,
-)
+from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
 from django.contrib.contenttypes.models import ContentType
 from django.db import models
 
@@ -62,6 +60,7 @@ class IntegerData(models.Model):
 class BigIntegerData(models.Model):
     data = models.BigIntegerField(null=True)
 
+
 # class ImageData(models.Model):
 #    data = models.ImageField(null=True)
 
@@ -100,6 +99,7 @@ class TimeData(models.Model):
 
 class Tag(models.Model):
     """A tag on an item."""
+
     data = models.SlugField()
     content_type = models.ForeignKey(ContentType, models.CASCADE)
     object_id = models.PositiveIntegerField()
@@ -115,6 +115,7 @@ class GenericData(models.Model):
 
     tags = GenericRelation(Tag)
 
+
 # The following test classes are all for validation
 # of related objects; in particular, forward, backward,
 # and self references.
@@ -127,7 +128,7 @@ class Anchor(models.Model):
     data = models.CharField(max_length=30)
 
     class Meta:
-        ordering = ('id',)
+        ordering = ("id",)
 
 
 class UniqueAnchor(models.Model):
@@ -151,15 +152,15 @@ class O2OData(models.Model):
 
 
 class FKSelfData(models.Model):
-    data = models.ForeignKey('self', models.CASCADE, null=True)
+    data = models.ForeignKey("self", models.CASCADE, null=True)
 
 
 class M2MSelfData(models.Model):
-    data = models.ManyToManyField('self', symmetrical=False)
+    data = models.ManyToManyField("self", symmetrical=False)
 
 
 class FKDataToField(models.Model):
-    data = models.ForeignKey(UniqueAnchor, models.SET_NULL, null=True, to_field='data')
+    data = models.ForeignKey(UniqueAnchor, models.SET_NULL, null=True, to_field="data")
 
 
 class FKDataToO2O(models.Model):
@@ -167,7 +168,7 @@ class FKDataToO2O(models.Model):
 
 
 class M2MIntermediateData(models.Model):
-    data = models.ManyToManyField(Anchor, through='Intermediate')
+    data = models.ManyToManyField(Anchor, through="Intermediate")
 
 
 class Intermediate(models.Model):
@@ -175,6 +176,7 @@ class Intermediate(models.Model):
     right = models.ForeignKey(Anchor, models.CASCADE)
     extra = models.CharField(max_length=30, blank=True, default="doesn't matter")
 
+
 # The following test classes are for validating the
 # deserialization of objects that use a user-defined
 # field as the primary key.
@@ -206,6 +208,7 @@ class DecimalPKData(models.Model):
 class EmailPKData(models.Model):
     data = models.EmailField(primary_key=True)
 
+
 # class FilePKData(models.Model):
 #    data = models.FileField(primary_key=True)
 
@@ -221,6 +224,7 @@ class FloatPKData(models.Model):
 class IntegerPKData(models.Model):
     data = models.IntegerField(primary_key=True)
 
+
 # class ImagePKData(models.Model):
 #    data = models.ImageField(primary_key=True)
 
@@ -244,6 +248,7 @@ class SlugPKData(models.Model):
 class SmallPKData(models.Model):
     data = models.SmallIntegerField(primary_key=True)
 
+
 # class TextPKData(models.Model):
 #     data = models.TextField(primary_key=True)
 
@@ -283,6 +288,7 @@ class ModifyingSaveData(models.Model):
         self.data = 666
         super().save(*args, **kwargs)
 
+
 # Tests for serialization of models using inheritance.
 # Regression for #7202, #7350
 
diff --git a/tests/serializers/models/multi_table.py b/tests/serializers/models/multi_table.py
index 4b07880925..2f42b57137 100644
--- a/tests/serializers/models/multi_table.py
+++ b/tests/serializers/models/multi_table.py
@@ -8,7 +8,7 @@ class ParentManager(models.Manager):
 
 class Parent(models.Model):
     parent_data = models.CharField(max_length=30, unique=True)
-    parent_m2m = models.ManyToManyField('self')
+    parent_m2m = models.ManyToManyField("self")
 
     objects = ParentManager()
 
diff --git a/tests/serializers/models/natural.py b/tests/serializers/models/natural.py
index d062d7a45b..1e439b34eb 100644
--- a/tests/serializers/models/natural.py
+++ b/tests/serializers/models/natural.py
@@ -25,8 +25,12 @@ class FKDataNaturalKey(models.Model):
 
 class NaturalKeyThing(models.Model):
     key = models.CharField(max_length=100, unique=True)
-    other_thing = models.ForeignKey('NaturalKeyThing', on_delete=models.CASCADE, null=True)
-    other_things = models.ManyToManyField('NaturalKeyThing', related_name='thing_m2m_set')
+    other_thing = models.ForeignKey(
+        "NaturalKeyThing", on_delete=models.CASCADE, null=True
+    )
+    other_things = models.ManyToManyField(
+        "NaturalKeyThing", related_name="thing_m2m_set"
+    )
 
     class Manager(models.Manager):
         def get_by_natural_key(self, key):
@@ -61,9 +65,11 @@ class FKAsPKNoNaturalKeyManager(models.Manager):
 
 
 class FKAsPKNoNaturalKey(models.Model):
-    pk_fk = models.ForeignKey(NaturalKeyAnchor, on_delete=models.CASCADE, primary_key=True)
+    pk_fk = models.ForeignKey(
+        NaturalKeyAnchor, on_delete=models.CASCADE, primary_key=True
+    )
 
     objects = FKAsPKNoNaturalKeyManager()
 
     def natural_key(self):
-        raise NotImplementedError('This method was not expected to be called.')
+        raise NotImplementedError("This method was not expected to be called.")
diff --git a/tests/serializers/test_data.py b/tests/serializers/test_data.py
index 91cad48e0f..330e5016e4 100644
--- a/tests/serializers/test_data.py
+++ b/tests/serializers/test_data.py
@@ -15,18 +15,62 @@ from django.db import connection, models
 from django.test import TestCase
 
 from .models import (
-    Anchor, AutoNowDateTimeData, BigIntegerData, BinaryData, BooleanData,
-    BooleanPKData, CharData, CharPKData, DateData, DatePKData, DateTimeData,
-    DateTimePKData, DecimalData, DecimalPKData, EmailData, EmailPKData,
-    ExplicitInheritBaseModel, FileData, FilePathData, FilePathPKData, FKData,
-    FKDataToField, FKDataToO2O, FKSelfData, FKToUUID, FloatData, FloatPKData,
-    GenericData, GenericIPAddressData, GenericIPAddressPKData,
-    InheritAbstractModel, InheritBaseModel, IntegerData, IntegerPKData,
-    Intermediate, LengthModel, M2MData, M2MIntermediateData, M2MSelfData,
-    ModifyingSaveData, O2OData, PositiveBigIntegerData, PositiveIntegerData,
-    PositiveIntegerPKData, PositiveSmallIntegerData,
-    PositiveSmallIntegerPKData, SlugData, SlugPKData, SmallData, SmallPKData,
-    Tag, TextData, TimeData, UniqueAnchor, UUIDData, UUIDDefaultData,
+    Anchor,
+    AutoNowDateTimeData,
+    BigIntegerData,
+    BinaryData,
+    BooleanData,
+    BooleanPKData,
+    CharData,
+    CharPKData,
+    DateData,
+    DatePKData,
+    DateTimeData,
+    DateTimePKData,
+    DecimalData,
+    DecimalPKData,
+    EmailData,
+    EmailPKData,
+    ExplicitInheritBaseModel,
+    FileData,
+    FilePathData,
+    FilePathPKData,
+    FKData,
+    FKDataToField,
+    FKDataToO2O,
+    FKSelfData,
+    FKToUUID,
+    FloatData,
+    FloatPKData,
+    GenericData,
+    GenericIPAddressData,
+    GenericIPAddressPKData,
+    InheritAbstractModel,
+    InheritBaseModel,
+    IntegerData,
+    IntegerPKData,
+    Intermediate,
+    LengthModel,
+    M2MData,
+    M2MIntermediateData,
+    M2MSelfData,
+    ModifyingSaveData,
+    O2OData,
+    PositiveBigIntegerData,
+    PositiveIntegerData,
+    PositiveIntegerPKData,
+    PositiveSmallIntegerData,
+    PositiveSmallIntegerPKData,
+    SlugData,
+    SlugPKData,
+    SmallData,
+    SmallPKData,
+    Tag,
+    TextData,
+    TimeData,
+    UniqueAnchor,
+    UUIDData,
+    UUIDDefaultData,
 )
 from .tests import register_tests
 
@@ -55,7 +99,7 @@ def generic_create(pk, klass, data):
 
 def fk_create(pk, klass, data):
     instance = klass(id=pk)
-    setattr(instance, 'data_id', data)
+    setattr(instance, "data_id", data)
     models.Model.save_base(instance, raw=True)
     return [instance]
 
@@ -75,10 +119,10 @@ def im2m_create(pk, klass, data):
 
 def im_create(pk, klass, data):
     instance = klass(id=pk)
-    instance.right_id = data['right']
-    instance.left_id = data['left']
-    if 'extra' in data:
-        instance.extra = data['extra']
+    instance.right_id = data["right"]
+    instance.left_id = data["left"]
+    if "extra" in data:
+        instance.extra = data["extra"]
     models.Model.save_base(instance, raw=True)
     return [instance]
 
@@ -110,6 +154,7 @@ def inherited_create(pk, klass, data):
         created.append(klass.objects.get(id=pk))
     return created
 
+
 # A set of functions that can be used to compare
 # test data objects of various kinds
 
@@ -118,25 +163,36 @@ def data_compare(testcase, pk, klass, data):
     instance = klass.objects.get(id=pk)
     if klass == BinaryData and data is not None:
         testcase.assertEqual(
-            bytes(data), bytes(instance.data),
-            "Objects with PK=%d not equal; expected '%s' (%s), got '%s' (%s)" % (
-                pk, repr(bytes(data)), type(data), repr(bytes(instance.data)),
+            bytes(data),
+            bytes(instance.data),
+            "Objects with PK=%d not equal; expected '%s' (%s), got '%s' (%s)"
+            % (
+                pk,
+                repr(bytes(data)),
+                type(data),
+                repr(bytes(instance.data)),
                 type(instance.data),
-            )
+            ),
         )
     else:
         testcase.assertEqual(
-            data, instance.data,
-            "Objects with PK=%d not equal; expected '%s' (%s), got '%s' (%s)" % (
-                pk, data, type(data), instance, type(instance.data),
-            )
+            data,
+            instance.data,
+            "Objects with PK=%d not equal; expected '%s' (%s), got '%s' (%s)"
+            % (
+                pk,
+                data,
+                type(data),
+                instance,
+                type(instance.data),
+            ),
         )
 
 
 def generic_compare(testcase, pk, klass, data):
     instance = klass.objects.get(id=pk)
     testcase.assertEqual(data[0], instance.data)
-    testcase.assertEqual(data[1:], [t.data for t in instance.tags.order_by('id')])
+    testcase.assertEqual(data[1:], [t.data for t in instance.tags.order_by("id")])
 
 
 def fk_compare(testcase, pk, klass, data):
@@ -146,7 +202,7 @@ def fk_compare(testcase, pk, klass, data):
 
 def m2m_compare(testcase, pk, klass, data):
     instance = klass.objects.get(id=pk)
-    testcase.assertEqual(data, [obj.id for obj in instance.data.order_by('id')])
+    testcase.assertEqual(data, [obj.id for obj in instance.data.order_by("id")])
 
 
 def im2m_compare(testcase, pk, klass, data):
@@ -156,10 +212,10 @@ def im2m_compare(testcase, pk, klass, data):
 
 def im_compare(testcase, pk, klass, data):
     instance = klass.objects.get(id=pk)
-    testcase.assertEqual(data['left'], instance.left_id)
-    testcase.assertEqual(data['right'], instance.right_id)
-    if 'extra' in data:
-        testcase.assertEqual(data['extra'], instance.extra)
+    testcase.assertEqual(data["left"], instance.left_id)
+    testcase.assertEqual(data["right"], instance.right_id)
+    if "extra" in data:
+        testcase.assertEqual(data["extra"], instance.extra)
     else:
         testcase.assertEqual("doesn't matter", instance.extra)
 
@@ -209,7 +265,7 @@ test_data = [
     (data_obj, 15, CharData, None),
     # (We use something that will fit into a latin1 database encoding here,
     # because that is still the default used on many system setups.)
-    (data_obj, 16, CharData, '\xa5'),
+    (data_obj, 16, CharData, "\xa5"),
     (data_obj, 20, DateData, datetime.date(2006, 6, 16)),
     (data_obj, 21, DateData, None),
     (data_obj, 30, DateTimeData, datetime.datetime(2006, 6, 16, 10, 42, 37)),
@@ -217,15 +273,15 @@ test_data = [
     (data_obj, 40, EmailData, "hovercraft@example.com"),
     (data_obj, 41, EmailData, None),
     (data_obj, 42, EmailData, ""),
-    (data_obj, 50, FileData, 'file:///foo/bar/whiz.txt'),
+    (data_obj, 50, FileData, "file:///foo/bar/whiz.txt"),
     # (data_obj, 51, FileData, None),
     (data_obj, 52, FileData, ""),
     (data_obj, 60, FilePathData, "/foo/bar/whiz.txt"),
     (data_obj, 61, FilePathData, None),
     (data_obj, 62, FilePathData, ""),
-    (data_obj, 70, DecimalData, decimal.Decimal('12.345')),
-    (data_obj, 71, DecimalData, decimal.Decimal('-12.345')),
-    (data_obj, 72, DecimalData, decimal.Decimal('0.0')),
+    (data_obj, 70, DecimalData, decimal.Decimal("12.345")),
+    (data_obj, 71, DecimalData, decimal.Decimal("-12.345")),
+    (data_obj, 72, DecimalData, decimal.Decimal("0.0")),
     (data_obj, 73, DecimalData, None),
     (data_obj, 74, FloatData, 12.345),
     (data_obj, 75, FloatData, -12.345),
@@ -251,38 +307,36 @@ test_data = [
     (data_obj, 151, SmallData, -12),
     (data_obj, 152, SmallData, 0),
     (data_obj, 153, SmallData, None),
-    (data_obj, 160, TextData, """This is a long piece of text.
+    (
+        data_obj,
+        160,
+        TextData,
+        """This is a long piece of text.
 It contains line breaks.
 Several of them.
-The end."""),
+The end.""",
+    ),
     (data_obj, 161, TextData, ""),
     (data_obj, 162, TextData, None),
     (data_obj, 170, TimeData, datetime.time(10, 42, 37)),
     (data_obj, 171, TimeData, None),
-
-    (generic_obj, 200, GenericData, ['Generic Object 1', 'tag1', 'tag2']),
-    (generic_obj, 201, GenericData, ['Generic Object 2', 'tag2', 'tag3']),
-
+    (generic_obj, 200, GenericData, ["Generic Object 1", "tag1", "tag2"]),
+    (generic_obj, 201, GenericData, ["Generic Object 2", "tag2", "tag3"]),
     (data_obj, 300, Anchor, "Anchor 1"),
     (data_obj, 301, Anchor, "Anchor 2"),
     (data_obj, 302, UniqueAnchor, "UAnchor 1"),
-
     (fk_obj, 400, FKData, 300),  # Post reference
     (fk_obj, 401, FKData, 500),  # Pre reference
     (fk_obj, 402, FKData, None),  # Empty reference
-
     (m2m_obj, 410, M2MData, []),  # Empty set
     (m2m_obj, 411, M2MData, [300, 301]),  # Post reference
     (m2m_obj, 412, M2MData, [500, 501]),  # Pre reference
     (m2m_obj, 413, M2MData, [300, 301, 500, 501]),  # Pre and Post reference
-
     (o2o_obj, None, O2OData, 300),  # Post reference
     (o2o_obj, None, O2OData, 500),  # Pre reference
-
     (fk_obj, 430, FKSelfData, 431),  # Pre reference
     (fk_obj, 431, FKSelfData, 430),  # Post reference
     (fk_obj, 432, FKSelfData, None),  # Empty reference
-
     (m2m_obj, 440, M2MSelfData, []),
     (m2m_obj, 441, M2MSelfData, []),
     (m2m_obj, 442, M2MSelfData, [440, 441]),
@@ -290,31 +344,24 @@ The end."""),
     (m2m_obj, 444, M2MSelfData, [440, 441, 445, 446]),
     (m2m_obj, 445, M2MSelfData, []),
     (m2m_obj, 446, M2MSelfData, []),
-
     (fk_obj, 450, FKDataToField, "UAnchor 1"),
     (fk_obj, 451, FKDataToField, "UAnchor 2"),
     (fk_obj, 452, FKDataToField, None),
-
     (fk_obj, 460, FKDataToO2O, 300),
-
     (im2m_obj, 470, M2MIntermediateData, None),
-
     # testing post- and pre-references and extra fields
-    (im_obj, 480, Intermediate, {'right': 300, 'left': 470}),
-    (im_obj, 481, Intermediate, {'right': 300, 'left': 490}),
-    (im_obj, 482, Intermediate, {'right': 500, 'left': 470}),
-    (im_obj, 483, Intermediate, {'right': 500, 'left': 490}),
-    (im_obj, 484, Intermediate, {'right': 300, 'left': 470, 'extra': "extra"}),
-    (im_obj, 485, Intermediate, {'right': 300, 'left': 490, 'extra': "extra"}),
-    (im_obj, 486, Intermediate, {'right': 500, 'left': 470, 'extra': "extra"}),
-    (im_obj, 487, Intermediate, {'right': 500, 'left': 490, 'extra': "extra"}),
-
+    (im_obj, 480, Intermediate, {"right": 300, "left": 470}),
+    (im_obj, 481, Intermediate, {"right": 300, "left": 490}),
+    (im_obj, 482, Intermediate, {"right": 500, "left": 470}),
+    (im_obj, 483, Intermediate, {"right": 500, "left": 490}),
+    (im_obj, 484, Intermediate, {"right": 300, "left": 470, "extra": "extra"}),
+    (im_obj, 485, Intermediate, {"right": 300, "left": 490, "extra": "extra"}),
+    (im_obj, 486, Intermediate, {"right": 500, "left": 470, "extra": "extra"}),
+    (im_obj, 487, Intermediate, {"right": 500, "left": 490, "extra": "extra"}),
     (im2m_obj, 490, M2MIntermediateData, []),
-
     (data_obj, 500, Anchor, "Anchor 3"),
     (data_obj, 501, Anchor, "Anchor 4"),
     (data_obj, 502, UniqueAnchor, "UAnchor 2"),
-
     (pk_obj, 601, BooleanPKData, True),
     (pk_obj, 602, BooleanPKData, False),
     (pk_obj, 610, CharPKData, "Test Char PKData"),
@@ -323,9 +370,9 @@ The end."""),
     (pk_obj, 640, EmailPKData, "hovercraft@example.com"),
     # (pk_obj, 650, FilePKData, 'file:///foo/bar/whiz.txt'),
     (pk_obj, 660, FilePathPKData, "/foo/bar/whiz.txt"),
-    (pk_obj, 670, DecimalPKData, decimal.Decimal('12.345')),
-    (pk_obj, 671, DecimalPKData, decimal.Decimal('-12.345')),
-    (pk_obj, 672, DecimalPKData, decimal.Decimal('0.0')),
+    (pk_obj, 670, DecimalPKData, decimal.Decimal("12.345")),
+    (pk_obj, 671, DecimalPKData, decimal.Decimal("-12.345")),
+    (pk_obj, 672, DecimalPKData, decimal.Decimal("0.0")),
     (pk_obj, 673, FloatPKData, 12.345),
     (pk_obj, 674, FloatPKData, -12.345),
     (pk_obj, 675, FloatPKData, 0.0),
@@ -349,14 +396,16 @@ The end."""),
     (pk_obj, 791, UUIDData, uuid_obj),
     (fk_obj, 792, FKToUUID, uuid_obj),
     (pk_obj, 793, UUIDDefaultData, uuid_obj),
-
     (data_obj, 800, AutoNowDateTimeData, datetime.datetime(2006, 6, 16, 10, 42, 37)),
     (data_obj, 810, ModifyingSaveData, 42),
-
-    (inherited_obj, 900, InheritAbstractModel, {'child_data': 37, 'parent_data': 42}),
-    (inherited_obj, 910, ExplicitInheritBaseModel, {'child_data': 37, 'parent_data': 42}),
-    (inherited_obj, 920, InheritBaseModel, {'child_data': 37, 'parent_data': 42}),
-
+    (inherited_obj, 900, InheritAbstractModel, {"child_data": 37, "parent_data": 42}),
+    (
+        inherited_obj,
+        910,
+        ExplicitInheritBaseModel,
+        {"child_data": 37, "parent_data": 42},
+    ),
+    (inherited_obj, 920, InheritBaseModel, {"child_data": 37, "parent_data": 42}),
     (data_obj, 1000, BigIntegerData, 9223372036854775807),
     (data_obj, 1001, BigIntegerData, -9223372036854775808),
     (data_obj, 1002, BigIntegerData, 0),
@@ -370,10 +419,15 @@ The end."""),
 # when field.empty_strings_allowed is True and the value is None; skip these
 # tests.
 if connection.features.interprets_empty_strings_as_nulls:
-    test_data = [data for data in test_data
-                 if not (data[0] == data_obj and
-                         data[2]._meta.get_field('data').empty_strings_allowed and
-                         data[3] is None)]
+    test_data = [
+        data
+        for data in test_data
+        if not (
+            data[0] == data_obj
+            and data[2]._meta.get_field("data").empty_strings_allowed
+            and data[3] is None
+        )
+    ]
 
 
 class SerializerDataTests(TestCase):
@@ -385,10 +439,12 @@ def serializerTest(self, format):
     # NO_AUTO_VALUE_ON_ZERO SQL mode since it won't let you create an object
     # with an autoincrement primary key of 0.
     if connection.features.allows_auto_pk_0:
-        test_data.extend([
-            (data_obj, 0, Anchor, 'Anchor 0'),
-            (fk_obj, 465, FKData, 0),
-        ])
+        test_data.extend(
+            [
+                (data_obj, 0, Anchor, "Anchor 0"),
+                (fk_obj, 465, FKData, 0),
+            ]
+        )
 
     # Create all the objects defined in the test data
     objects = []
@@ -421,4 +477,4 @@ def serializerTest(self, format):
         self.assertEqual(count, klass.objects.count())
 
 
-register_tests(SerializerDataTests, 'test_%s_serializer', serializerTest)
+register_tests(SerializerDataTests, "test_%s_serializer", serializerTest)
diff --git a/tests/serializers/test_deserializedobject.py b/tests/serializers/test_deserializedobject.py
index d9c313b78d..1252052100 100644
--- a/tests/serializers/test_deserializedobject.py
+++ b/tests/serializers/test_deserializedobject.py
@@ -5,8 +5,9 @@ from .models import Author
 
 
 class TestDeserializedObjectTests(SimpleTestCase):
-
     def test_repr(self):
-        author = Author(name='John', pk=1)
+        author = Author(name="John", pk=1)
         deserial_obj = DeserializedObject(obj=author)
-        self.assertEqual(repr(deserial_obj), '<DeserializedObject: serializers.Author(pk=1)>')
+        self.assertEqual(
+            repr(deserial_obj), "<DeserializedObject: serializers.Author(pk=1)>"
+        )
diff --git a/tests/serializers/test_json.py b/tests/serializers/test_json.py
index 93e51e124c..0c625684ac 100644
--- a/tests/serializers/test_json.py
+++ b/tests/serializers/test_json.py
@@ -56,21 +56,25 @@ class JsonSerializerTestCase(SerializersTestBase, TestCase):
     @staticmethod
     def _get_pk_values(serial_str):
         serial_list = json.loads(serial_str)
-        return [obj_dict['pk'] for obj_dict in serial_list]
+        return [obj_dict["pk"] for obj_dict in serial_list]
 
     @staticmethod
     def _get_field_values(serial_str, field_name):
         serial_list = json.loads(serial_str)
-        return [obj_dict['fields'][field_name] for obj_dict in serial_list if field_name in obj_dict['fields']]
+        return [
+            obj_dict["fields"][field_name]
+            for obj_dict in serial_list
+            if field_name in obj_dict["fields"]
+        ]
 
     def test_indentation_whitespace(self):
         s = serializers.json.Serializer()
         json_data = s.serialize([Score(score=5.0), Score(score=6.0)], indent=2)
         for line in json_data.splitlines():
-            if re.search(r'.+,\s*$', line):
+            if re.search(r".+,\s*$", line):
                 self.assertEqual(line, line.rstrip())
 
-    @isolate_apps('serializers')
+    @isolate_apps("serializers")
     def test_custom_encoder(self):
         class ScoreDecimal(models.Model):
             score = models.DecimalField()
@@ -106,8 +110,10 @@ class JsonSerializerTestCase(SerializersTestBase, TestCase):
                 "team": "Team"
             }
         }]"""
-        with self.assertRaisesMessage(DeserializationError, "(serializers.player:pk=badpk)"):
-            list(serializers.deserialize('json', test_string))
+        with self.assertRaisesMessage(
+            DeserializationError, "(serializers.player:pk=badpk)"
+        ):
+            list(serializers.deserialize("json", test_string))
 
     def test_helpful_error_message_invalid_field(self):
         """
@@ -125,7 +131,7 @@ class JsonSerializerTestCase(SerializersTestBase, TestCase):
         }]"""
         expected = "(serializers.player:pk=1) field_value was 'invalidint'"
         with self.assertRaisesMessage(DeserializationError, expected):
-            list(serializers.deserialize('json', test_string))
+            list(serializers.deserialize("json", test_string))
 
     def test_helpful_error_message_for_foreign_keys(self):
         """
@@ -146,7 +152,7 @@ class JsonSerializerTestCase(SerializersTestBase, TestCase):
         key = ["doesnotexist", "metadata"]
         expected = "(serializers.category:pk=1) field_value was '%r'" % key
         with self.assertRaisesMessage(DeserializationError, expected):
-            list(serializers.deserialize('json', test_string))
+            list(serializers.deserialize("json", test_string))
 
     def test_helpful_error_message_for_many2many_non_natural(self):
         """
@@ -176,7 +182,7 @@ class JsonSerializerTestCase(SerializersTestBase, TestCase):
         }]"""
         expected = "(serializers.article:pk=1) field_value was 'doesnotexist'"
         with self.assertRaisesMessage(DeserializationError, expected):
-            list(serializers.deserialize('json', test_string))
+            list(serializers.deserialize("json", test_string))
 
     def test_helpful_error_message_for_many2many_natural1(self):
         """
@@ -214,7 +220,7 @@ class JsonSerializerTestCase(SerializersTestBase, TestCase):
         key = ["doesnotexist", "meta1"]
         expected = "(serializers.article:pk=1) field_value was '%r'" % key
         with self.assertRaisesMessage(DeserializationError, expected):
-            for obj in serializers.deserialize('json', test_string):
+            for obj in serializers.deserialize("json", test_string):
                 obj.save()
 
     def test_helpful_error_message_for_many2many_natural2(self):
@@ -249,7 +255,7 @@ class JsonSerializerTestCase(SerializersTestBase, TestCase):
         }]"""
         expected = "(serializers.article:pk=1) field_value was 'doesnotexist'"
         with self.assertRaisesMessage(DeserializationError, expected):
-            for obj in serializers.deserialize('json', test_string, ignore=False):
+            for obj in serializers.deserialize("json", test_string, ignore=False):
                 obj.save()
 
     def test_helpful_error_message_for_many2many_not_iterable(self):
@@ -264,10 +270,12 @@ class JsonSerializerTestCase(SerializersTestBase, TestCase):
 
         expected = "(serializers.m2mdata:pk=1) field_value was 'None'"
         with self.assertRaisesMessage(DeserializationError, expected):
-            next(serializers.deserialize('json', test_string, ignore=False))
+            next(serializers.deserialize("json", test_string, ignore=False))
 
 
-class JsonSerializerTransactionTestCase(SerializersTransactionTestBase, TransactionTestCase):
+class JsonSerializerTransactionTestCase(
+    SerializersTransactionTestBase, TransactionTestCase
+):
     serializer_name = "json"
     fwd_ref_str = """[
     {
@@ -299,23 +307,23 @@ class JsonSerializerTransactionTestCase(SerializersTransactionTestBase, Transact
 class DjangoJSONEncoderTests(SimpleTestCase):
     def test_lazy_string_encoding(self):
         self.assertEqual(
-            json.dumps({'lang': gettext_lazy("French")}, cls=DjangoJSONEncoder),
-            '{"lang": "French"}'
+            json.dumps({"lang": gettext_lazy("French")}, cls=DjangoJSONEncoder),
+            '{"lang": "French"}',
         )
-        with override('fr'):
+        with override("fr"):
             self.assertEqual(
-                json.dumps({'lang': gettext_lazy("French")}, cls=DjangoJSONEncoder),
-                '{"lang": "Fran\\u00e7ais"}'
+                json.dumps({"lang": gettext_lazy("French")}, cls=DjangoJSONEncoder),
+                '{"lang": "Fran\\u00e7ais"}',
             )
 
     def test_timedelta(self):
         duration = datetime.timedelta(days=1, hours=2, seconds=3)
         self.assertEqual(
-            json.dumps({'duration': duration}, cls=DjangoJSONEncoder),
-            '{"duration": "P1DT02H00M03S"}'
+            json.dumps({"duration": duration}, cls=DjangoJSONEncoder),
+            '{"duration": "P1DT02H00M03S"}',
         )
         duration = datetime.timedelta(0)
         self.assertEqual(
-            json.dumps({'duration': duration}, cls=DjangoJSONEncoder),
-            '{"duration": "P0DT00H00M00S"}'
+            json.dumps({"duration": duration}, cls=DjangoJSONEncoder),
+            '{"duration": "P0DT00H00M00S"}',
         )
diff --git a/tests/serializers/test_jsonl.py b/tests/serializers/test_jsonl.py
index e4f1a3e80f..16a0759e74 100644
--- a/tests/serializers/test_jsonl.py
+++ b/tests/serializers/test_jsonl.py
@@ -44,20 +44,24 @@ class JsonlSerializerTestCase(SerializersTestBase, TestCase):
     @staticmethod
     def _get_pk_values(serial_str):
         serial_list = [json.loads(line) for line in serial_str.split("\n") if line]
-        return [obj_dict['pk'] for obj_dict in serial_list]
+        return [obj_dict["pk"] for obj_dict in serial_list]
 
     @staticmethod
     def _get_field_values(serial_str, field_name):
         serial_list = [json.loads(line) for line in serial_str.split("\n") if line]
-        return [obj_dict['fields'][field_name] for obj_dict in serial_list if field_name in obj_dict['fields']]
+        return [
+            obj_dict["fields"][field_name]
+            for obj_dict in serial_list
+            if field_name in obj_dict["fields"]
+        ]
 
     def test_no_indentation(self):
         s = serializers.jsonl.Serializer()
         json_data = s.serialize([Score(score=5.0), Score(score=6.0)], indent=2)
         for line in json_data.splitlines():
-            self.assertIsNone(re.search(r'.+,\s*$', line))
+            self.assertIsNone(re.search(r".+,\s*$", line))
 
-    @isolate_apps('serializers')
+    @isolate_apps("serializers")
     def test_custom_encoder(self):
         class ScoreDecimal(models.Model):
             score = models.DecimalField()
@@ -70,7 +74,8 @@ class JsonlSerializerTestCase(SerializersTestBase, TestCase):
 
         s = serializers.jsonl.Serializer()
         json_data = s.serialize(
-            [ScoreDecimal(score=decimal.Decimal(1.0))], cls=CustomJSONEncoder,
+            [ScoreDecimal(score=decimal.Decimal(1.0))],
+            cls=CustomJSONEncoder,
         )
         self.assertIn('"fields": {"score": "1"}', json_data)
 
@@ -88,8 +93,10 @@ class JsonlSerializerTestCase(SerializersTestBase, TestCase):
             '{"pk": "badpk","model": "serializers.player",'
             '"fields": {"name": "Bob","rank": 1,"team": "Team"}}'
         )
-        with self.assertRaisesMessage(DeserializationError, "(serializers.player:pk=badpk)"):
-            list(serializers.deserialize('jsonl', test_string))
+        with self.assertRaisesMessage(
+            DeserializationError, "(serializers.player:pk=badpk)"
+        ):
+            list(serializers.deserialize("jsonl", test_string))
 
     def test_helpful_error_message_invalid_field(self):
         """
@@ -102,7 +109,7 @@ class JsonlSerializerTestCase(SerializersTestBase, TestCase):
         )
         expected = "(serializers.player:pk=1) field_value was 'invalidint'"
         with self.assertRaisesMessage(DeserializationError, expected):
-            list(serializers.deserialize('jsonl', test_string))
+            list(serializers.deserialize("jsonl", test_string))
 
     def test_helpful_error_message_for_foreign_keys(self):
         """
@@ -118,7 +125,7 @@ class JsonlSerializerTestCase(SerializersTestBase, TestCase):
         key = ["doesnotexist", "metadata"]
         expected = "(serializers.category:pk=1) field_value was '%r'" % key
         with self.assertRaisesMessage(DeserializationError, expected):
-            list(serializers.deserialize('jsonl', test_string))
+            list(serializers.deserialize("jsonl", test_string))
 
     def test_helpful_error_message_for_many2many_non_natural(self):
         """
@@ -144,12 +151,12 @@ class JsonlSerializerTestCase(SerializersTestBase, TestCase):
                 "pk": 1,
                 "model": "serializers.category",
                 "fields": {"name": "Reference"}
-            }"""
+            }""",
         ]
         test_string = "\n".join([s.replace("\n", "") for s in test_strings])
         expected = "(serializers.article:pk=1) field_value was 'doesnotexist'"
         with self.assertRaisesMessage(DeserializationError, expected):
-            list(serializers.deserialize('jsonl', test_string))
+            list(serializers.deserialize("jsonl", test_string))
 
     def test_helpful_error_message_for_many2many_natural1(self):
         """
@@ -180,13 +187,13 @@ class JsonlSerializerTestCase(SerializersTestBase, TestCase):
                 "pk": 1,
                 "model": "serializers.author",
                 "fields": {"name": "Agnes"}
-            }"""
+            }""",
         ]
         test_string = "\n".join([s.replace("\n", "") for s in test_strings])
         key = ["doesnotexist", "meta1"]
         expected = "(serializers.article:pk=1) field_value was '%r'" % key
         with self.assertRaisesMessage(DeserializationError, expected):
-            for obj in serializers.deserialize('jsonl', test_string):
+            for obj in serializers.deserialize("jsonl", test_string):
                 obj.save()
 
     def test_helpful_error_message_for_many2many_natural2(self):
@@ -214,12 +221,12 @@ class JsonlSerializerTestCase(SerializersTestBase, TestCase):
                 "pk": 1,
                 "model": "serializers.author",
                 "fields": {"name": "Agnes"}
-            }"""
+            }""",
         ]
         test_string = "\n".join([s.replace("\n", "") for s in test_strings])
         expected = "(serializers.article:pk=1) field_value was 'doesnotexist'"
         with self.assertRaisesMessage(DeserializationError, expected):
-            for obj in serializers.deserialize('jsonl', test_string, ignore=False):
+            for obj in serializers.deserialize("jsonl", test_string, ignore=False):
                 obj.save()
 
     def test_helpful_error_message_for_many2many_not_iterable(self):
@@ -231,10 +238,12 @@ class JsonlSerializerTestCase(SerializersTestBase, TestCase):
         )
         expected = "(serializers.m2mdata:pk=1) field_value was 'None'"
         with self.assertRaisesMessage(DeserializationError, expected):
-            next(serializers.deserialize('jsonl', test_string, ignore=False))
+            next(serializers.deserialize("jsonl", test_string, ignore=False))
 
 
-class JsonSerializerTransactionTestCase(SerializersTransactionTestBase, TransactionTestCase):
+class JsonSerializerTransactionTestCase(
+    SerializersTransactionTestBase, TransactionTestCase
+):
     serializer_name = "jsonl"
     fwd_ref_str = [
         """{
@@ -256,6 +265,6 @@ class JsonSerializerTransactionTestCase(SerializersTransactionTestBase, Transact
             "pk": 1,
             "model": "serializers.author",
             "fields": {"name": "Agnes"}
-        }"""
+        }""",
     ]
     fwd_ref_str = "\n".join([s.replace("\n", "") for s in fwd_ref_str])
diff --git a/tests/serializers/test_natural.py b/tests/serializers/test_natural.py
index 7d05f3a71f..6b6cfae6f3 100644
--- a/tests/serializers/test_natural.py
+++ b/tests/serializers/test_natural.py
@@ -3,8 +3,12 @@ from django.db import connection
 from django.test import TestCase
 
 from .models import (
-    Child, FKAsPKNoNaturalKey, FKDataNaturalKey, NaturalKeyAnchor,
-    NaturalKeyThing, NaturalPKWithDefault,
+    Child,
+    FKAsPKNoNaturalKey,
+    FKDataNaturalKey,
+    NaturalKeyAnchor,
+    NaturalKeyThing,
+    NaturalPKWithDefault,
 )
 from .tests import register_tests
 
@@ -22,7 +26,9 @@ def natural_key_serializer_test(self, format):
             FKDataNaturalKey.objects.create(id=1102, data_id=None),
         ]
     # Serialize the test database
-    serialized_data = serializers.serialize(format, objects, indent=2, use_natural_foreign_keys=True)
+    serialized_data = serializers.serialize(
+        format, objects, indent=2, use_natural_foreign_keys=True
+    )
 
     for obj in serializers.deserialize(format, serialized_data):
         obj.save()
@@ -32,19 +38,25 @@ def natural_key_serializer_test(self, format):
     for obj in objects:
         instance = obj.__class__.objects.get(id=obj.pk)
         self.assertEqual(
-            obj.data, instance.data,
-            "Objects with PK=%d not equal; expected '%s' (%s), got '%s' (%s)" % (
-                obj.pk, obj.data, type(obj.data), instance, type(instance.data),
-            )
+            obj.data,
+            instance.data,
+            "Objects with PK=%d not equal; expected '%s' (%s), got '%s' (%s)"
+            % (
+                obj.pk,
+                obj.data,
+                type(obj.data),
+                instance,
+                type(instance.data),
+            ),
         )
 
 
 def natural_key_test(self, format):
     book1 = {
-        'data': '978-1590597255',
-        'title': 'The Definitive Guide to Django: Web Development Done Right',
+        "data": "978-1590597255",
+        "title": "The Definitive Guide to Django: Web Development Done Right",
     }
-    book2 = {'data': '978-1590599969', 'title': 'Practical Django Projects'}
+    book2 = {"data": "978-1590599969", "title": "Practical Django Projects"}
 
     # Create the books.
     adrian = NaturalKeyAnchor.objects.create(**book1)
@@ -52,8 +64,11 @@ def natural_key_test(self, format):
 
     # Serialize the books.
     string_data = serializers.serialize(
-        format, NaturalKeyAnchor.objects.all(), indent=2,
-        use_natural_foreign_keys=True, use_natural_primary_keys=True,
+        format,
+        NaturalKeyAnchor.objects.all(),
+        indent=2,
+        use_natural_foreign_keys=True,
+        use_natural_primary_keys=True,
     )
 
     # Delete one book (to prove that the natural key generation will only
@@ -64,9 +79,9 @@ def natural_key_test(self, format):
     # Deserialize and test.
     books = list(serializers.deserialize(format, string_data))
     self.assertEqual(len(books), 2)
-    self.assertEqual(books[0].object.title, book1['title'])
+    self.assertEqual(books[0].object.title, book1["title"])
     self.assertEqual(books[0].object.pk, adrian.pk)
-    self.assertEqual(books[1].object.title, book2['title'])
+    self.assertEqual(books[1].object.title, book2["title"])
     self.assertIsNone(books[1].object.pk)
 
 
@@ -77,12 +92,13 @@ def natural_pk_mti_test(self, format):
     the fields of the child so it's possible to relate the child to the parent
     when deserializing.
     """
-    child_1 = Child.objects.create(parent_data='1', child_data='1')
-    child_2 = Child.objects.create(parent_data='2', child_data='2')
+    child_1 = Child.objects.create(parent_data="1", child_data="1")
+    child_2 = Child.objects.create(parent_data="2", child_data="2")
     string_data = serializers.serialize(
         format,
         [child_1.parent_ptr, child_2.parent_ptr, child_2, child_1],
-        use_natural_foreign_keys=True, use_natural_primary_keys=True,
+        use_natural_foreign_keys=True,
+        use_natural_primary_keys=True,
     )
     child_1.delete()
     child_2.delete()
@@ -97,90 +113,106 @@ def natural_pk_mti_test(self, format):
 
 
 def forward_ref_fk_test(self, format):
-    t1 = NaturalKeyThing.objects.create(key='t1')
-    t2 = NaturalKeyThing.objects.create(key='t2', other_thing=t1)
+    t1 = NaturalKeyThing.objects.create(key="t1")
+    t2 = NaturalKeyThing.objects.create(key="t2", other_thing=t1)
     t1.other_thing = t2
     t1.save()
     string_data = serializers.serialize(
-        format, [t1, t2], use_natural_primary_keys=True,
+        format,
+        [t1, t2],
+        use_natural_primary_keys=True,
         use_natural_foreign_keys=True,
     )
     NaturalKeyThing.objects.all().delete()
     objs_with_deferred_fields = []
-    for obj in serializers.deserialize(format, string_data, handle_forward_references=True):
+    for obj in serializers.deserialize(
+        format, string_data, handle_forward_references=True
+    ):
         obj.save()
         if obj.deferred_fields:
             objs_with_deferred_fields.append(obj)
     for obj in objs_with_deferred_fields:
         obj.save_deferred_fields()
-    t1 = NaturalKeyThing.objects.get(key='t1')
-    t2 = NaturalKeyThing.objects.get(key='t2')
+    t1 = NaturalKeyThing.objects.get(key="t1")
+    t2 = NaturalKeyThing.objects.get(key="t2")
     self.assertEqual(t1.other_thing, t2)
     self.assertEqual(t2.other_thing, t1)
 
 
 def forward_ref_fk_with_error_test(self, format):
-    t1 = NaturalKeyThing.objects.create(key='t1')
-    t2 = NaturalKeyThing.objects.create(key='t2', other_thing=t1)
+    t1 = NaturalKeyThing.objects.create(key="t1")
+    t2 = NaturalKeyThing.objects.create(key="t2", other_thing=t1)
     t1.other_thing = t2
     t1.save()
     string_data = serializers.serialize(
-        format, [t1], use_natural_primary_keys=True,
+        format,
+        [t1],
+        use_natural_primary_keys=True,
         use_natural_foreign_keys=True,
     )
     NaturalKeyThing.objects.all().delete()
     objs_with_deferred_fields = []
-    for obj in serializers.deserialize(format, string_data, handle_forward_references=True):
+    for obj in serializers.deserialize(
+        format, string_data, handle_forward_references=True
+    ):
         obj.save()
         if obj.deferred_fields:
             objs_with_deferred_fields.append(obj)
     obj = objs_with_deferred_fields[0]
-    msg = 'NaturalKeyThing matching query does not exist'
+    msg = "NaturalKeyThing matching query does not exist"
     with self.assertRaisesMessage(serializers.base.DeserializationError, msg):
         obj.save_deferred_fields()
 
 
 def forward_ref_m2m_test(self, format):
-    t1 = NaturalKeyThing.objects.create(key='t1')
-    t2 = NaturalKeyThing.objects.create(key='t2')
-    t3 = NaturalKeyThing.objects.create(key='t3')
+    t1 = NaturalKeyThing.objects.create(key="t1")
+    t2 = NaturalKeyThing.objects.create(key="t2")
+    t3 = NaturalKeyThing.objects.create(key="t3")
     t1.other_things.set([t2, t3])
     string_data = serializers.serialize(
-        format, [t1, t2, t3], use_natural_primary_keys=True,
+        format,
+        [t1, t2, t3],
+        use_natural_primary_keys=True,
         use_natural_foreign_keys=True,
     )
     NaturalKeyThing.objects.all().delete()
     objs_with_deferred_fields = []
-    for obj in serializers.deserialize(format, string_data, handle_forward_references=True):
+    for obj in serializers.deserialize(
+        format, string_data, handle_forward_references=True
+    ):
         obj.save()
         if obj.deferred_fields:
             objs_with_deferred_fields.append(obj)
     for obj in objs_with_deferred_fields:
         obj.save_deferred_fields()
-    t1 = NaturalKeyThing.objects.get(key='t1')
-    t2 = NaturalKeyThing.objects.get(key='t2')
-    t3 = NaturalKeyThing.objects.get(key='t3')
+    t1 = NaturalKeyThing.objects.get(key="t1")
+    t2 = NaturalKeyThing.objects.get(key="t2")
+    t3 = NaturalKeyThing.objects.get(key="t3")
     self.assertCountEqual(t1.other_things.all(), [t2, t3])
 
 
 def forward_ref_m2m_with_error_test(self, format):
-    t1 = NaturalKeyThing.objects.create(key='t1')
-    t2 = NaturalKeyThing.objects.create(key='t2')
-    t3 = NaturalKeyThing.objects.create(key='t3')
+    t1 = NaturalKeyThing.objects.create(key="t1")
+    t2 = NaturalKeyThing.objects.create(key="t2")
+    t3 = NaturalKeyThing.objects.create(key="t3")
     t1.other_things.set([t2, t3])
     t1.save()
     string_data = serializers.serialize(
-        format, [t1, t2], use_natural_primary_keys=True,
+        format,
+        [t1, t2],
+        use_natural_primary_keys=True,
         use_natural_foreign_keys=True,
     )
     NaturalKeyThing.objects.all().delete()
     objs_with_deferred_fields = []
-    for obj in serializers.deserialize(format, string_data, handle_forward_references=True):
+    for obj in serializers.deserialize(
+        format, string_data, handle_forward_references=True
+    ):
         obj.save()
         if obj.deferred_fields:
             objs_with_deferred_fields.append(obj)
     obj = objs_with_deferred_fields[0]
-    msg = 'NaturalKeyThing matching query does not exist'
+    msg = "NaturalKeyThing matching query does not exist"
     with self.assertRaisesMessage(serializers.base.DeserializationError, msg):
         obj.save_deferred_fields()
 
@@ -190,9 +222,11 @@ def pk_with_default(self, format):
     The deserializer works with natural keys when the primary key has a default
     value.
     """
-    obj = NaturalPKWithDefault.objects.create(name='name')
+    obj = NaturalPKWithDefault.objects.create(name="name")
     string_data = serializers.serialize(
-        format, NaturalPKWithDefault.objects.all(), use_natural_foreign_keys=True,
+        format,
+        NaturalPKWithDefault.objects.all(),
+        use_natural_foreign_keys=True,
         use_natural_primary_keys=True,
     )
     objs = list(serializers.deserialize(format, string_data))
@@ -205,7 +239,7 @@ def fk_as_pk_natural_key_not_called(self, format):
     The deserializer doesn't rely on natural keys when a model has a custom
     primary key that is a ForeignKey.
     """
-    o1 = NaturalKeyAnchor.objects.create(data='978-1590599969')
+    o1 = NaturalKeyAnchor.objects.create(data="978-1590599969")
     o2 = FKAsPKNoNaturalKey.objects.create(pk_fk=o1)
     serialized_data = serializers.serialize(format, [o1, o2])
     deserialized_objects = list(serializers.deserialize(format, serialized_data))
@@ -215,16 +249,36 @@ def fk_as_pk_natural_key_not_called(self, format):
 
 
 # Dynamically register tests for each serializer
-register_tests(NaturalKeySerializerTests, 'test_%s_natural_key_serializer', natural_key_serializer_test)
-register_tests(NaturalKeySerializerTests, 'test_%s_serializer_natural_keys', natural_key_test)
-register_tests(NaturalKeySerializerTests, 'test_%s_serializer_natural_pks_mti', natural_pk_mti_test)
-register_tests(NaturalKeySerializerTests, 'test_%s_forward_references_fks', forward_ref_fk_test)
-register_tests(NaturalKeySerializerTests, 'test_%s_forward_references_fk_errors', forward_ref_fk_with_error_test)
-register_tests(NaturalKeySerializerTests, 'test_%s_forward_references_m2ms', forward_ref_m2m_test)
-register_tests(NaturalKeySerializerTests, 'test_%s_forward_references_m2m_errors', forward_ref_m2m_with_error_test)
-register_tests(NaturalKeySerializerTests, 'test_%s_pk_with_default', pk_with_default)
 register_tests(
     NaturalKeySerializerTests,
-    'test_%s_fk_as_pk_natural_key_not_called',
+    "test_%s_natural_key_serializer",
+    natural_key_serializer_test,
+)
+register_tests(
+    NaturalKeySerializerTests, "test_%s_serializer_natural_keys", natural_key_test
+)
+register_tests(
+    NaturalKeySerializerTests, "test_%s_serializer_natural_pks_mti", natural_pk_mti_test
+)
+register_tests(
+    NaturalKeySerializerTests, "test_%s_forward_references_fks", forward_ref_fk_test
+)
+register_tests(
+    NaturalKeySerializerTests,
+    "test_%s_forward_references_fk_errors",
+    forward_ref_fk_with_error_test,
+)
+register_tests(
+    NaturalKeySerializerTests, "test_%s_forward_references_m2ms", forward_ref_m2m_test
+)
+register_tests(
+    NaturalKeySerializerTests,
+    "test_%s_forward_references_m2m_errors",
+    forward_ref_m2m_with_error_test,
+)
+register_tests(NaturalKeySerializerTests, "test_%s_pk_with_default", pk_with_default)
+register_tests(
+    NaturalKeySerializerTests,
+    "test_%s_fk_as_pk_natural_key_not_called",
     fk_as_pk_natural_key_not_called,
 )
diff --git a/tests/serializers/test_xml.py b/tests/serializers/test_xml.py
index b11cfdd864..bfa91559ff 100644
--- a/tests/serializers/test_xml.py
+++ b/tests/serializers/test_xml.py
@@ -72,7 +72,7 @@ class XmlSerializerTestCase(SerializersTestBase, TestCase):
         self.a1.headline = "HT \u0009, LF \u000A, and CR \u000D are allowed"
         self.assertIn(
             "HT \t, LF \n, and CR \r are allowed",
-            serializers.serialize(self.serializer_name, [self.a1])
+            serializers.serialize(self.serializer_name, [self.a1]),
         )
 
     def test_no_dtd(self):
@@ -84,10 +84,12 @@ class XmlSerializerTestCase(SerializersTestBase, TestCase):
         """
         xml = '<?xml version="1.0" standalone="no"?><!DOCTYPE example SYSTEM "http://example.com/example.dtd">'
         with self.assertRaises(DTDForbidden):
-            next(serializers.deserialize('xml', xml))
+            next(serializers.deserialize("xml", xml))
 
 
-class XmlSerializerTransactionTestCase(SerializersTransactionTestBase, TransactionTestCase):
+class XmlSerializerTransactionTestCase(
+    SerializersTransactionTestBase, TransactionTestCase
+):
     serializer_name = "xml"
     fwd_ref_str = """<?xml version="1.0" encoding="utf-8"?>
 <django-objects version="1.0">
diff --git a/tests/serializers/test_yaml.py b/tests/serializers/test_yaml.py
index 6e11b93040..683e0e0688 100644
--- a/tests/serializers/test_yaml.py
+++ b/tests/serializers/test_yaml.py
@@ -11,11 +11,12 @@ from .tests import SerializersTestBase, SerializersTransactionTestBase
 
 try:
     import yaml
+
     HAS_YAML = True
 except ImportError:
     HAS_YAML = False
 
-YAML_IMPORT_ERROR_MESSAGE = r'No module named yaml'
+YAML_IMPORT_ERROR_MESSAGE = r"No module named yaml"
 
 
 class YamlImportModuleMock:
@@ -29,11 +30,12 @@ class YamlImportModuleMock:
 
     Refs: #12756
     """
+
     def __init__(self):
         self._import_module = importlib.import_module
 
     def import_module(self, module_path):
-        if module_path == serializers.BUILTIN_SERIALIZERS['yaml']:
+        if module_path == serializers.BUILTIN_SERIALIZERS["yaml"]:
             raise ImportError(YAML_IMPORT_ERROR_MESSAGE)
 
         return self._import_module(module_path)
@@ -44,6 +46,7 @@ class NoYamlSerializerTestCase(SimpleTestCase):
 
     Refs: #12756
     """
+
     @classmethod
     def setUpClass(cls):
         """Removes imported yaml and stubs importlib.import_module"""
@@ -78,8 +81,10 @@ class NoYamlSerializerTestCase(SimpleTestCase):
 
     def test_dumpdata_pyyaml_error_message(self):
         """Calling dumpdata produces an error when yaml package missing"""
-        with self.assertRaisesMessage(management.CommandError, YAML_IMPORT_ERROR_MESSAGE):
-            management.call_command('dumpdata', format='yaml')
+        with self.assertRaisesMessage(
+            management.CommandError, YAML_IMPORT_ERROR_MESSAGE
+        ):
+            management.call_command("dumpdata", format="yaml")
 
 
 @unittest.skipUnless(HAS_YAML, "No yaml library detected")
@@ -93,17 +98,23 @@ class YamlSerializerTestCase(SerializersTestBase, TestCase):
   fields:
     name: Non-fiction"""
 
-    mapping_ordering_str = """- model: serializers.article
+    mapping_ordering_str = (
+        """- model: serializers.article
   pk: %(article_pk)s
   fields:
     author: %(author_pk)s
     headline: Poker has no place on ESPN
     pub_date: 2006-06-16 11:00:00
-    categories:""" + (
-        ' [%(first_category_pk)s, %(second_category_pk)s]' if HAS_YAML and yaml.__version__ < '5.1'
-        else '\n    - %(first_category_pk)s\n    - %(second_category_pk)s') + """
+    categories:"""
+        + (
+            " [%(first_category_pk)s, %(second_category_pk)s]"
+            if HAS_YAML and yaml.__version__ < "5.1"
+            else "\n    - %(first_category_pk)s\n    - %(second_category_pk)s"
+        )
+        + """
     meta_data: []
 """
+    )
 
     @staticmethod
     def _validate_output(serial_str):
@@ -145,7 +156,9 @@ class YamlSerializerTestCase(SerializersTestBase, TestCase):
 
 
 @unittest.skipUnless(HAS_YAML, "No yaml library detected")
-class YamlSerializerTransactionTestCase(SerializersTransactionTestBase, TransactionTestCase):
+class YamlSerializerTransactionTestCase(
+    SerializersTransactionTestBase, TransactionTestCase
+):
     serializer_name = "yaml"
     fwd_ref_str = """- model: serializers.article
   pk: 1
diff --git a/tests/serializers/tests.py b/tests/serializers/tests.py
index 1b375a4a1e..8778d6f7da 100644
--- a/tests/serializers/tests.py
+++ b/tests/serializers/tests.py
@@ -14,8 +14,19 @@ from django.test.utils import Approximate, ignore_warnings
 from django.utils.deprecation import RemovedInDjango50Warning
 
 from .models import (
-    Actor, Article, Author, AuthorProfile, BaseModel, Category, Child,
-    ComplexModel, Movie, Player, ProxyBaseModel, ProxyProxyBaseModel, Score,
+    Actor,
+    Article,
+    Author,
+    AuthorProfile,
+    BaseModel,
+    Category,
+    Child,
+    ComplexModel,
+    Movie,
+    Player,
+    ProxyBaseModel,
+    ProxyProxyBaseModel,
+    Score,
     Team,
 )
 
@@ -35,22 +46,22 @@ class SerializerRegistrationTests(SimpleTestCase):
 
     def test_register(self):
         "Registering a new serializer populates the full registry. Refs #14823"
-        serializers.register_serializer('json3', 'django.core.serializers.json')
+        serializers.register_serializer("json3", "django.core.serializers.json")
 
         public_formats = serializers.get_public_serializer_formats()
-        self.assertIn('json3', public_formats)
-        self.assertIn('json2', public_formats)
-        self.assertIn('xml', public_formats)
+        self.assertIn("json3", public_formats)
+        self.assertIn("json2", public_formats)
+        self.assertIn("xml", public_formats)
 
     def test_unregister(self):
         "Unregistering a serializer doesn't cause the registry to be repopulated. Refs #14823"
-        serializers.unregister_serializer('xml')
-        serializers.register_serializer('json3', 'django.core.serializers.json')
+        serializers.unregister_serializer("xml")
+        serializers.register_serializer("json3", "django.core.serializers.json")
 
         public_formats = serializers.get_public_serializer_formats()
 
-        self.assertNotIn('xml', public_formats)
-        self.assertIn('json3', public_formats)
+        self.assertNotIn("xml", public_formats)
+        self.assertIn("json3", public_formats)
 
     def test_unregister_unknown_serializer(self):
         with self.assertRaises(SerializerDoesNotExist):
@@ -61,14 +72,14 @@ class SerializerRegistrationTests(SimpleTestCase):
         all_formats = set(serializers.get_serializer_formats())
         public_formats = set(serializers.get_public_serializer_formats())
 
-        self.assertIn('xml', all_formats),
-        self.assertIn('xml', public_formats)
+        self.assertIn("xml", all_formats),
+        self.assertIn("xml", public_formats)
 
-        self.assertIn('json2', all_formats)
-        self.assertIn('json2', public_formats)
+        self.assertIn("json2", all_formats)
+        self.assertIn("json2", public_formats)
 
-        self.assertIn('python', all_formats)
-        self.assertNotIn('python', public_formats)
+        self.assertIn("python", all_formats)
+        self.assertNotIn("python", public_formats)
 
     def test_get_unknown_serializer(self):
         """
@@ -81,7 +92,7 @@ class SerializerRegistrationTests(SimpleTestCase):
             serializers.get_serializer("nonsense")
 
         # SerializerDoesNotExist is instantiated with the nonexistent format
-        with self.assertRaisesMessage(SerializerDoesNotExist, 'nonsense'):
+        with self.assertRaisesMessage(SerializerDoesNotExist, "nonsense"):
             serializers.get_serializer("nonsense")
 
     def test_get_unknown_deserializer(self):
@@ -98,13 +109,13 @@ class SerializersTestBase:
         music = Category.objects.create(name="Music")
         op_ed = Category.objects.create(name="Op-Ed")
 
-        cls.joe = Author.objects.create(name='Joe')
-        cls.jane = Author.objects.create(name='Jane')
+        cls.joe = Author.objects.create(name="Joe")
+        cls.jane = Author.objects.create(name="Jane")
 
         cls.a1 = Article(
             author=cls.jane,
             headline="Poker has no place on ESPN",
-            pub_date=datetime(2006, 6, 16, 11, 00)
+            pub_date=datetime(2006, 6, 16, 11, 00),
         )
         cls.a1.save()
         cls.a1.categories.set([sports, op_ed])
@@ -112,7 +123,7 @@ class SerializersTestBase:
         cls.a2 = Article(
             author=cls.joe,
             headline="Time to reform copyright",
-            pub_date=datetime(2006, 6, 16, 13, 00, 11, 345)
+            pub_date=datetime(2006, 6, 16, 13, 00, 11, 345),
         )
         cls.a2.save()
         cls.a2.categories.set([music, op_ed])
@@ -129,7 +140,7 @@ class SerializersTestBase:
         self.assertEqual(len(models), 2)
 
     def test_serialize_to_stream(self):
-        obj = ComplexModel(field1='first', field2='second', field3='third')
+        obj = ComplexModel(field1="first", field2="second", field3="third")
         obj.save_base(raw=True)
 
         # Serialize the test database to a stream
@@ -146,19 +157,19 @@ class SerializersTestBase:
                 self.assertEqual(string_data, stream.content.decode())
 
     def test_serialize_specific_fields(self):
-        obj = ComplexModel(field1='first', field2='second', field3='third')
+        obj = ComplexModel(field1="first", field2="second", field3="third")
         obj.save_base(raw=True)
 
         # Serialize then deserialize the test database
         serialized_data = serializers.serialize(
-            self.serializer_name, [obj], indent=2, fields=('field1', 'field3')
+            self.serializer_name, [obj], indent=2, fields=("field1", "field3")
         )
         result = next(serializers.deserialize(self.serializer_name, serialized_data))
 
         # The deserialized object contains data in only the serialized fields.
-        self.assertEqual(result.object.field1, 'first')
-        self.assertEqual(result.object.field2, '')
-        self.assertEqual(result.object.field3, 'third')
+        self.assertEqual(result.object.field1, "first")
+        self.assertEqual(result.object.field2, "")
+        self.assertEqual(result.object.field3, "third")
 
     def test_altering_serialized_output(self):
         """
@@ -187,18 +198,24 @@ class SerializersTestBase:
         doesn't appear in the serialized field list - it replaces the pk
         identifier.
         """
-        AuthorProfile.objects.create(author=self.joe, date_of_birth=datetime(1970, 1, 1))
-        serial_str = serializers.serialize(self.serializer_name, AuthorProfile.objects.all())
-        self.assertFalse(self._get_field_values(serial_str, 'author'))
+        AuthorProfile.objects.create(
+            author=self.joe, date_of_birth=datetime(1970, 1, 1)
+        )
+        serial_str = serializers.serialize(
+            self.serializer_name, AuthorProfile.objects.all()
+        )
+        self.assertFalse(self._get_field_values(serial_str, "author"))
 
         for obj in serializers.deserialize(self.serializer_name, serial_str):
             self.assertEqual(obj.object.pk, self.joe.pk)
 
     def test_serialize_field_subset(self):
         """Output can be restricted to a subset of fields"""
-        valid_fields = ('headline', 'pub_date')
+        valid_fields = ("headline", "pub_date")
         invalid_fields = ("author", "categories")
-        serial_str = serializers.serialize(self.serializer_name, Article.objects.all(), fields=valid_fields)
+        serial_str = serializers.serialize(
+            self.serializer_name, Article.objects.all(), fields=valid_fields
+        )
         for field_name in invalid_fields:
             self.assertFalse(self._get_field_values(serial_str, field_name))
 
@@ -208,7 +225,7 @@ class SerializersTestBase:
     def test_serialize_unicode_roundtrip(self):
         """Unicode makes the roundtrip intact"""
         actor_name = "Za\u017c\u00f3\u0142\u0107"
-        movie_title = 'G\u0119\u015bl\u0105 ja\u017a\u0144'
+        movie_title = "G\u0119\u015bl\u0105 ja\u017a\u0144"
         ac = Actor(name=actor_name)
         mv = Movie(title=movie_title, actor=ac)
         ac.save()
@@ -223,7 +240,7 @@ class SerializersTestBase:
         self.assertEqual(mv_obj.title, movie_title)
 
     def test_unicode_serialization(self):
-        unicode_name = 'יוניקוד'
+        unicode_name = "יוניקוד"
         data = serializers.serialize(self.serializer_name, [Author(name=unicode_name)])
         self.assertIn(unicode_name, data)
         objs = list(serializers.deserialize(self.serializer_name, data))
@@ -232,11 +249,15 @@ class SerializersTestBase:
     def test_serialize_progressbar(self):
         fake_stdout = StringIO()
         serializers.serialize(
-            self.serializer_name, Article.objects.all(),
-            progress_output=fake_stdout, object_count=Article.objects.count()
+            self.serializer_name,
+            Article.objects.all(),
+            progress_output=fake_stdout,
+            object_count=Article.objects.count(),
         )
         self.assertTrue(
-            fake_stdout.getvalue().endswith('[' + '.' * ProgressBar.progress_width + ']\n')
+            fake_stdout.getvalue().endswith(
+                "[" + "." * ProgressBar.progress_width + "]\n"
+            )
         )
 
     def test_serialize_superfluous_queries(self):
@@ -244,9 +265,9 @@ class SerializersTestBase:
 
         #17602
         """
-        ac = Actor(name='Actor name')
+        ac = Actor(name="Actor name")
         ac.save()
-        mv = Movie(title='Movie title', actor_id=ac.pk)
+        mv = Movie(title="Movie title", actor_id=ac.pk)
         mv.save()
 
         with self.assertNumQueries(0):
@@ -258,7 +279,7 @@ class SerializersTestBase:
         with self.assertNumQueries(3):
             serializers.serialize(
                 self.serializer_name,
-                Article.objects.all().prefetch_related('categories', 'meta_data'),
+                Article.objects.all().prefetch_related("categories", "meta_data"),
             )
         # One query for the Article table, and two m2m queries for each
         # article.
@@ -275,7 +296,9 @@ class SerializersTestBase:
         pk_value = self._get_pk_values(serial_str)[0]
         self.assertFalse(pk_value)
 
-        cat_obj = list(serializers.deserialize(self.serializer_name, serial_str))[0].object
+        cat_obj = list(serializers.deserialize(self.serializer_name, serial_str))[
+            0
+        ].object
         self.assertIsNone(cat_obj.id)
 
     def test_float_serialization(self):
@@ -287,8 +310,8 @@ class SerializersTestBase:
         self.assertEqual(deserial_objs[0].object.score, Approximate(3.4, places=1))
 
     def test_deferred_field_serialization(self):
-        author = Author.objects.create(name='Victor Hugo')
-        author = Author.objects.defer('name').get(pk=author.pk)
+        author = Author.objects.create(name="Victor Hugo")
+        author = Author.objects.defer("name").get(pk=author.pk)
         serial_str = serializers.serialize(self.serializer_name, [author])
         deserial_objs = list(serializers.deserialize(self.serializer_name, serial_str))
         self.assertIsInstance(deserial_objs[0].object, Author)
@@ -307,7 +330,9 @@ class SerializersTestBase:
         self.assertEqual(team[0], team_str)
 
         deserial_objs = list(serializers.deserialize(self.serializer_name, serial_str))
-        self.assertEqual(deserial_objs[0].object.team.to_string(), player.team.to_string())
+        self.assertEqual(
+            deserial_objs[0].object.team.to_string(), player.team.to_string()
+        )
 
     def test_pre_1000ad_date(self):
         """Year values before 1000AD are properly formatted"""
@@ -316,17 +341,20 @@ class SerializersTestBase:
         a = Article.objects.create(
             author=self.jane,
             headline="Nobody remembers the early years",
-            pub_date=datetime(1, 2, 3, 4, 5, 6))
+            pub_date=datetime(1, 2, 3, 4, 5, 6),
+        )
 
         serial_str = serializers.serialize(self.serializer_name, [a])
         date_values = self._get_field_values(serial_str, "pub_date")
-        self.assertEqual(date_values[0].replace('T', ' '), "0001-02-03 04:05:06")
+        self.assertEqual(date_values[0].replace("T", " "), "0001-02-03 04:05:06")
 
     def test_pkless_serialized_strings(self):
         """
         Serialized strings without PKs can be turned into models
         """
-        deserial_objs = list(serializers.deserialize(self.serializer_name, self.pkless_str))
+        deserial_objs = list(
+            serializers.deserialize(self.serializer_name, self.pkless_str)
+        )
         for obj in deserial_objs:
             self.assertFalse(obj.object.id)
             obj.save()
@@ -335,23 +363,31 @@ class SerializersTestBase:
     def test_deterministic_mapping_ordering(self):
         """Mapping such as fields should be deterministically ordered. (#24558)"""
         output = serializers.serialize(self.serializer_name, [self.a1], indent=2)
-        categories = self.a1.categories.values_list('pk', flat=True)
-        self.assertEqual(output, self.mapping_ordering_str % {
-            'article_pk': self.a1.pk,
-            'author_pk': self.a1.author_id,
-            'first_category_pk': categories[0],
-            'second_category_pk': categories[1],
-        })
+        categories = self.a1.categories.values_list("pk", flat=True)
+        self.assertEqual(
+            output,
+            self.mapping_ordering_str
+            % {
+                "article_pk": self.a1.pk,
+                "author_pk": self.a1.author_id,
+                "first_category_pk": categories[0],
+                "second_category_pk": categories[1],
+            },
+        )
 
     def test_deserialize_force_insert(self):
         """Deserialized content can be saved with force_insert as a parameter."""
         serial_str = serializers.serialize(self.serializer_name, [self.a1])
-        deserial_obj = list(serializers.deserialize(self.serializer_name, serial_str))[0]
-        with mock.patch('django.db.models.Model') as mock_model:
+        deserial_obj = list(serializers.deserialize(self.serializer_name, serial_str))[
+            0
+        ]
+        with mock.patch("django.db.models.Model") as mock_model:
             deserial_obj.save(force_insert=False)
-            mock_model.save_base.assert_called_with(deserial_obj.object, raw=True, using=None, force_insert=False)
+            mock_model.save_base.assert_called_with(
+                deserial_obj.object, raw=True, using=None, force_insert=False
+            )
 
-    @skipUnlessDBFeature('can_defer_constraint_checks')
+    @skipUnlessDBFeature("can_defer_constraint_checks")
     def test_serialize_proxy_model(self):
         BaseModel.objects.create(parent_data=1)
         base_objects = BaseModel.objects.all()
@@ -360,20 +396,19 @@ class SerializersTestBase:
         base_data = serializers.serialize("json", base_objects)
         proxy_data = serializers.serialize("json", proxy_objects)
         proxy_proxy_data = serializers.serialize("json", proxy_proxy_objects)
-        self.assertEqual(base_data, proxy_data.replace('proxy', ''))
-        self.assertEqual(base_data, proxy_proxy_data.replace('proxy', ''))
+        self.assertEqual(base_data, proxy_data.replace("proxy", ""))
+        self.assertEqual(base_data, proxy_proxy_data.replace("proxy", ""))
 
     def test_serialize_inherited_fields(self):
-        child_1 = Child.objects.create(parent_data='a', child_data='b')
-        child_2 = Child.objects.create(parent_data='c', child_data='d')
+        child_1 = Child.objects.create(parent_data="a", child_data="b")
+        child_2 = Child.objects.create(parent_data="c", child_data="d")
         child_1.parent_m2m.add(child_2)
         child_data = serializers.serialize(self.serializer_name, [child_1, child_2])
-        self.assertEqual(self._get_field_values(child_data, 'parent_m2m'), [])
-        self.assertEqual(self._get_field_values(child_data, 'parent_data'), [])
+        self.assertEqual(self._get_field_values(child_data, "parent_m2m"), [])
+        self.assertEqual(self._get_field_values(child_data, "parent_data"), [])
 
 
 class SerializerAPITests(SimpleTestCase):
-
     def test_stream_class(self):
         class File:
             def __init__(self):
@@ -383,7 +418,7 @@ class SerializerAPITests(SimpleTestCase):
                 self.lines.append(line)
 
             def getvalue(self):
-                return ''.join(self.lines)
+                return "".join(self.lines)
 
         class Serializer(serializers.json.Serializer):
             stream_class = File
@@ -392,14 +427,16 @@ class SerializerAPITests(SimpleTestCase):
         data = serializer.serialize([Score(id=1, score=3.4)])
         self.assertIs(serializer.stream_class, File)
         self.assertIsInstance(serializer.stream, File)
-        self.assertEqual(data, '[{"model": "serializers.score", "pk": 1, "fields": {"score": 3.4}}]')
+        self.assertEqual(
+            data, '[{"model": "serializers.score", "pk": 1, "fields": {"score": 3.4}}]'
+        )
 
 
 class SerializersTransactionTestBase:
 
-    available_apps = ['serializers']
+    available_apps = ["serializers"]
 
-    @skipUnlessDBFeature('supports_forward_references')
+    @skipUnlessDBFeature("supports_forward_references")
     def test_forward_refs(self):
         """
         Objects ids can be referenced before they are
@@ -432,14 +469,14 @@ class PickleSerializerTests(SimpleTestCase):
     @ignore_warnings(category=RemovedInDjango50Warning)
     def test_serializer_loads_dumps(self):
         serializer = PickleSerializer()
-        test_data = 'test data'
+        test_data = "test data"
         dump = serializer.dumps(test_data)
         self.assertEqual(serializer.loads(dump), test_data)
 
     def test_serializer_warning(self):
         msg = (
-            'PickleSerializer is deprecated due to its security risk. Use '
-            'JSONSerializer instead.'
+            "PickleSerializer is deprecated due to its security risk. Use "
+            "JSONSerializer instead."
         )
         with self.assertRaisesMessage(RemovedInDjango50Warning, msg):
             PickleSerializer()
@@ -451,10 +488,12 @@ def register_tests(test_class, method_name, test_func, exclude=()):
     serializers are automatically tested.
     """
     for format_ in serializers.get_serializer_formats():
-        if format_ == 'geojson' or format_ in exclude:
+        if format_ == "geojson" or format_ in exclude:
             continue
         decorated_func = skipIf(
             isinstance(serializers.get_serializer(format_), serializers.BadSerializer),
-            'The Python library for the %s serializer is not installed.' % format_,
+            "The Python library for the %s serializer is not installed." % format_,
         )(test_func)
-        setattr(test_class, method_name % format_, partialmethod(decorated_func, format_))
+        setattr(
+            test_class, method_name % format_, partialmethod(decorated_func, format_)
+        )