Refs #33476 -- Reformatted code with Black.

1 files changed, 455 insertions, 347 deletions

diff --git a/tests/postgres_tests/test_constraints.py b/tests/postgres_tests/test_constraints.py
index 22506ed62d..14b45f9b7f 100644
--- a/tests/postgres_tests/test_constraints.py
+++ b/tests/postgres_tests/test_constraints.py
@@ -2,11 +2,15 @@ import datetime
 from unittest import mock
 
 from django.contrib.postgres.indexes import OpClass
-from django.db import (
-    IntegrityError, NotSupportedError, connection, transaction,
-)
+from django.db import IntegrityError, NotSupportedError, connection, transaction
 from django.db.models import (
-    CheckConstraint, Deferrable, F, Func, IntegerField, Q, UniqueConstraint,
+    CheckConstraint,
+    Deferrable,
+    F,
+    Func,
+    IntegerField,
+    Q,
+    UniqueConstraint,
 )
 from django.db.models.fields.json import KeyTextTransform
 from django.db.models.functions import Cast, Left, Lower
@@ -15,29 +19,29 @@ from django.utils import timezone
 from django.utils.deprecation import RemovedInDjango50Warning
 
 from . import PostgreSQLTestCase
-from .models import (
-    HotelReservation, IntegerArrayModel, RangesModel, Room, Scene,
-)
+from .models import HotelReservation, IntegerArrayModel, RangesModel, Room, Scene
 
 try:
     from psycopg2.extras import DateRange, NumericRange
 
     from django.contrib.postgres.constraints import ExclusionConstraint
     from django.contrib.postgres.fields import (
-        DateTimeRangeField, RangeBoundary, RangeOperators,
+        DateTimeRangeField,
+        RangeBoundary,
+        RangeOperators,
     )
 except ImportError:
     pass
 
 
-@modify_settings(INSTALLED_APPS={'append': 'django.contrib.postgres'})
+@modify_settings(INSTALLED_APPS={"append": "django.contrib.postgres"})
 class SchemaTests(PostgreSQLTestCase):
-    get_opclass_query = '''
+    get_opclass_query = """
         SELECT opcname, c.relname FROM pg_opclass AS oc
         JOIN pg_index as i on oc.oid = ANY(i.indclass)
         JOIN pg_class as c on c.oid = i.indexrelid
         WHERE c.relname = %s
-    '''
+    """
 
     def get_constraints(self, table):
         """Get the constraints on the table using a new cursor."""
@@ -45,8 +49,10 @@ class SchemaTests(PostgreSQLTestCase):
             return connection.introspection.get_constraints(cursor, table)
 
     def test_check_constraint_range_value(self):
-        constraint_name = 'ints_between'
-        self.assertNotIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+        constraint_name = "ints_between"
+        self.assertNotIn(
+            constraint_name, self.get_constraints(RangesModel._meta.db_table)
+        )
         constraint = CheckConstraint(
             check=Q(ints__contained_by=NumericRange(10, 30)),
             name=constraint_name,
@@ -59,10 +65,12 @@ class SchemaTests(PostgreSQLTestCase):
         RangesModel.objects.create(ints=(10, 30))
 
     def test_check_constraint_daterange_contains(self):
-        constraint_name = 'dates_contains'
-        self.assertNotIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+        constraint_name = "dates_contains"
+        self.assertNotIn(
+            constraint_name, self.get_constraints(RangesModel._meta.db_table)
+        )
         constraint = CheckConstraint(
-            check=Q(dates__contains=F('dates_inner')),
+            check=Q(dates__contains=F("dates_inner")),
             name=constraint_name,
         )
         with connection.schema_editor() as editor:
@@ -81,10 +89,12 @@ class SchemaTests(PostgreSQLTestCase):
         )
 
     def test_check_constraint_datetimerange_contains(self):
-        constraint_name = 'timestamps_contains'
-        self.assertNotIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+        constraint_name = "timestamps_contains"
+        self.assertNotIn(
+            constraint_name, self.get_constraints(RangesModel._meta.db_table)
+        )
         constraint = CheckConstraint(
-            check=Q(timestamps__contains=F('timestamps_inner')),
+            check=Q(timestamps__contains=F("timestamps_inner")),
             name=constraint_name,
         )
         with connection.schema_editor() as editor:
@@ -104,9 +114,9 @@ class SchemaTests(PostgreSQLTestCase):
 
     def test_opclass(self):
         constraint = UniqueConstraint(
-            name='test_opclass',
-            fields=['scene'],
-            opclasses=['varchar_pattern_ops'],
+            name="test_opclass",
+            fields=["scene"],
+            opclasses=["varchar_pattern_ops"],
         )
         with connection.schema_editor() as editor:
             editor.add_constraint(Scene, constraint)
@@ -115,7 +125,7 @@ class SchemaTests(PostgreSQLTestCase):
             cursor.execute(self.get_opclass_query, [constraint.name])
             self.assertEqual(
                 cursor.fetchall(),
-                [('varchar_pattern_ops', constraint.name)],
+                [("varchar_pattern_ops", constraint.name)],
             )
         # Drop the constraint.
         with connection.schema_editor() as editor:
@@ -124,25 +134,25 @@ class SchemaTests(PostgreSQLTestCase):
 
     def test_opclass_multiple_columns(self):
         constraint = UniqueConstraint(
-            name='test_opclass_multiple',
-            fields=['scene', 'setting'],
-            opclasses=['varchar_pattern_ops', 'text_pattern_ops'],
+            name="test_opclass_multiple",
+            fields=["scene", "setting"],
+            opclasses=["varchar_pattern_ops", "text_pattern_ops"],
         )
         with connection.schema_editor() as editor:
             editor.add_constraint(Scene, constraint)
         with editor.connection.cursor() as cursor:
             cursor.execute(self.get_opclass_query, [constraint.name])
             expected_opclasses = (
-                ('varchar_pattern_ops', constraint.name),
-                ('text_pattern_ops', constraint.name),
+                ("varchar_pattern_ops", constraint.name),
+                ("text_pattern_ops", constraint.name),
             )
             self.assertCountEqual(cursor.fetchall(), expected_opclasses)
 
     def test_opclass_partial(self):
         constraint = UniqueConstraint(
-            name='test_opclass_partial',
-            fields=['scene'],
-            opclasses=['varchar_pattern_ops'],
+            name="test_opclass_partial",
+            fields=["scene"],
+            opclasses=["varchar_pattern_ops"],
             condition=Q(setting__contains="Sir Bedemir's Castle"),
         )
         with connection.schema_editor() as editor:
@@ -151,16 +161,16 @@ class SchemaTests(PostgreSQLTestCase):
             cursor.execute(self.get_opclass_query, [constraint.name])
             self.assertCountEqual(
                 cursor.fetchall(),
-                [('varchar_pattern_ops', constraint.name)],
+                [("varchar_pattern_ops", constraint.name)],
             )
 
-    @skipUnlessDBFeature('supports_covering_indexes')
+    @skipUnlessDBFeature("supports_covering_indexes")
     def test_opclass_include(self):
         constraint = UniqueConstraint(
-            name='test_opclass_include',
-            fields=['scene'],
-            opclasses=['varchar_pattern_ops'],
-            include=['setting'],
+            name="test_opclass_include",
+            fields=["scene"],
+            opclasses=["varchar_pattern_ops"],
+            include=["setting"],
         )
         with connection.schema_editor() as editor:
             editor.add_constraint(Scene, constraint)
@@ -168,38 +178,38 @@ class SchemaTests(PostgreSQLTestCase):
             cursor.execute(self.get_opclass_query, [constraint.name])
             self.assertCountEqual(
                 cursor.fetchall(),
-                [('varchar_pattern_ops', constraint.name)],
+                [("varchar_pattern_ops", constraint.name)],
             )
 
-    @skipUnlessDBFeature('supports_expression_indexes')
+    @skipUnlessDBFeature("supports_expression_indexes")
     def test_opclass_func(self):
         constraint = UniqueConstraint(
-            OpClass(Lower('scene'), name='text_pattern_ops'),
-            name='test_opclass_func',
+            OpClass(Lower("scene"), name="text_pattern_ops"),
+            name="test_opclass_func",
         )
         with connection.schema_editor() as editor:
             editor.add_constraint(Scene, constraint)
         constraints = self.get_constraints(Scene._meta.db_table)
-        self.assertIs(constraints[constraint.name]['unique'], True)
+        self.assertIs(constraints[constraint.name]["unique"], True)
         self.assertIn(constraint.name, constraints)
         with editor.connection.cursor() as cursor:
             cursor.execute(self.get_opclass_query, [constraint.name])
             self.assertEqual(
                 cursor.fetchall(),
-                [('text_pattern_ops', constraint.name)],
+                [("text_pattern_ops", constraint.name)],
             )
-        Scene.objects.create(scene='Scene 10', setting='The dark forest of Ewing')
+        Scene.objects.create(scene="Scene 10", setting="The dark forest of Ewing")
         with self.assertRaises(IntegrityError), transaction.atomic():
-            Scene.objects.create(scene='ScEnE 10', setting="Sir Bedemir's Castle")
-        Scene.objects.create(scene='Scene 5', setting="Sir Bedemir's Castle")
+            Scene.objects.create(scene="ScEnE 10", setting="Sir Bedemir's Castle")
+        Scene.objects.create(scene="Scene 5", setting="Sir Bedemir's Castle")
         # Drop the constraint.
         with connection.schema_editor() as editor:
             editor.remove_constraint(Scene, constraint)
         self.assertNotIn(constraint.name, self.get_constraints(Scene._meta.db_table))
-        Scene.objects.create(scene='ScEnE 10', setting="Sir Bedemir's Castle")
+        Scene.objects.create(scene="ScEnE 10", setting="Sir Bedemir's Castle")
 
 
-@modify_settings(INSTALLED_APPS={'append': 'django.contrib.postgres'})
+@modify_settings(INSTALLED_APPS={"append": "django.contrib.postgres"})
 class ExclusionConstraintTests(PostgreSQLTestCase):
     def get_constraints(self, table):
         """Get the constraints on the table using a new cursor."""
@@ -207,102 +217,104 @@ class ExclusionConstraintTests(PostgreSQLTestCase):
             return connection.introspection.get_constraints(cursor, table)
 
     def test_invalid_condition(self):
-        msg = 'ExclusionConstraint.condition must be a Q instance.'
+        msg = "ExclusionConstraint.condition must be a Q instance."
         with self.assertRaisesMessage(ValueError, msg):
             ExclusionConstraint(
-                index_type='GIST',
-                name='exclude_invalid_condition',
-                expressions=[(F('datespan'), RangeOperators.OVERLAPS)],
-                condition=F('invalid'),
+                index_type="GIST",
+                name="exclude_invalid_condition",
+                expressions=[(F("datespan"), RangeOperators.OVERLAPS)],
+                condition=F("invalid"),
             )
 
     def test_invalid_index_type(self):
-        msg = 'Exclusion constraints only support GiST or SP-GiST indexes.'
+        msg = "Exclusion constraints only support GiST or SP-GiST indexes."
         with self.assertRaisesMessage(ValueError, msg):
             ExclusionConstraint(
-                index_type='gin',
-                name='exclude_invalid_index_type',
-                expressions=[(F('datespan'), RangeOperators.OVERLAPS)],
+                index_type="gin",
+                name="exclude_invalid_index_type",
+                expressions=[(F("datespan"), RangeOperators.OVERLAPS)],
             )
 
     def test_invalid_expressions(self):
-        msg = 'The expressions must be a list of 2-tuples.'
-        for expressions in (['foo'], [('foo')], [('foo_1', 'foo_2', 'foo_3')]):
+        msg = "The expressions must be a list of 2-tuples."
+        for expressions in (["foo"], [("foo")], [("foo_1", "foo_2", "foo_3")]):
             with self.subTest(expressions), self.assertRaisesMessage(ValueError, msg):
                 ExclusionConstraint(
-                    index_type='GIST',
-                    name='exclude_invalid_expressions',
+                    index_type="GIST",
+                    name="exclude_invalid_expressions",
                     expressions=expressions,
                 )
 
     def test_empty_expressions(self):
-        msg = 'At least one expression is required to define an exclusion constraint.'
+        msg = "At least one expression is required to define an exclusion constraint."
         for empty_expressions in (None, []):
-            with self.subTest(empty_expressions), self.assertRaisesMessage(ValueError, msg):
+            with self.subTest(empty_expressions), self.assertRaisesMessage(
+                ValueError, msg
+            ):
                 ExclusionConstraint(
-                    index_type='GIST',
-                    name='exclude_empty_expressions',
+                    index_type="GIST",
+                    name="exclude_empty_expressions",
                     expressions=empty_expressions,
                 )
 
     def test_invalid_deferrable(self):
-        msg = 'ExclusionConstraint.deferrable must be a Deferrable instance.'
+        msg = "ExclusionConstraint.deferrable must be a Deferrable instance."
         with self.assertRaisesMessage(ValueError, msg):
             ExclusionConstraint(
-                name='exclude_invalid_deferrable',
-                expressions=[(F('datespan'), RangeOperators.OVERLAPS)],
-                deferrable='invalid',
+                name="exclude_invalid_deferrable",
+                expressions=[(F("datespan"), RangeOperators.OVERLAPS)],
+                deferrable="invalid",
             )
 
     def test_deferrable_with_condition(self):
-        msg = 'ExclusionConstraint with conditions cannot be deferred.'
+        msg = "ExclusionConstraint with conditions cannot be deferred."
         with self.assertRaisesMessage(ValueError, msg):
             ExclusionConstraint(
-                name='exclude_invalid_condition',
-                expressions=[(F('datespan'), RangeOperators.OVERLAPS)],
+                name="exclude_invalid_condition",
+                expressions=[(F("datespan"), RangeOperators.OVERLAPS)],
                 condition=Q(cancelled=False),
                 deferrable=Deferrable.DEFERRED,
             )
 
     def test_invalid_include_type(self):
-        msg = 'ExclusionConstraint.include must be a list or tuple.'
+        msg = "ExclusionConstraint.include must be a list or tuple."
         with self.assertRaisesMessage(ValueError, msg):
             ExclusionConstraint(
-                name='exclude_invalid_include',
-                expressions=[(F('datespan'), RangeOperators.OVERLAPS)],
-                include='invalid',
+                name="exclude_invalid_include",
+                expressions=[(F("datespan"), RangeOperators.OVERLAPS)],
+                include="invalid",
             )
 
     @ignore_warnings(category=RemovedInDjango50Warning)
     def test_invalid_opclasses_type(self):
-        msg = 'ExclusionConstraint.opclasses must be a list or tuple.'
+        msg = "ExclusionConstraint.opclasses must be a list or tuple."
         with self.assertRaisesMessage(ValueError, msg):
             ExclusionConstraint(
-                name='exclude_invalid_opclasses',
-                expressions=[(F('datespan'), RangeOperators.OVERLAPS)],
-                opclasses='invalid',
+                name="exclude_invalid_opclasses",
+                expressions=[(F("datespan"), RangeOperators.OVERLAPS)],
+                opclasses="invalid",
             )
 
     @ignore_warnings(category=RemovedInDjango50Warning)
     def test_opclasses_and_expressions_same_length(self):
         msg = (
-            'ExclusionConstraint.expressions and '
-            'ExclusionConstraint.opclasses must have the same number of '
-            'elements.'
+            "ExclusionConstraint.expressions and "
+            "ExclusionConstraint.opclasses must have the same number of "
+            "elements."
         )
         with self.assertRaisesMessage(ValueError, msg):
             ExclusionConstraint(
-                name='exclude_invalid_expressions_opclasses_length',
-                expressions=[(F('datespan'), RangeOperators.OVERLAPS)],
-                opclasses=['foo', 'bar'],
+                name="exclude_invalid_expressions_opclasses_length",
+                expressions=[(F("datespan"), RangeOperators.OVERLAPS)],
+                opclasses=["foo", "bar"],
             )
 
     def test_repr(self):
         constraint = ExclusionConstraint(
-            name='exclude_overlapping',
+            name="exclude_overlapping",
             expressions=[
-                (F('datespan'), RangeOperators.OVERLAPS),
-                (F('room'), RangeOperators.EQUAL),
+                (F("datespan"), RangeOperators.OVERLAPS),
+                (F("room"), RangeOperators.EQUAL),
             ],
         )
         self.assertEqual(
@@ -311,10 +323,10 @@ class ExclusionConstraintTests(PostgreSQLTestCase):
             "(F(datespan), '&&'), (F(room), '=')] name='exclude_overlapping'>",
         )
         constraint = ExclusionConstraint(
-            name='exclude_overlapping',
-            expressions=[(F('datespan'), RangeOperators.ADJACENT_TO)],
+            name="exclude_overlapping",
+            expressions=[(F("datespan"), RangeOperators.ADJACENT_TO)],
             condition=Q(cancelled=False),
-            index_type='SPGiST',
+            index_type="SPGiST",
         )
         self.assertEqual(
             repr(constraint),
@@ -323,8 +335,8 @@ class ExclusionConstraintTests(PostgreSQLTestCase):
             "condition=(AND: ('cancelled', False))>",
         )
         constraint = ExclusionConstraint(
-            name='exclude_overlapping',
-            expressions=[(F('datespan'), RangeOperators.ADJACENT_TO)],
+            name="exclude_overlapping",
+            expressions=[(F("datespan"), RangeOperators.ADJACENT_TO)],
             deferrable=Deferrable.IMMEDIATE,
         )
         self.assertEqual(
@@ -334,9 +346,9 @@ class ExclusionConstraintTests(PostgreSQLTestCase):
             "deferrable=Deferrable.IMMEDIATE>",
         )
         constraint = ExclusionConstraint(
-            name='exclude_overlapping',
-            expressions=[(F('datespan'), RangeOperators.ADJACENT_TO)],
-            include=['cancelled', 'room'],
+            name="exclude_overlapping",
+            expressions=[(F("datespan"), RangeOperators.ADJACENT_TO)],
+            include=["cancelled", "room"],
         )
         self.assertEqual(
             repr(constraint),
@@ -345,9 +357,9 @@ class ExclusionConstraintTests(PostgreSQLTestCase):
             "include=('cancelled', 'room')>",
         )
         constraint = ExclusionConstraint(
-            name='exclude_overlapping',
+            name="exclude_overlapping",
             expressions=[
-                (OpClass('datespan', name='range_ops'), RangeOperators.ADJACENT_TO),
+                (OpClass("datespan", name="range_ops"), RangeOperators.ADJACENT_TO),
             ],
         )
         self.assertEqual(
@@ -359,75 +371,75 @@ class ExclusionConstraintTests(PostgreSQLTestCase):
 
     def test_eq(self):
         constraint_1 = ExclusionConstraint(
-            name='exclude_overlapping',
+            name="exclude_overlapping",
             expressions=[
-                (F('datespan'), RangeOperators.OVERLAPS),
-                (F('room'), RangeOperators.EQUAL),
+                (F("datespan"), RangeOperators.OVERLAPS),
+                (F("room"), RangeOperators.EQUAL),
             ],
             condition=Q(cancelled=False),
         )
         constraint_2 = ExclusionConstraint(
-            name='exclude_overlapping',
+            name="exclude_overlapping",
             expressions=[
-                ('datespan', RangeOperators.OVERLAPS),
-                ('room', RangeOperators.EQUAL),
+                ("datespan", RangeOperators.OVERLAPS),
+                ("room", RangeOperators.EQUAL),
             ],
         )
         constraint_3 = ExclusionConstraint(
-            name='exclude_overlapping',
-            expressions=[('datespan', RangeOperators.OVERLAPS)],
+            name="exclude_overlapping",
+            expressions=[("datespan", RangeOperators.OVERLAPS)],
             condition=Q(cancelled=False),
         )
         constraint_4 = ExclusionConstraint(
-            name='exclude_overlapping',
+            name="exclude_overlapping",
             expressions=[
-                ('datespan', RangeOperators.OVERLAPS),
-                ('room', RangeOperators.EQUAL),
+                ("datespan", RangeOperators.OVERLAPS),
+                ("room", RangeOperators.EQUAL),
             ],
             deferrable=Deferrable.DEFERRED,
         )
         constraint_5 = ExclusionConstraint(
-            name='exclude_overlapping',
+            name="exclude_overlapping",
             expressions=[
-                ('datespan', RangeOperators.OVERLAPS),
-                ('room', RangeOperators.EQUAL),
+                ("datespan", RangeOperators.OVERLAPS),
+                ("room", RangeOperators.EQUAL),
             ],
             deferrable=Deferrable.IMMEDIATE,
         )
         constraint_6 = ExclusionConstraint(
-            name='exclude_overlapping',
+            name="exclude_overlapping",
             expressions=[
-                ('datespan', RangeOperators.OVERLAPS),
-                ('room', RangeOperators.EQUAL),
+                ("datespan", RangeOperators.OVERLAPS),
+                ("room", RangeOperators.EQUAL),
             ],
             deferrable=Deferrable.IMMEDIATE,
-            include=['cancelled'],
+            include=["cancelled"],
         )
         constraint_7 = ExclusionConstraint(
-            name='exclude_overlapping',
+            name="exclude_overlapping",
             expressions=[
-                ('datespan', RangeOperators.OVERLAPS),
-                ('room', RangeOperators.EQUAL),
+                ("datespan", RangeOperators.OVERLAPS),
+                ("room", RangeOperators.EQUAL),
             ],
-            include=['cancelled'],
+            include=["cancelled"],
         )
         with ignore_warnings(category=RemovedInDjango50Warning):
             constraint_8 = ExclusionConstraint(
-                name='exclude_overlapping',
+                name="exclude_overlapping",
                 expressions=[
-                    ('datespan', RangeOperators.OVERLAPS),
-                    ('room', RangeOperators.EQUAL),
+                    ("datespan", RangeOperators.OVERLAPS),
+                    ("room", RangeOperators.EQUAL),
                 ],
-                include=['cancelled'],
-                opclasses=['range_ops', 'range_ops']
+                include=["cancelled"],
+                opclasses=["range_ops", "range_ops"],
             )
             constraint_9 = ExclusionConstraint(
-                name='exclude_overlapping',
+                name="exclude_overlapping",
                 expressions=[
-                    ('datespan', RangeOperators.OVERLAPS),
-                    ('room', RangeOperators.EQUAL),
+                    ("datespan", RangeOperators.OVERLAPS),
+                    ("room", RangeOperators.EQUAL),
                 ],
-                opclasses=['range_ops', 'range_ops']
+                opclasses=["range_ops", "range_ops"],
             )
             self.assertNotEqual(constraint_2, constraint_9)
             self.assertNotEqual(constraint_7, constraint_8)
@@ -445,99 +457,151 @@ class ExclusionConstraintTests(PostgreSQLTestCase):
 
     def test_deconstruct(self):
         constraint = ExclusionConstraint(
-            name='exclude_overlapping',
-            expressions=[('datespan', RangeOperators.OVERLAPS), ('room', RangeOperators.EQUAL)],
+            name="exclude_overlapping",
+            expressions=[
+                ("datespan", RangeOperators.OVERLAPS),
+                ("room", RangeOperators.EQUAL),
+            ],
         )
         path, args, kwargs = constraint.deconstruct()
-        self.assertEqual(path, 'django.contrib.postgres.constraints.ExclusionConstraint')
+        self.assertEqual(
+            path, "django.contrib.postgres.constraints.ExclusionConstraint"
+        )
         self.assertEqual(args, ())
-        self.assertEqual(kwargs, {
-            'name': 'exclude_overlapping',
-            'expressions': [('datespan', RangeOperators.OVERLAPS), ('room', RangeOperators.EQUAL)],
-        })
+        self.assertEqual(
+            kwargs,
+            {
+                "name": "exclude_overlapping",
+                "expressions": [
+                    ("datespan", RangeOperators.OVERLAPS),
+                    ("room", RangeOperators.EQUAL),
+                ],
+            },
+        )
 
     def test_deconstruct_index_type(self):
         constraint = ExclusionConstraint(
-            name='exclude_overlapping',
-            index_type='SPGIST',
-            expressions=[('datespan', RangeOperators.OVERLAPS), ('room', RangeOperators.EQUAL)],
+            name="exclude_overlapping",
+            index_type="SPGIST",
+            expressions=[
+                ("datespan", RangeOperators.OVERLAPS),
+                ("room", RangeOperators.EQUAL),
+            ],
         )
         path, args, kwargs = constraint.deconstruct()
-        self.assertEqual(path, 'django.contrib.postgres.constraints.ExclusionConstraint')
+        self.assertEqual(
+            path, "django.contrib.postgres.constraints.ExclusionConstraint"
+        )
         self.assertEqual(args, ())
-        self.assertEqual(kwargs, {
-            'name': 'exclude_overlapping',
-            'index_type': 'SPGIST',
-            'expressions': [('datespan', RangeOperators.OVERLAPS), ('room', RangeOperators.EQUAL)],
-        })
+        self.assertEqual(
+            kwargs,
+            {
+                "name": "exclude_overlapping",
+                "index_type": "SPGIST",
+                "expressions": [
+                    ("datespan", RangeOperators.OVERLAPS),
+                    ("room", RangeOperators.EQUAL),
+                ],
+            },
+        )
 
     def test_deconstruct_condition(self):
         constraint = ExclusionConstraint(
-            name='exclude_overlapping',
-            expressions=[('datespan', RangeOperators.OVERLAPS), ('room', RangeOperators.EQUAL)],
+            name="exclude_overlapping",
+            expressions=[
+                ("datespan", RangeOperators.OVERLAPS),
+                ("room", RangeOperators.EQUAL),
+            ],
             condition=Q(cancelled=False),
         )
         path, args, kwargs = constraint.deconstruct()
-        self.assertEqual(path, 'django.contrib.postgres.constraints.ExclusionConstraint')
+        self.assertEqual(
+            path, "django.contrib.postgres.constraints.ExclusionConstraint"
+        )
         self.assertEqual(args, ())
-        self.assertEqual(kwargs, {
-            'name': 'exclude_overlapping',
-            'expressions': [('datespan', RangeOperators.OVERLAPS), ('room', RangeOperators.EQUAL)],
-            'condition': Q(cancelled=False),
-        })
+        self.assertEqual(
+            kwargs,
+            {
+                "name": "exclude_overlapping",
+                "expressions": [
+                    ("datespan", RangeOperators.OVERLAPS),
+                    ("room", RangeOperators.EQUAL),
+                ],
+                "condition": Q(cancelled=False),
+            },
+        )
 
     def test_deconstruct_deferrable(self):
         constraint = ExclusionConstraint(
-            name='exclude_overlapping',
-            expressions=[('datespan', RangeOperators.OVERLAPS)],
+            name="exclude_overlapping",
+            expressions=[("datespan", RangeOperators.OVERLAPS)],
             deferrable=Deferrable.DEFERRED,
         )
         path, args, kwargs = constraint.deconstruct()
-        self.assertEqual(path, 'django.contrib.postgres.constraints.ExclusionConstraint')
+        self.assertEqual(
+            path, "django.contrib.postgres.constraints.ExclusionConstraint"
+        )
         self.assertEqual(args, ())
-        self.assertEqual(kwargs, {
-            'name': 'exclude_overlapping',
-            'expressions': [('datespan', RangeOperators.OVERLAPS)],
-            'deferrable': Deferrable.DEFERRED,
-        })
+        self.assertEqual(
+            kwargs,
+            {
+                "name": "exclude_overlapping",
+                "expressions": [("datespan", RangeOperators.OVERLAPS)],
+                "deferrable": Deferrable.DEFERRED,
+            },
+        )
 
     def test_deconstruct_include(self):
         constraint = ExclusionConstraint(
-            name='exclude_overlapping',
-            expressions=[('datespan', RangeOperators.OVERLAPS)],
-            include=['cancelled', 'room'],
+            name="exclude_overlapping",
+            expressions=[("datespan", RangeOperators.OVERLAPS)],
+            include=["cancelled", "room"],
         )
         path, args, kwargs = constraint.deconstruct()
-        self.assertEqual(path, 'django.contrib.postgres.constraints.ExclusionConstraint')
+        self.assertEqual(
+            path, "django.contrib.postgres.constraints.ExclusionConstraint"
+        )
         self.assertEqual(args, ())
-        self.assertEqual(kwargs, {
-            'name': 'exclude_overlapping',
-            'expressions': [('datespan', RangeOperators.OVERLAPS)],
-            'include': ('cancelled', 'room'),
-        })
+        self.assertEqual(
+            kwargs,
+            {
+                "name": "exclude_overlapping",
+                "expressions": [("datespan", RangeOperators.OVERLAPS)],
+                "include": ("cancelled", "room"),
+            },
+        )
 
     @ignore_warnings(category=RemovedInDjango50Warning)
     def test_deconstruct_opclasses(self):
         constraint = ExclusionConstraint(
-            name='exclude_overlapping',
-            expressions=[('datespan', RangeOperators.OVERLAPS)],
-            opclasses=['range_ops'],
+            name="exclude_overlapping",
+            expressions=[("datespan", RangeOperators.OVERLAPS)],
+            opclasses=["range_ops"],
         )
         path, args, kwargs = constraint.deconstruct()
-        self.assertEqual(path, 'django.contrib.postgres.constraints.ExclusionConstraint')
+        self.assertEqual(
+            path, "django.contrib.postgres.constraints.ExclusionConstraint"
+        )
         self.assertEqual(args, ())
-        self.assertEqual(kwargs, {
-            'name': 'exclude_overlapping',
-            'expressions': [('datespan', RangeOperators.OVERLAPS)],
-            'opclasses': ['range_ops'],
-        })
+        self.assertEqual(
+            kwargs,
+            {
+                "name": "exclude_overlapping",
+                "expressions": [("datespan", RangeOperators.OVERLAPS)],
+                "opclasses": ["range_ops"],
+            },
+        )
 
     def _test_range_overlaps(self, constraint):
         # Create exclusion constraint.
-        self.assertNotIn(constraint.name, self.get_constraints(HotelReservation._meta.db_table))
+        self.assertNotIn(
+            constraint.name, self.get_constraints(HotelReservation._meta.db_table)
+        )
         with connection.schema_editor() as editor:
             editor.add_constraint(HotelReservation, constraint)
-        self.assertIn(constraint.name, self.get_constraints(HotelReservation._meta.db_table))
+        self.assertIn(
+            constraint.name, self.get_constraints(HotelReservation._meta.db_table)
+        )
         # Add initial reservations.
         room101 = Room.objects.create(number=101)
         room102 = Room.objects.create(number=102)
@@ -570,61 +634,63 @@ class ExclusionConstraintTests(PostgreSQLTestCase):
             )
             reservation.save()
         # Valid range.
-        HotelReservation.objects.bulk_create([
-            # Other room.
-            HotelReservation(
-                datespan=(datetimes[1].date(), datetimes[2].date()),
-                start=datetimes[1],
-                end=datetimes[2],
-                room=room101,
-            ),
-            # Cancelled reservation.
-            HotelReservation(
-                datespan=(datetimes[1].date(), datetimes[1].date()),
-                start=datetimes[1],
-                end=datetimes[2],
-                room=room102,
-                cancelled=True,
-            ),
-            # Other adjacent dates.
-            HotelReservation(
-                datespan=(datetimes[3].date(), datetimes[4].date()),
-                start=datetimes[3],
-                end=datetimes[4],
-                room=room102,
-            ),
-        ])
+        HotelReservation.objects.bulk_create(
+            [
+                # Other room.
+                HotelReservation(
+                    datespan=(datetimes[1].date(), datetimes[2].date()),
+                    start=datetimes[1],
+                    end=datetimes[2],
+                    room=room101,
+                ),
+                # Cancelled reservation.
+                HotelReservation(
+                    datespan=(datetimes[1].date(), datetimes[1].date()),
+                    start=datetimes[1],
+                    end=datetimes[2],
+                    room=room102,
+                    cancelled=True,
+                ),
+                # Other adjacent dates.
+                HotelReservation(
+                    datespan=(datetimes[3].date(), datetimes[4].date()),
+                    start=datetimes[3],
+                    end=datetimes[4],
+                    room=room102,
+                ),
+            ]
+        )
 
     @ignore_warnings(category=RemovedInDjango50Warning)
     def test_range_overlaps_custom_opclasses(self):
         class TsTzRange(Func):
-            function = 'TSTZRANGE'
+            function = "TSTZRANGE"
             output_field = DateTimeRangeField()
 
         constraint = ExclusionConstraint(
-            name='exclude_overlapping_reservations_custom',
+            name="exclude_overlapping_reservations_custom",
             expressions=[
-                (TsTzRange('start', 'end', RangeBoundary()), RangeOperators.OVERLAPS),
-                ('room', RangeOperators.EQUAL)
+                (TsTzRange("start", "end", RangeBoundary()), RangeOperators.OVERLAPS),
+                ("room", RangeOperators.EQUAL),
             ],
             condition=Q(cancelled=False),
-            opclasses=['range_ops', 'gist_int4_ops'],
+            opclasses=["range_ops", "gist_int4_ops"],
         )
         self._test_range_overlaps(constraint)
 
     def test_range_overlaps_custom(self):
         class TsTzRange(Func):
-            function = 'TSTZRANGE'
+            function = "TSTZRANGE"
             output_field = DateTimeRangeField()
 
         constraint = ExclusionConstraint(
-            name='exclude_overlapping_reservations_custom_opclass',
+            name="exclude_overlapping_reservations_custom_opclass",
             expressions=[
                 (
-                    OpClass(TsTzRange('start', 'end', RangeBoundary()), 'range_ops'),
+                    OpClass(TsTzRange("start", "end", RangeBoundary()), "range_ops"),
                     RangeOperators.OVERLAPS,
                 ),
-                (OpClass('room', 'gist_int4_ops'), RangeOperators.EQUAL),
+                (OpClass("room", "gist_int4_ops"), RangeOperators.EQUAL),
             ],
             condition=Q(cancelled=False),
         )
@@ -632,21 +698,23 @@ class ExclusionConstraintTests(PostgreSQLTestCase):
 
     def test_range_overlaps(self):
         constraint = ExclusionConstraint(
-            name='exclude_overlapping_reservations',
+            name="exclude_overlapping_reservations",
             expressions=[
-                (F('datespan'), RangeOperators.OVERLAPS),
-                ('room', RangeOperators.EQUAL)
+                (F("datespan"), RangeOperators.OVERLAPS),
+                ("room", RangeOperators.EQUAL),
             ],
             condition=Q(cancelled=False),
         )
         self._test_range_overlaps(constraint)
 
     def test_range_adjacent(self):
-        constraint_name = 'ints_adjacent'
-        self.assertNotIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+        constraint_name = "ints_adjacent"
+        self.assertNotIn(
+            constraint_name, self.get_constraints(RangesModel._meta.db_table)
+        )
         constraint = ExclusionConstraint(
             name=constraint_name,
-            expressions=[('ints', RangeOperators.ADJACENT_TO)],
+            expressions=[("ints", RangeOperators.ADJACENT_TO)],
         )
         with connection.schema_editor() as editor:
             editor.add_constraint(RangesModel, constraint)
@@ -659,26 +727,28 @@ class ExclusionConstraintTests(PostgreSQLTestCase):
         # Drop the constraint.
         with connection.schema_editor() as editor:
             editor.remove_constraint(RangesModel, constraint)
-        self.assertNotIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+        self.assertNotIn(
+            constraint_name, self.get_constraints(RangesModel._meta.db_table)
+        )
 
     def test_expressions_with_params(self):
-        constraint_name = 'scene_left_equal'
+        constraint_name = "scene_left_equal"
         self.assertNotIn(constraint_name, self.get_constraints(Scene._meta.db_table))
         constraint = ExclusionConstraint(
             name=constraint_name,
-            expressions=[(Left('scene', 4), RangeOperators.EQUAL)],
+            expressions=[(Left("scene", 4), RangeOperators.EQUAL)],
         )
         with connection.schema_editor() as editor:
             editor.add_constraint(Scene, constraint)
         self.assertIn(constraint_name, self.get_constraints(Scene._meta.db_table))
 
     def test_expressions_with_key_transform(self):
-        constraint_name = 'exclude_overlapping_reservations_smoking'
+        constraint_name = "exclude_overlapping_reservations_smoking"
         constraint = ExclusionConstraint(
             name=constraint_name,
             expressions=[
-                (F('datespan'), RangeOperators.OVERLAPS),
-                (KeyTextTransform('smoking', 'requirements'), RangeOperators.EQUAL),
+                (F("datespan"), RangeOperators.OVERLAPS),
+                (KeyTextTransform("smoking", "requirements"), RangeOperators.EQUAL),
             ],
         )
         with connection.schema_editor() as editor:
@@ -689,10 +759,10 @@ class ExclusionConstraintTests(PostgreSQLTestCase):
         )
 
     def test_index_transform(self):
-        constraint_name = 'first_index_equal'
+        constraint_name = "first_index_equal"
         constraint = ExclusionConstraint(
             name=constraint_name,
-            expressions=[('field__0', RangeOperators.EQUAL)],
+            expressions=[("field__0", RangeOperators.EQUAL)],
         )
         with connection.schema_editor() as editor:
             editor.add_constraint(IntegerArrayModel, constraint)
@@ -702,11 +772,13 @@ class ExclusionConstraintTests(PostgreSQLTestCase):
         )
 
     def test_range_adjacent_initially_deferred(self):
-        constraint_name = 'ints_adjacent_deferred'
-        self.assertNotIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+        constraint_name = "ints_adjacent_deferred"
+        self.assertNotIn(
+            constraint_name, self.get_constraints(RangesModel._meta.db_table)
+        )
         constraint = ExclusionConstraint(
             name=constraint_name,
-            expressions=[('ints', RangeOperators.ADJACENT_TO)],
+            expressions=[("ints", RangeOperators.ADJACENT_TO)],
             deferrable=Deferrable.DEFERRED,
         )
         with connection.schema_editor() as editor:
@@ -718,21 +790,23 @@ class ExclusionConstraintTests(PostgreSQLTestCase):
         with self.assertRaises(IntegrityError):
             with transaction.atomic(), connection.cursor() as cursor:
                 quoted_name = connection.ops.quote_name(constraint_name)
-                cursor.execute('SET CONSTRAINTS %s IMMEDIATE' % quoted_name)
+                cursor.execute("SET CONSTRAINTS %s IMMEDIATE" % quoted_name)
         # Remove adjacent range before the end of transaction.
         adjacent_range.delete()
         RangesModel.objects.create(ints=(10, 19))
         RangesModel.objects.create(ints=(51, 60))
 
-    @skipUnlessDBFeature('supports_covering_gist_indexes')
+    @skipUnlessDBFeature("supports_covering_gist_indexes")
     def test_range_adjacent_gist_include(self):
-        constraint_name = 'ints_adjacent_gist_include'
-        self.assertNotIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+        constraint_name = "ints_adjacent_gist_include"
+        self.assertNotIn(
+            constraint_name, self.get_constraints(RangesModel._meta.db_table)
+        )
         constraint = ExclusionConstraint(
             name=constraint_name,
-            expressions=[('ints', RangeOperators.ADJACENT_TO)],
-            index_type='gist',
-            include=['decimals', 'ints'],
+            expressions=[("ints", RangeOperators.ADJACENT_TO)],
+            index_type="gist",
+            include=["decimals", "ints"],
         )
         with connection.schema_editor() as editor:
             editor.add_constraint(RangesModel, constraint)
@@ -743,15 +817,17 @@ class ExclusionConstraintTests(PostgreSQLTestCase):
         RangesModel.objects.create(ints=(10, 19))
         RangesModel.objects.create(ints=(51, 60))
 
-    @skipUnlessDBFeature('supports_covering_spgist_indexes')
+    @skipUnlessDBFeature("supports_covering_spgist_indexes")
     def test_range_adjacent_spgist_include(self):
-        constraint_name = 'ints_adjacent_spgist_include'
-        self.assertNotIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+        constraint_name = "ints_adjacent_spgist_include"
+        self.assertNotIn(
+            constraint_name, self.get_constraints(RangesModel._meta.db_table)
+        )
         constraint = ExclusionConstraint(
             name=constraint_name,
-            expressions=[('ints', RangeOperators.ADJACENT_TO)],
-            index_type='spgist',
-            include=['decimals', 'ints'],
+            expressions=[("ints", RangeOperators.ADJACENT_TO)],
+            index_type="spgist",
+            include=["decimals", "ints"],
         )
         with connection.schema_editor() as editor:
             editor.add_constraint(RangesModel, constraint)
@@ -762,60 +838,68 @@ class ExclusionConstraintTests(PostgreSQLTestCase):
         RangesModel.objects.create(ints=(10, 19))
         RangesModel.objects.create(ints=(51, 60))
 
-    @skipUnlessDBFeature('supports_covering_gist_indexes')
+    @skipUnlessDBFeature("supports_covering_gist_indexes")
     def test_range_adjacent_gist_include_condition(self):
-        constraint_name = 'ints_adjacent_gist_include_condition'
-        self.assertNotIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+        constraint_name = "ints_adjacent_gist_include_condition"
+        self.assertNotIn(
+            constraint_name, self.get_constraints(RangesModel._meta.db_table)
+        )
         constraint = ExclusionConstraint(
             name=constraint_name,
-            expressions=[('ints', RangeOperators.ADJACENT_TO)],
-            index_type='gist',
-            include=['decimals'],
+            expressions=[("ints", RangeOperators.ADJACENT_TO)],
+            index_type="gist",
+            include=["decimals"],
             condition=Q(id__gte=100),
         )
         with connection.schema_editor() as editor:
             editor.add_constraint(RangesModel, constraint)
         self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
 
-    @skipUnlessDBFeature('supports_covering_spgist_indexes')
+    @skipUnlessDBFeature("supports_covering_spgist_indexes")
     def test_range_adjacent_spgist_include_condition(self):
-        constraint_name = 'ints_adjacent_spgist_include_condition'
-        self.assertNotIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+        constraint_name = "ints_adjacent_spgist_include_condition"
+        self.assertNotIn(
+            constraint_name, self.get_constraints(RangesModel._meta.db_table)
+        )
         constraint = ExclusionConstraint(
             name=constraint_name,
-            expressions=[('ints', RangeOperators.ADJACENT_TO)],
-            index_type='spgist',
-            include=['decimals'],
+            expressions=[("ints", RangeOperators.ADJACENT_TO)],
+            index_type="spgist",
+            include=["decimals"],
             condition=Q(id__gte=100),
         )
         with connection.schema_editor() as editor:
             editor.add_constraint(RangesModel, constraint)
         self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
 
-    @skipUnlessDBFeature('supports_covering_gist_indexes')
+    @skipUnlessDBFeature("supports_covering_gist_indexes")
     def test_range_adjacent_gist_include_deferrable(self):
-        constraint_name = 'ints_adjacent_gist_include_deferrable'
-        self.assertNotIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+        constraint_name = "ints_adjacent_gist_include_deferrable"
+        self.assertNotIn(
+            constraint_name, self.get_constraints(RangesModel._meta.db_table)
+        )
         constraint = ExclusionConstraint(
             name=constraint_name,
-            expressions=[('ints', RangeOperators.ADJACENT_TO)],
-            index_type='gist',
-            include=['decimals'],
+            expressions=[("ints", RangeOperators.ADJACENT_TO)],
+            index_type="gist",
+            include=["decimals"],
             deferrable=Deferrable.DEFERRED,
         )
         with connection.schema_editor() as editor:
             editor.add_constraint(RangesModel, constraint)
         self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
 
-    @skipUnlessDBFeature('supports_covering_spgist_indexes')
+    @skipUnlessDBFeature("supports_covering_spgist_indexes")
     def test_range_adjacent_spgist_include_deferrable(self):
-        constraint_name = 'ints_adjacent_spgist_include_deferrable'
-        self.assertNotIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+        constraint_name = "ints_adjacent_spgist_include_deferrable"
+        self.assertNotIn(
+            constraint_name, self.get_constraints(RangesModel._meta.db_table)
+        )
         constraint = ExclusionConstraint(
             name=constraint_name,
-            expressions=[('ints', RangeOperators.ADJACENT_TO)],
-            index_type='spgist',
-            include=['decimals'],
+            expressions=[("ints", RangeOperators.ADJACENT_TO)],
+            index_type="spgist",
+            include=["decimals"],
             deferrable=Deferrable.DEFERRED,
         )
         with connection.schema_editor() as editor:
@@ -823,53 +907,55 @@ class ExclusionConstraintTests(PostgreSQLTestCase):
         self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
 
     def test_gist_include_not_supported(self):
-        constraint_name = 'ints_adjacent_gist_include_not_supported'
+        constraint_name = "ints_adjacent_gist_include_not_supported"
         constraint = ExclusionConstraint(
             name=constraint_name,
-            expressions=[('ints', RangeOperators.ADJACENT_TO)],
-            index_type='gist',
-            include=['id'],
+            expressions=[("ints", RangeOperators.ADJACENT_TO)],
+            index_type="gist",
+            include=["id"],
         )
         msg = (
-            'Covering exclusion constraints using a GiST index require '
-            'PostgreSQL 12+.'
+            "Covering exclusion constraints using a GiST index require "
+            "PostgreSQL 12+."
         )
         with connection.schema_editor() as editor:
             with mock.patch(
-                'django.db.backends.postgresql.features.DatabaseFeatures.supports_covering_gist_indexes',
+                "django.db.backends.postgresql.features.DatabaseFeatures.supports_covering_gist_indexes",
                 False,
             ):
                 with self.assertRaisesMessage(NotSupportedError, msg):
                     editor.add_constraint(RangesModel, constraint)
 
     def test_spgist_include_not_supported(self):
-        constraint_name = 'ints_adjacent_spgist_include_not_supported'
+        constraint_name = "ints_adjacent_spgist_include_not_supported"
         constraint = ExclusionConstraint(
             name=constraint_name,
-            expressions=[('ints', RangeOperators.ADJACENT_TO)],
-            index_type='spgist',
-            include=['id'],
+            expressions=[("ints", RangeOperators.ADJACENT_TO)],
+            index_type="spgist",
+            include=["id"],
         )
         msg = (
-            'Covering exclusion constraints using an SP-GiST index require '
-            'PostgreSQL 14+.'
+            "Covering exclusion constraints using an SP-GiST index require "
+            "PostgreSQL 14+."
         )
         with connection.schema_editor() as editor:
             with mock.patch(
-                'django.db.backends.postgresql.features.DatabaseFeatures.'
-                'supports_covering_spgist_indexes',
+                "django.db.backends.postgresql.features.DatabaseFeatures."
+                "supports_covering_spgist_indexes",
                 False,
             ):
                 with self.assertRaisesMessage(NotSupportedError, msg):
                     editor.add_constraint(RangesModel, constraint)
 
     def test_range_adjacent_opclass(self):
-        constraint_name = 'ints_adjacent_opclass'
-        self.assertNotIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+        constraint_name = "ints_adjacent_opclass"
+        self.assertNotIn(
+            constraint_name, self.get_constraints(RangesModel._meta.db_table)
+        )
         constraint = ExclusionConstraint(
             name=constraint_name,
             expressions=[
-                (OpClass('ints', name='range_ops'), RangeOperators.ADJACENT_TO),
+                (OpClass("ints", name="range_ops"), RangeOperators.ADJACENT_TO),
             ],
         )
         with connection.schema_editor() as editor:
@@ -880,7 +966,7 @@ class ExclusionConstraintTests(PostgreSQLTestCase):
             cursor.execute(SchemaTests.get_opclass_query, [constraint_name])
             self.assertEqual(
                 cursor.fetchall(),
-                [('range_ops', constraint_name)],
+                [("range_ops", constraint_name)],
             )
         RangesModel.objects.create(ints=(20, 50))
         with self.assertRaises(IntegrityError), transaction.atomic():
@@ -890,15 +976,19 @@ class ExclusionConstraintTests(PostgreSQLTestCase):
         # Drop the constraint.
         with connection.schema_editor() as editor:
             editor.remove_constraint(RangesModel, constraint)
-        self.assertNotIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+        self.assertNotIn(
+            constraint_name, self.get_constraints(RangesModel._meta.db_table)
+        )
 
     def test_range_adjacent_opclass_condition(self):
-        constraint_name = 'ints_adjacent_opclass_condition'
-        self.assertNotIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+        constraint_name = "ints_adjacent_opclass_condition"
+        self.assertNotIn(
+            constraint_name, self.get_constraints(RangesModel._meta.db_table)
+        )
         constraint = ExclusionConstraint(
             name=constraint_name,
             expressions=[
-                (OpClass('ints', name='range_ops'), RangeOperators.ADJACENT_TO),
+                (OpClass("ints", name="range_ops"), RangeOperators.ADJACENT_TO),
             ],
             condition=Q(id__gte=100),
         )
@@ -907,12 +997,14 @@ class ExclusionConstraintTests(PostgreSQLTestCase):
         self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
 
     def test_range_adjacent_opclass_deferrable(self):
-        constraint_name = 'ints_adjacent_opclass_deferrable'
-        self.assertNotIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+        constraint_name = "ints_adjacent_opclass_deferrable"
+        self.assertNotIn(
+            constraint_name, self.get_constraints(RangesModel._meta.db_table)
+        )
         constraint = ExclusionConstraint(
             name=constraint_name,
             expressions=[
-                (OpClass('ints', name='range_ops'), RangeOperators.ADJACENT_TO),
+                (OpClass("ints", name="range_ops"), RangeOperators.ADJACENT_TO),
             ],
             deferrable=Deferrable.DEFERRED,
         )
@@ -920,51 +1012,55 @@ class ExclusionConstraintTests(PostgreSQLTestCase):
             editor.add_constraint(RangesModel, constraint)
         self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
 
-    @skipUnlessDBFeature('supports_covering_gist_indexes')
+    @skipUnlessDBFeature("supports_covering_gist_indexes")
     def test_range_adjacent_gist_opclass_include(self):
-        constraint_name = 'ints_adjacent_gist_opclass_include'
-        self.assertNotIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+        constraint_name = "ints_adjacent_gist_opclass_include"
+        self.assertNotIn(
+            constraint_name, self.get_constraints(RangesModel._meta.db_table)
+        )
         constraint = ExclusionConstraint(
             name=constraint_name,
             expressions=[
-                (OpClass('ints', name='range_ops'), RangeOperators.ADJACENT_TO),
+                (OpClass("ints", name="range_ops"), RangeOperators.ADJACENT_TO),
             ],
-            index_type='gist',
-            include=['decimals'],
+            index_type="gist",
+            include=["decimals"],
         )
         with connection.schema_editor() as editor:
             editor.add_constraint(RangesModel, constraint)
         self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
 
-    @skipUnlessDBFeature('supports_covering_spgist_indexes')
+    @skipUnlessDBFeature("supports_covering_spgist_indexes")
     def test_range_adjacent_spgist_opclass_include(self):
-        constraint_name = 'ints_adjacent_spgist_opclass_include'
-        self.assertNotIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+        constraint_name = "ints_adjacent_spgist_opclass_include"
+        self.assertNotIn(
+            constraint_name, self.get_constraints(RangesModel._meta.db_table)
+        )
         constraint = ExclusionConstraint(
             name=constraint_name,
             expressions=[
-                (OpClass('ints', name='range_ops'), RangeOperators.ADJACENT_TO),
+                (OpClass("ints", name="range_ops"), RangeOperators.ADJACENT_TO),
             ],
-            index_type='spgist',
-            include=['decimals'],
+            index_type="spgist",
+            include=["decimals"],
         )
         with connection.schema_editor() as editor:
             editor.add_constraint(RangesModel, constraint)
         self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
 
     def test_range_equal_cast(self):
-        constraint_name = 'exclusion_equal_room_cast'
+        constraint_name = "exclusion_equal_room_cast"
         self.assertNotIn(constraint_name, self.get_constraints(Room._meta.db_table))
         constraint = ExclusionConstraint(
             name=constraint_name,
-            expressions=[(Cast('number', IntegerField()), RangeOperators.EQUAL)],
+            expressions=[(Cast("number", IntegerField()), RangeOperators.EQUAL)],
         )
         with connection.schema_editor() as editor:
             editor.add_constraint(Room, constraint)
         self.assertIn(constraint_name, self.get_constraints(Room._meta.db_table))
 
 
-@modify_settings(INSTALLED_APPS={'append': 'django.contrib.postgres'})
+@modify_settings(INSTALLED_APPS={"append": "django.contrib.postgres"})
 class ExclusionConstraintOpclassesDepracationTests(PostgreSQLTestCase):
     def get_constraints(self, table):
         """Get the constraints on the table using a new cursor."""
@@ -973,23 +1069,23 @@ class ExclusionConstraintOpclassesDepracationTests(PostgreSQLTestCase):
 
     def test_warning(self):
         msg = (
-            'The opclasses argument is deprecated in favor of using '
-            'django.contrib.postgres.indexes.OpClass in '
-            'ExclusionConstraint.expressions.'
+            "The opclasses argument is deprecated in favor of using "
+            "django.contrib.postgres.indexes.OpClass in "
+            "ExclusionConstraint.expressions."
         )
         with self.assertWarnsMessage(RemovedInDjango50Warning, msg):
             ExclusionConstraint(
-                name='exclude_overlapping',
-                expressions=[(F('datespan'), RangeOperators.ADJACENT_TO)],
-                opclasses=['range_ops'],
+                name="exclude_overlapping",
+                expressions=[(F("datespan"), RangeOperators.ADJACENT_TO)],
+                opclasses=["range_ops"],
             )
 
     @ignore_warnings(category=RemovedInDjango50Warning)
     def test_repr(self):
         constraint = ExclusionConstraint(
-            name='exclude_overlapping',
-            expressions=[(F('datespan'), RangeOperators.ADJACENT_TO)],
-            opclasses=['range_ops'],
+            name="exclude_overlapping",
+            expressions=[(F("datespan"), RangeOperators.ADJACENT_TO)],
+            opclasses=["range_ops"],
         )
         self.assertEqual(
             repr(constraint),
@@ -1000,12 +1096,14 @@ class ExclusionConstraintOpclassesDepracationTests(PostgreSQLTestCase):
 
     @ignore_warnings(category=RemovedInDjango50Warning)
     def test_range_adjacent_opclasses(self):
-        constraint_name = 'ints_adjacent_opclasses'
-        self.assertNotIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+        constraint_name = "ints_adjacent_opclasses"
+        self.assertNotIn(
+            constraint_name, self.get_constraints(RangesModel._meta.db_table)
+        )
         constraint = ExclusionConstraint(
             name=constraint_name,
-            expressions=[('ints', RangeOperators.ADJACENT_TO)],
-            opclasses=['range_ops'],
+            expressions=[("ints", RangeOperators.ADJACENT_TO)],
+            opclasses=["range_ops"],
         )
         with connection.schema_editor() as editor:
             editor.add_constraint(RangesModel, constraint)
@@ -1015,7 +1113,7 @@ class ExclusionConstraintOpclassesDepracationTests(PostgreSQLTestCase):
             cursor.execute(SchemaTests.get_opclass_query, [constraint.name])
             self.assertEqual(
                 cursor.fetchall(),
-                [('range_ops', constraint.name)],
+                [("range_ops", constraint.name)],
             )
         RangesModel.objects.create(ints=(20, 50))
         with self.assertRaises(IntegrityError), transaction.atomic():
@@ -1025,16 +1123,20 @@ class ExclusionConstraintOpclassesDepracationTests(PostgreSQLTestCase):
         # Drop the constraint.
         with connection.schema_editor() as editor:
             editor.remove_constraint(RangesModel, constraint)
-        self.assertNotIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+        self.assertNotIn(
+            constraint_name, self.get_constraints(RangesModel._meta.db_table)
+        )
 
     @ignore_warnings(category=RemovedInDjango50Warning)
     def test_range_adjacent_opclasses_condition(self):
-        constraint_name = 'ints_adjacent_opclasses_condition'
-        self.assertNotIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+        constraint_name = "ints_adjacent_opclasses_condition"
+        self.assertNotIn(
+            constraint_name, self.get_constraints(RangesModel._meta.db_table)
+        )
         constraint = ExclusionConstraint(
             name=constraint_name,
-            expressions=[('ints', RangeOperators.ADJACENT_TO)],
-            opclasses=['range_ops'],
+            expressions=[("ints", RangeOperators.ADJACENT_TO)],
+            opclasses=["range_ops"],
             condition=Q(id__gte=100),
         )
         with connection.schema_editor() as editor:
@@ -1043,12 +1145,14 @@ class ExclusionConstraintOpclassesDepracationTests(PostgreSQLTestCase):
 
     @ignore_warnings(category=RemovedInDjango50Warning)
     def test_range_adjacent_opclasses_deferrable(self):
-        constraint_name = 'ints_adjacent_opclasses_deferrable'
-        self.assertNotIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+        constraint_name = "ints_adjacent_opclasses_deferrable"
+        self.assertNotIn(
+            constraint_name, self.get_constraints(RangesModel._meta.db_table)
+        )
         constraint = ExclusionConstraint(
             name=constraint_name,
-            expressions=[('ints', RangeOperators.ADJACENT_TO)],
-            opclasses=['range_ops'],
+            expressions=[("ints", RangeOperators.ADJACENT_TO)],
+            opclasses=["range_ops"],
             deferrable=Deferrable.DEFERRED,
         )
         with connection.schema_editor() as editor:
@@ -1056,32 +1160,36 @@ class ExclusionConstraintOpclassesDepracationTests(PostgreSQLTestCase):
         self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
 
     @ignore_warnings(category=RemovedInDjango50Warning)
-    @skipUnlessDBFeature('supports_covering_gist_indexes')
+    @skipUnlessDBFeature("supports_covering_gist_indexes")
     def test_range_adjacent_gist_opclasses_include(self):
-        constraint_name = 'ints_adjacent_gist_opclasses_include'
-        self.assertNotIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+        constraint_name = "ints_adjacent_gist_opclasses_include"
+        self.assertNotIn(
+            constraint_name, self.get_constraints(RangesModel._meta.db_table)
+        )
         constraint = ExclusionConstraint(
             name=constraint_name,
-            expressions=[('ints', RangeOperators.ADJACENT_TO)],
-            index_type='gist',
-            opclasses=['range_ops'],
-            include=['decimals'],
+            expressions=[("ints", RangeOperators.ADJACENT_TO)],
+            index_type="gist",
+            opclasses=["range_ops"],
+            include=["decimals"],
         )
         with connection.schema_editor() as editor:
             editor.add_constraint(RangesModel, constraint)
         self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
 
     @ignore_warnings(category=RemovedInDjango50Warning)
-    @skipUnlessDBFeature('supports_covering_spgist_indexes')
+    @skipUnlessDBFeature("supports_covering_spgist_indexes")
     def test_range_adjacent_spgist_opclasses_include(self):
-        constraint_name = 'ints_adjacent_spgist_opclasses_include'
-        self.assertNotIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+        constraint_name = "ints_adjacent_spgist_opclasses_include"
+        self.assertNotIn(
+            constraint_name, self.get_constraints(RangesModel._meta.db_table)
+        )
         constraint = ExclusionConstraint(
             name=constraint_name,
-            expressions=[('ints', RangeOperators.ADJACENT_TO)],
-            index_type='spgist',
-            opclasses=['range_ops'],
-            include=['decimals'],
+            expressions=[("ints", RangeOperators.ADJACENT_TO)],
+            index_type="spgist",
+            opclasses=["range_ops"],
+            include=["decimals"],
         )
         with connection.schema_editor() as editor:
             editor.add_constraint(RangesModel, constraint)