Run black -l 79 against all source files

This is a straight reformat run using black as is, with no edits
applied at all.

The black run will format code consistently, however in
some cases that are prevalent in SQLAlchemy code it produces
too-long lines.   The too-long lines will be resolved in the
following commit that will resolve all remaining flake8 issues
including shadowed builtins, long lines, import order, unused
imports, duplicate imports, and docstring issues.

Change-Id: I7eda77fed3d8e73df84b3651fd6cfcfe858d4dc9

1 files changed, 251 insertions, 204 deletions

diff --git a/test/ext/test_mutable.py b/test/ext/test_mutable.py
index 654a85e74..d46ace9a8 100644
--- a/test/ext/test_mutable.py
+++ b/test/ext/test_mutable.py
@@ -23,7 +23,6 @@ class SubFoo(Foo):
 
 
 class FooWithEq(object):
-
     def __init__(self, **kw):
         for k in kw:
             setattr(self, k, kw[k])
@@ -36,7 +35,6 @@ class FooWithEq(object):
 
 
 class Point(MutableComposite):
-
     def __init__(self, x, y):
         self.x = x
         self.y = y
@@ -55,13 +53,14 @@ class Point(MutableComposite):
         self.x, self.y = state
 
     def __eq__(self, other):
-        return isinstance(other, Point) and \
-            other.x == self.x and \
-            other.y == self.y
+        return (
+            isinstance(other, Point)
+            and other.x == self.x
+            and other.y == self.y
+        )
 
 
 class MyPoint(Point):
-
     @classmethod
     def coerce(cls, key, value):
         if isinstance(value, tuple):
@@ -82,7 +81,7 @@ class _MutableDictTestFixture(object):
 
 
 class _MutableDictTestBase(_MutableDictTestFixture):
-    run_define_tables = 'each'
+    run_define_tables = "each"
 
     def setup_mappers(cls):
         foo = cls.tables.foo
@@ -100,20 +99,21 @@ class _MutableDictTestBase(_MutableDictTestFixture):
         assert_raises_message(
             ValueError,
             "Attribute 'data' does not accept objects of type",
-            Foo, data=set([1, 2, 3])
+            Foo,
+            data=set([1, 2, 3]),
         )
 
     def test_in_place_mutation(self):
         sess = Session()
 
-        f1 = Foo(data={'a': 'b'})
+        f1 = Foo(data={"a": "b"})
         sess.add(f1)
         sess.commit()
 
-        f1.data['a'] = 'c'
+        f1.data["a"] = "c"
         sess.commit()
 
-        eq_(f1.data, {'a': 'c'})
+        eq_(f1.data, {"a": "c"})
 
     def test_modified_event(self):
         canary = mock.Mock()
@@ -124,14 +124,17 @@ class _MutableDictTestBase(_MutableDictTestFixture):
 
         eq_(
             canary.mock_calls,
-            [mock.call(
-                f1, attributes.Event(Foo.data.impl, attributes.OP_MODIFIED))]
+            [
+                mock.call(
+                    f1, attributes.Event(Foo.data.impl, attributes.OP_MODIFIED)
+                )
+            ],
         )
 
     def test_clear(self):
         sess = Session()
 
-        f1 = Foo(data={'a': 'b'})
+        f1 = Foo(data={"a": "b"})
         sess.add(f1)
         sess.commit()
 
@@ -143,46 +146,46 @@ class _MutableDictTestBase(_MutableDictTestFixture):
     def test_update(self):
         sess = Session()
 
-        f1 = Foo(data={'a': 'b'})
+        f1 = Foo(data={"a": "b"})
         sess.add(f1)
         sess.commit()
 
-        f1.data.update({'a': 'z'})
+        f1.data.update({"a": "z"})
         sess.commit()
 
-        eq_(f1.data, {'a': 'z'})
+        eq_(f1.data, {"a": "z"})
 
     def test_pop(self):
         sess = Session()
 
-        f1 = Foo(data={'a': 'b', 'c': 'd'})
+        f1 = Foo(data={"a": "b", "c": "d"})
         sess.add(f1)
         sess.commit()
 
-        eq_(f1.data.pop('a'), 'b')
+        eq_(f1.data.pop("a"), "b")
         sess.commit()
 
-        assert_raises(KeyError, f1.data.pop, 'g')
+        assert_raises(KeyError, f1.data.pop, "g")
 
-        eq_(f1.data, {'c': 'd'})
+        eq_(f1.data, {"c": "d"})
 
     def test_pop_default(self):
         sess = Session()
 
-        f1 = Foo(data={'a': 'b', 'c': 'd'})
+        f1 = Foo(data={"a": "b", "c": "d"})
         sess.add(f1)
         sess.commit()
 
-        eq_(f1.data.pop('a', 'q'), 'b')
-        eq_(f1.data.pop('a', 'q'), 'q')
+        eq_(f1.data.pop("a", "q"), "b")
+        eq_(f1.data.pop("a", "q"), "q")
         sess.commit()
 
-        eq_(f1.data, {'c': 'd'})
+        eq_(f1.data, {"c": "d"})
 
     def test_popitem(self):
         sess = Session()
 
-        orig = {'a': 'b', 'c': 'd'}
+        orig = {"a": "b", "c": "d"}
 
         # the orig dict remains unchanged when we assign,
         # but just making this future-proof
@@ -192,7 +195,7 @@ class _MutableDictTestBase(_MutableDictTestFixture):
         sess.commit()
 
         k, v = f1.data.popitem()
-        assert k in ('a', 'c')
+        assert k in ("a", "c")
         orig.pop(k)
 
         sess.commit()
@@ -202,45 +205,45 @@ class _MutableDictTestBase(_MutableDictTestFixture):
     def test_setdefault(self):
         sess = Session()
 
-        f1 = Foo(data={'a': 'b'})
+        f1 = Foo(data={"a": "b"})
         sess.add(f1)
         sess.commit()
 
-        eq_(f1.data.setdefault('c', 'd'), 'd')
+        eq_(f1.data.setdefault("c", "d"), "d")
         sess.commit()
 
-        eq_(f1.data, {'a': 'b', 'c': 'd'})
+        eq_(f1.data, {"a": "b", "c": "d"})
 
-        eq_(f1.data.setdefault('c', 'q'), 'd')
+        eq_(f1.data.setdefault("c", "q"), "d")
         sess.commit()
 
-        eq_(f1.data, {'a': 'b', 'c': 'd'})
+        eq_(f1.data, {"a": "b", "c": "d"})
 
     def test_replace(self):
         sess = Session()
-        f1 = Foo(data={'a': 'b'})
+        f1 = Foo(data={"a": "b"})
         sess.add(f1)
         sess.flush()
 
-        f1.data = {'b': 'c'}
+        f1.data = {"b": "c"}
         sess.commit()
-        eq_(f1.data, {'b': 'c'})
+        eq_(f1.data, {"b": "c"})
 
     def test_replace_itself_still_ok(self):
         sess = Session()
-        f1 = Foo(data={'a': 'b'})
+        f1 = Foo(data={"a": "b"})
         sess.add(f1)
         sess.flush()
 
         f1.data = f1.data
-        f1.data['b'] = 'c'
+        f1.data["b"] = "c"
         sess.commit()
-        eq_(f1.data, {'a': 'b', 'b': 'c'})
+        eq_(f1.data, {"a": "b", "b": "c"})
 
     def test_pickle_parent(self):
         sess = Session()
 
-        f1 = Foo(data={'a': 'b'})
+        f1 = Foo(data={"a": "b"})
         sess.add(f1)
         sess.commit()
         f1.data
@@ -250,7 +253,7 @@ class _MutableDictTestBase(_MutableDictTestFixture):
             sess = Session()
             f2 = loads(dumps(f1))
             sess.add(f2)
-            f2.data['a'] = 'c'
+            f2.data["a"] = "c"
             assert f2 in sess.dirty
 
     def test_unrelated_flush(self):
@@ -267,14 +270,14 @@ class _MutableDictTestBase(_MutableDictTestFixture):
     def _test_non_mutable(self):
         sess = Session()
 
-        f1 = Foo(non_mutable_data={'a': 'b'})
+        f1 = Foo(non_mutable_data={"a": "b"})
         sess.add(f1)
         sess.commit()
 
-        f1.non_mutable_data['a'] = 'c'
+        f1.non_mutable_data["a"] = "c"
         sess.commit()
 
-        eq_(f1.non_mutable_data, {'a': 'b'})
+        eq_(f1.non_mutable_data, {"a": "b"})
 
 
 class _MutableListTestFixture(object):
@@ -290,7 +293,7 @@ class _MutableListTestFixture(object):
 
 
 class _MutableListTestBase(_MutableListTestFixture):
-    run_define_tables = 'each'
+    run_define_tables = "each"
 
     def setup_mappers(cls):
         foo = cls.tables.foo
@@ -308,7 +311,8 @@ class _MutableListTestBase(_MutableListTestFixture):
         assert_raises_message(
             ValueError,
             "Attribute 'data' does not accept objects of type",
-            Foo, data=set([1, 2, 3])
+            Foo,
+            data=set([1, 2, 3]),
         )
 
     def test_in_place_mutation(self):
@@ -348,7 +352,7 @@ class _MutableListTestBase(_MutableListTestFixture):
         eq_(f1.data, [1, 4])
 
     def test_clear(self):
-        if not hasattr(list, 'clear'):
+        if not hasattr(list, "clear"):
             # py2 list doesn't have 'clear'
             return
         sess = Session()
@@ -502,7 +506,7 @@ class _MutableSetTestFixture(object):
 
 
 class _MutableSetTestBase(_MutableSetTestFixture):
-    run_define_tables = 'each'
+    run_define_tables = "each"
 
     def setup_mappers(cls):
         foo = cls.tables.foo
@@ -520,7 +524,8 @@ class _MutableSetTestBase(_MutableSetTestFixture):
         assert_raises_message(
             ValueError,
             "Attribute 'data' does not accept objects of type",
-            Foo, data=[1, 2, 3]
+            Foo,
+            data=[1, 2, 3],
         )
 
     def test_clear(self):
@@ -721,11 +726,12 @@ class MutableColumnDefaultTest(_MutableDictTestFixture, fixtures.MappedTest):
 
         mutable_pickle = MutableDict.as_mutable(PickleType)
         Table(
-            'foo', metadata,
+            "foo",
+            metadata,
             Column(
-                'id', Integer, primary_key=True,
-                test_needs_autoincrement=True),
-            Column('data', mutable_pickle, default={}),
+                "id", Integer, primary_key=True, test_needs_autoincrement=True
+            ),
+            Column("data", mutable_pickle, default={}),
         )
 
     def setup_mappers(cls):
@@ -743,32 +749,33 @@ class MutableColumnDefaultTest(_MutableDictTestFixture, fixtures.MappedTest):
         sess.flush()
         assert isinstance(f1.data, self._type_fixture())
         assert f1 not in sess.dirty
-        f1.data['foo'] = 'bar'
+        f1.data["foo"] = "bar"
         assert f1 in sess.dirty
 
 
 class MutableWithScalarPickleTest(_MutableDictTestBase, fixtures.MappedTest):
-
     @classmethod
     def define_tables(cls, metadata):
         MutableDict = cls._type_fixture()
 
         mutable_pickle = MutableDict.as_mutable(PickleType)
-        Table('foo', metadata,
-              Column('id', Integer, primary_key=True,
-                     test_needs_autoincrement=True),
-              Column('skip', mutable_pickle),
-              Column('data', mutable_pickle),
-              Column('non_mutable_data', PickleType),
-              Column('unrelated_data', String(50))
-              )
+        Table(
+            "foo",
+            metadata,
+            Column(
+                "id", Integer, primary_key=True, test_needs_autoincrement=True
+            ),
+            Column("skip", mutable_pickle),
+            Column("data", mutable_pickle),
+            Column("non_mutable_data", PickleType),
+            Column("unrelated_data", String(50)),
+        )
 
     def test_non_mutable(self):
         self._test_non_mutable()
 
 
 class MutableWithScalarJSONTest(_MutableDictTestBase, fixtures.MappedTest):
-
     @classmethod
     def define_tables(cls, metadata):
         import json
@@ -789,13 +796,16 @@ class MutableWithScalarJSONTest(_MutableDictTestBase, fixtures.MappedTest):
 
         MutableDict = cls._type_fixture()
 
-        Table('foo', metadata,
-              Column('id', Integer, primary_key=True,
-                     test_needs_autoincrement=True),
-              Column('data', MutableDict.as_mutable(JSONEncodedDict)),
-              Column('non_mutable_data', JSONEncodedDict),
-              Column('unrelated_data', String(50))
-              )
+        Table(
+            "foo",
+            metadata,
+            Column(
+                "id", Integer, primary_key=True, test_needs_autoincrement=True
+            ),
+            Column("data", MutableDict.as_mutable(JSONEncodedDict)),
+            Column("non_mutable_data", JSONEncodedDict),
+            Column("unrelated_data", String(50)),
+        )
 
     def test_non_mutable(self):
         self._test_non_mutable()
@@ -807,13 +817,10 @@ class MutableIncludeNonPrimaryTest(MutableWithScalarJSONTest):
         foo = cls.tables.foo
 
         mapper(Foo, foo)
-        mapper(Foo, foo, non_primary=True, properties={
-            "foo_bar": foo.c.data
-        })
+        mapper(Foo, foo, non_primary=True, properties={"foo_bar": foo.c.data})
 
 
 class MutableColumnCopyJSONTest(_MutableDictTestBase, fixtures.MappedTest):
-
     @classmethod
     def define_tables(cls, metadata):
         import json
@@ -840,8 +847,9 @@ class MutableColumnCopyJSONTest(_MutableDictTestBase, fixtures.MappedTest):
         class AbstractFoo(Base):
             __abstract__ = True
 
-            id = Column(Integer, primary_key=True,
-                        test_needs_autoincrement=True)
+            id = Column(
+                Integer, primary_key=True, test_needs_autoincrement=True
+            )
             data = Column(MutableDict.as_mutable(JSONEncodedDict))
             non_mutable_data = Column(JSONEncodedDict)
             unrelated_data = Column(String(50))
@@ -849,7 +857,8 @@ class MutableColumnCopyJSONTest(_MutableDictTestBase, fixtures.MappedTest):
         class Foo(AbstractFoo):
             __tablename__ = "foo"
             column_prop = column_property(
-                func.lower(AbstractFoo.unrelated_data))
+                func.lower(AbstractFoo.unrelated_data)
+            )
 
         assert Foo.data.property.columns[0].type is not AbstractFoo.data.type
 
@@ -858,7 +867,7 @@ class MutableColumnCopyJSONTest(_MutableDictTestBase, fixtures.MappedTest):
 
 
 class MutableColumnCopyArrayTest(_MutableListTestBase, fixtures.MappedTest):
-    __requires__ = 'array_type',
+    __requires__ = ("array_type",)
 
     @classmethod
     def define_tables(cls, metadata):
@@ -873,62 +882,72 @@ class MutableColumnCopyArrayTest(_MutableListTestBase, fixtures.MappedTest):
             data = Column(MutableList.as_mutable(ARRAY(Integer)))
 
         class Foo(Mixin, Base):
-            __tablename__ = 'foo'
+            __tablename__ = "foo"
             id = Column(Integer, primary_key=True)
 
 
-class MutableListWithScalarPickleTest(_MutableListTestBase,
-                                      fixtures.MappedTest):
-
+class MutableListWithScalarPickleTest(
+    _MutableListTestBase, fixtures.MappedTest
+):
     @classmethod
     def define_tables(cls, metadata):
         MutableList = cls._type_fixture()
 
         mutable_pickle = MutableList.as_mutable(PickleType)
-        Table('foo', metadata,
-              Column('id', Integer, primary_key=True,
-                     test_needs_autoincrement=True),
-              Column('skip', mutable_pickle),
-              Column('data', mutable_pickle),
-              Column('non_mutable_data', PickleType),
-              Column('unrelated_data', String(50))
-              )
+        Table(
+            "foo",
+            metadata,
+            Column(
+                "id", Integer, primary_key=True, test_needs_autoincrement=True
+            ),
+            Column("skip", mutable_pickle),
+            Column("data", mutable_pickle),
+            Column("non_mutable_data", PickleType),
+            Column("unrelated_data", String(50)),
+        )
 
 
 class MutableSetWithScalarPickleTest(_MutableSetTestBase, fixtures.MappedTest):
-
     @classmethod
     def define_tables(cls, metadata):
         MutableSet = cls._type_fixture()
 
         mutable_pickle = MutableSet.as_mutable(PickleType)
-        Table('foo', metadata,
-              Column('id', Integer, primary_key=True,
-                     test_needs_autoincrement=True),
-              Column('skip', mutable_pickle),
-              Column('data', mutable_pickle),
-              Column('non_mutable_data', PickleType),
-              Column('unrelated_data', String(50))
-              )
-
+        Table(
+            "foo",
+            metadata,
+            Column(
+                "id", Integer, primary_key=True, test_needs_autoincrement=True
+            ),
+            Column("skip", mutable_pickle),
+            Column("data", mutable_pickle),
+            Column("non_mutable_data", PickleType),
+            Column("unrelated_data", String(50)),
+        )
 
-class MutableAssocWithAttrInheritTest(_MutableDictTestBase,
-                                      fixtures.MappedTest):
 
+class MutableAssocWithAttrInheritTest(
+    _MutableDictTestBase, fixtures.MappedTest
+):
     @classmethod
     def define_tables(cls, metadata):
 
-        Table('foo', metadata,
-              Column('id', Integer, primary_key=True,
-                     test_needs_autoincrement=True),
-              Column('data', PickleType),
-              Column('non_mutable_data', PickleType),
-              Column('unrelated_data', String(50))
-              )
+        Table(
+            "foo",
+            metadata,
+            Column(
+                "id", Integer, primary_key=True, test_needs_autoincrement=True
+            ),
+            Column("data", PickleType),
+            Column("non_mutable_data", PickleType),
+            Column("unrelated_data", String(50)),
+        )
 
-        Table('subfoo', metadata,
-              Column('id', Integer, ForeignKey('foo.id'), primary_key=True),
-              )
+        Table(
+            "subfoo",
+            metadata,
+            Column("id", Integer, ForeignKey("foo.id"), primary_key=True),
+        )
 
     def setup_mappers(cls):
         foo = cls.tables.foo
@@ -941,41 +960,44 @@ class MutableAssocWithAttrInheritTest(_MutableDictTestBase,
     def test_in_place_mutation(self):
         sess = Session()
 
-        f1 = SubFoo(data={'a': 'b'})
+        f1 = SubFoo(data={"a": "b"})
         sess.add(f1)
         sess.commit()
 
-        f1.data['a'] = 'c'
+        f1.data["a"] = "c"
         sess.commit()
 
-        eq_(f1.data, {'a': 'c'})
+        eq_(f1.data, {"a": "c"})
 
     def test_replace(self):
         sess = Session()
-        f1 = SubFoo(data={'a': 'b'})
+        f1 = SubFoo(data={"a": "b"})
         sess.add(f1)
         sess.flush()
 
-        f1.data = {'b': 'c'}
+        f1.data = {"b": "c"}
         sess.commit()
-        eq_(f1.data, {'b': 'c'})
-
+        eq_(f1.data, {"b": "c"})
 
-class MutableAssociationScalarPickleTest(_MutableDictTestBase,
-                                         fixtures.MappedTest):
 
+class MutableAssociationScalarPickleTest(
+    _MutableDictTestBase, fixtures.MappedTest
+):
     @classmethod
     def define_tables(cls, metadata):
         MutableDict = cls._type_fixture()
         MutableDict.associate_with(PickleType)
 
-        Table('foo', metadata,
-              Column('id', Integer, primary_key=True,
-                     test_needs_autoincrement=True),
-              Column('skip', PickleType),
-              Column('data', PickleType),
-              Column('unrelated_data', String(50))
-              )
+        Table(
+            "foo",
+            metadata,
+            Column(
+                "id", Integer, primary_key=True, test_needs_autoincrement=True
+            ),
+            Column("skip", PickleType),
+            Column("data", PickleType),
+            Column("unrelated_data", String(50)),
+        )
 
 
 class MutableAssocIncludeNonPrimaryTest(MutableAssociationScalarPickleTest):
@@ -984,14 +1006,12 @@ class MutableAssocIncludeNonPrimaryTest(MutableAssociationScalarPickleTest):
         foo = cls.tables.foo
 
         mapper(Foo, foo)
-        mapper(Foo, foo, non_primary=True, properties={
-            "foo_bar": foo.c.data
-        })
+        mapper(Foo, foo, non_primary=True, properties={"foo_bar": foo.c.data})
 
 
-class MutableAssociationScalarJSONTest(_MutableDictTestBase,
-                                       fixtures.MappedTest):
-
+class MutableAssociationScalarJSONTest(
+    _MutableDictTestBase, fixtures.MappedTest
+):
     @classmethod
     def define_tables(cls, metadata):
         import json
@@ -1013,27 +1033,33 @@ class MutableAssociationScalarJSONTest(_MutableDictTestBase,
         MutableDict = cls._type_fixture()
         MutableDict.associate_with(JSONEncodedDict)
 
-        Table('foo', metadata,
-              Column('id', Integer, primary_key=True,
-                     test_needs_autoincrement=True),
-              Column('data', JSONEncodedDict),
-              Column('unrelated_data', String(50))
-              )
+        Table(
+            "foo",
+            metadata,
+            Column(
+                "id", Integer, primary_key=True, test_needs_autoincrement=True
+            ),
+            Column("data", JSONEncodedDict),
+            Column("unrelated_data", String(50)),
+        )
 
 
-class CustomMutableAssociationScalarJSONTest(_MutableDictTestBase,
-                                             fixtures.MappedTest):
+class CustomMutableAssociationScalarJSONTest(
+    _MutableDictTestBase, fixtures.MappedTest
+):
 
     CustomMutableDict = None
 
     @classmethod
     def _type_fixture(cls):
-        if not(getattr(cls, 'CustomMutableDict')):
+        if not (getattr(cls, "CustomMutableDict")):
             MutableDict = super(
-                CustomMutableAssociationScalarJSONTest, cls)._type_fixture()
+                CustomMutableAssociationScalarJSONTest, cls
+            )._type_fixture()
 
             class CustomMutableDict(MutableDict):
                 pass
+
             cls.CustomMutableDict = CustomMutableDict
         return cls.CustomMutableDict
 
@@ -1058,12 +1084,15 @@ class CustomMutableAssociationScalarJSONTest(_MutableDictTestBase,
         CustomMutableDict = cls._type_fixture()
         CustomMutableDict.associate_with(JSONEncodedDict)
 
-        Table('foo', metadata,
-              Column('id', Integer, primary_key=True,
-                     test_needs_autoincrement=True),
-              Column('data', JSONEncodedDict),
-              Column('unrelated_data', String(50))
-              )
+        Table(
+            "foo",
+            metadata,
+            Column(
+                "id", Integer, primary_key=True, test_needs_autoincrement=True
+            ),
+            Column("data", JSONEncodedDict),
+            Column("unrelated_data", String(50)),
+        )
 
     def test_pickle_parent(self):
         # Picklers don't know how to pickle CustomMutableDict,
@@ -1072,26 +1101,29 @@ class CustomMutableAssociationScalarJSONTest(_MutableDictTestBase,
 
     def test_coerce(self):
         sess = Session()
-        f1 = Foo(data={'a': 'b'})
+        f1 = Foo(data={"a": "b"})
         sess.add(f1)
         sess.flush()
         eq_(type(f1.data), self._type_fixture())
 
 
 class _CompositeTestBase(object):
-
     @classmethod
     def define_tables(cls, metadata):
-        Table('foo', metadata,
-              Column('id', Integer, primary_key=True,
-                     test_needs_autoincrement=True),
-              Column('x', Integer),
-              Column('y', Integer),
-              Column('unrelated_data', String(50))
-              )
+        Table(
+            "foo",
+            metadata,
+            Column(
+                "id", Integer, primary_key=True, test_needs_autoincrement=True
+            ),
+            Column("x", Integer),
+            Column("y", Integer),
+            Column("unrelated_data", String(50)),
+        )
 
     def setup(self):
         from sqlalchemy.ext import mutable
+
         mutable._setup_composite_listener()
         super(_CompositeTestBase, self).setup()
 
@@ -1107,17 +1139,20 @@ class _CompositeTestBase(object):
         return Point
 
 
-class MutableCompositeColumnDefaultTest(_CompositeTestBase,
-                                        fixtures.MappedTest):
+class MutableCompositeColumnDefaultTest(
+    _CompositeTestBase, fixtures.MappedTest
+):
     @classmethod
     def define_tables(cls, metadata):
         Table(
-            'foo', metadata,
-            Column('id', Integer, primary_key=True,
-                   test_needs_autoincrement=True),
-            Column('x', Integer, default=5),
-            Column('y', Integer, default=9),
-            Column('unrelated_data', String(50))
+            "foo",
+            metadata,
+            Column(
+                "id", Integer, primary_key=True, test_needs_autoincrement=True
+            ),
+            Column("x", Integer, default=5),
+            Column("y", Integer, default=9),
+            Column("unrelated_data", String(50)),
         )
 
     @classmethod
@@ -1126,9 +1161,11 @@ class MutableCompositeColumnDefaultTest(_CompositeTestBase,
 
         cls.Point = cls._type_fixture()
 
-        mapper(Foo, foo, properties={
-            'data': composite(cls.Point, foo.c.x, foo.c.y)
-        })
+        mapper(
+            Foo,
+            foo,
+            properties={"data": composite(cls.Point, foo.c.x, foo.c.y)},
+        )
 
     def test_evt_on_flush_refresh(self):
         # this still worked prior to #3427 being fixed in any case
@@ -1145,16 +1182,17 @@ class MutableCompositeColumnDefaultTest(_CompositeTestBase,
 
 
 class MutableCompositesUnpickleTest(_CompositeTestBase, fixtures.MappedTest):
-
     @classmethod
     def setup_mappers(cls):
         foo = cls.tables.foo
 
         cls.Point = cls._type_fixture()
 
-        mapper(FooWithEq, foo, properties={
-            'data': composite(cls.Point, foo.c.x, foo.c.y)
-        })
+        mapper(
+            FooWithEq,
+            foo,
+            properties={"data": composite(cls.Point, foo.c.x, foo.c.y)},
+        )
 
     def test_unpickle_modified_eq(self):
         u1 = FooWithEq(data=self.Point(3, 5))
@@ -1163,16 +1201,15 @@ class MutableCompositesUnpickleTest(_CompositeTestBase, fixtures.MappedTest):
 
 
 class MutableCompositesTest(_CompositeTestBase, fixtures.MappedTest):
-
     @classmethod
     def setup_mappers(cls):
         foo = cls.tables.foo
 
         Point = cls._type_fixture()
 
-        mapper(Foo, foo, properties={
-            'data': composite(Point, foo.c.x, foo.c.y)
-        })
+        mapper(
+            Foo, foo, properties={"data": composite(Point, foo.c.x, foo.c.y)}
+        )
 
     def test_in_place_mutation(self):
         sess = Session()
@@ -1194,7 +1231,7 @@ class MutableCompositesTest(_CompositeTestBase, fixtures.MappedTest):
         sess.commit()
 
         f1.data
-        assert 'data' in f1.__dict__
+        assert "data" in f1.__dict__
         sess.close()
 
         for loads, dumps in picklers():
@@ -1220,7 +1257,10 @@ class MutableCompositesTest(_CompositeTestBase, fixtures.MappedTest):
         assert_raises_message(
             ValueError,
             "Attribute 'data' does not accept objects",
-            setattr, f1, 'data', 'foo'
+            setattr,
+            f1,
+            "data",
+            "foo",
         )
 
     def test_unrelated_flush(self):
@@ -1237,7 +1277,6 @@ class MutableCompositesTest(_CompositeTestBase, fixtures.MappedTest):
 
 
 class MutableCompositeCallableTest(_CompositeTestBase, fixtures.MappedTest):
-
     @classmethod
     def setup_mappers(cls):
         foo = cls.tables.foo
@@ -1246,9 +1285,13 @@ class MutableCompositeCallableTest(_CompositeTestBase, fixtures.MappedTest):
 
         # in this case, this is not actually a MutableComposite.
         # so we don't expect it to track changes
-        mapper(Foo, foo, properties={
-            'data': composite(lambda x, y: Point(x, y), foo.c.x, foo.c.y)
-        })
+        mapper(
+            Foo,
+            foo,
+            properties={
+                "data": composite(lambda x, y: Point(x, y), foo.c.x, foo.c.y)
+            },
+        )
 
     def test_basic(self):
         sess = Session()
@@ -1262,9 +1305,9 @@ class MutableCompositeCallableTest(_CompositeTestBase, fixtures.MappedTest):
         eq_(f1.data.x, 3)
 
 
-class MutableCompositeCustomCoerceTest(_CompositeTestBase,
-                                       fixtures.MappedTest):
-
+class MutableCompositeCustomCoerceTest(
+    _CompositeTestBase, fixtures.MappedTest
+):
     @classmethod
     def _type_fixture(cls):
 
@@ -1276,9 +1319,9 @@ class MutableCompositeCustomCoerceTest(_CompositeTestBase,
 
         Point = cls._type_fixture()
 
-        mapper(Foo, foo, properties={
-            'data': composite(Point, foo.c.x, foo.c.y)
-        })
+        mapper(
+            Foo, foo, properties={"data": composite(Point, foo.c.x, foo.c.y)}
+        )
 
     def test_custom_coerce(self):
         f = Foo()
@@ -1297,18 +1340,22 @@ class MutableCompositeCustomCoerceTest(_CompositeTestBase,
 
 
 class MutableInheritedCompositesTest(_CompositeTestBase, fixtures.MappedTest):
-
     @classmethod
     def define_tables(cls, metadata):
-        Table('foo', metadata,
-              Column('id', Integer, primary_key=True,
-                     test_needs_autoincrement=True),
-              Column('x', Integer),
-              Column('y', Integer)
-              )
-        Table('subfoo', metadata,
-              Column('id', Integer, ForeignKey('foo.id'), primary_key=True),
-              )
+        Table(
+            "foo",
+            metadata,
+            Column(
+                "id", Integer, primary_key=True, test_needs_autoincrement=True
+            ),
+            Column("x", Integer),
+            Column("y", Integer),
+        )
+        Table(
+            "subfoo",
+            metadata,
+            Column("id", Integer, ForeignKey("foo.id"), primary_key=True),
+        )
 
     @classmethod
     def setup_mappers(cls):
@@ -1317,9 +1364,9 @@ class MutableInheritedCompositesTest(_CompositeTestBase, fixtures.MappedTest):
 
         Point = cls._type_fixture()
 
-        mapper(Foo, foo, properties={
-            'data': composite(Point, foo.c.x, foo.c.y)
-        })
+        mapper(
+            Foo, foo, properties={"data": composite(Point, foo.c.x, foo.c.y)}
+        )
         mapper(SubFoo, subfoo, inherits=Foo)
 
     def test_in_place_mutation_subclass(self):
@@ -1342,7 +1389,7 @@ class MutableInheritedCompositesTest(_CompositeTestBase, fixtures.MappedTest):
         sess.commit()
 
         f1.data
-        assert 'data' in f1.__dict__
+        assert "data" in f1.__dict__
         sess.close()
 
         for loads, dumps in picklers():