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, 185 insertions, 109 deletions

diff --git a/lib/sqlalchemy/orm/collections.py b/lib/sqlalchemy/orm/collections.py
index 54c29bb5e..be9291741 100644
--- a/lib/sqlalchemy/orm/collections.py
+++ b/lib/sqlalchemy/orm/collections.py
@@ -113,9 +113,13 @@ from . import base
 
 from sqlalchemy.util.compat import inspect_getargspec
 
-__all__ = ['collection', 'collection_adapter',
-           'mapped_collection', 'column_mapped_collection',
-           'attribute_mapped_collection']
+__all__ = [
+    "collection",
+    "collection_adapter",
+    "mapped_collection",
+    "column_mapped_collection",
+    "attribute_mapped_collection",
+]
 
 __instrumentation_mutex = util.threading.Lock()
 
@@ -172,10 +176,12 @@ class _SerializableColumnGetter(object):
     def __call__(self, value):
         state = base.instance_state(value)
         m = base._state_mapper(state)
-        key = [m._get_state_attr_by_column(
-            state, state.dict,
-            m.mapped_table.columns[k])
-            for k in self.colkeys]
+        key = [
+            m._get_state_attr_by_column(
+                state, state.dict, m.mapped_table.columns[k]
+            )
+            for k in self.colkeys
+        ]
         if self.composite:
             return tuple(key)
         else:
@@ -208,16 +214,15 @@ class _SerializableColumnGetterV2(_PlainColumnGetter):
                 return None
             else:
                 return c.table.key
+
         colkeys = [(c.key, _table_key(c)) for c in cols]
         return _SerializableColumnGetterV2, (colkeys,)
 
     def _cols(self, mapper):
         cols = []
-        metadata = getattr(mapper.local_table, 'metadata', None)
+        metadata = getattr(mapper.local_table, "metadata", None)
         for (ckey, tkey) in self.colkeys:
-            if tkey is None or \
-                    metadata is None or \
-                    tkey not in metadata:
+            if tkey is None or metadata is None or tkey not in metadata:
                 cols.append(mapper.local_table.c[ckey])
             else:
                 cols.append(metadata.tables[tkey].c[ckey])
@@ -237,9 +242,10 @@ def column_mapped_collection(mapping_spec):
     after a session flush.
 
     """
-    cols = [expression._only_column_elements(q, "mapping_spec")
-            for q in util.to_list(mapping_spec)
-            ]
+    cols = [
+        expression._only_column_elements(q, "mapping_spec")
+        for q in util.to_list(mapping_spec)
+    ]
     keyfunc = _PlainColumnGetter(cols)
     return lambda: MappedCollection(keyfunc)
 
@@ -253,7 +259,7 @@ class _SerializableAttrGetter(object):
         return self.getter(target)
 
     def __reduce__(self):
-        return _SerializableAttrGetter, (self.name, )
+        return _SerializableAttrGetter, (self.name,)
 
 
 def attribute_mapped_collection(attr_name):
@@ -311,6 +317,7 @@ class collection(object):
         def popitem(self): ...
 
     """
+
     # Bundled as a class solely for ease of use: packaging, doc strings,
     # importability.
 
@@ -355,7 +362,7 @@ class collection(object):
         promulgation to collection events.
 
         """
-        fn._sa_instrument_role = 'appender'
+        fn._sa_instrument_role = "appender"
         return fn
 
     @staticmethod
@@ -382,7 +389,7 @@ class collection(object):
         promulgation to collection events.
 
         """
-        fn._sa_instrument_role = 'remover'
+        fn._sa_instrument_role = "remover"
         return fn
 
     @staticmethod
@@ -396,7 +403,7 @@ class collection(object):
             def __iter__(self): ...
 
         """
-        fn._sa_instrument_role = 'iterator'
+        fn._sa_instrument_role = "iterator"
         return fn
 
     @staticmethod
@@ -435,7 +442,7 @@ class collection(object):
            and :meth:`.AttributeEvents.dispose_collection` handlers.
 
         """
-        fn._sa_instrument_role = 'linker'
+        fn._sa_instrument_role = "linker"
         return fn
 
     link = linker
@@ -472,7 +479,7 @@ class collection(object):
         validation on the values about to be assigned.
 
         """
-        fn._sa_instrument_role = 'converter'
+        fn._sa_instrument_role = "converter"
         return fn
 
     @staticmethod
@@ -491,9 +498,11 @@ class collection(object):
             def do_stuff(self, thing, entity=None): ...
 
         """
+
         def decorator(fn):
-            fn._sa_instrument_before = ('fire_append_event', arg)
+            fn._sa_instrument_before = ("fire_append_event", arg)
             return fn
+
         return decorator
 
     @staticmethod
@@ -511,10 +520,12 @@ class collection(object):
             def __setitem__(self, index, item): ...
 
         """
+
         def decorator(fn):
-            fn._sa_instrument_before = ('fire_append_event', arg)
-            fn._sa_instrument_after = 'fire_remove_event'
+            fn._sa_instrument_before = ("fire_append_event", arg)
+            fn._sa_instrument_after = "fire_remove_event"
             return fn
+
         return decorator
 
     @staticmethod
@@ -533,9 +544,11 @@ class collection(object):
         collection.removes_return.
 
         """
+
         def decorator(fn):
-            fn._sa_instrument_before = ('fire_remove_event', arg)
+            fn._sa_instrument_before = ("fire_remove_event", arg)
             return fn
+
         return decorator
 
     @staticmethod
@@ -553,13 +566,15 @@ class collection(object):
         collection.remove.
 
         """
+
         def decorator(fn):
-            fn._sa_instrument_after = 'fire_remove_event'
+            fn._sa_instrument_after = "fire_remove_event"
             return fn
+
         return decorator
 
 
-collection_adapter = operator.attrgetter('_sa_adapter')
+collection_adapter = operator.attrgetter("_sa_adapter")
 """Fetch the :class:`.CollectionAdapter` for a collection."""
 
 
@@ -577,7 +592,13 @@ class CollectionAdapter(object):
     """
 
     __slots__ = (
-        'attr', '_key', '_data', 'owner_state', '_converter', 'invalidated')
+        "attr",
+        "_key",
+        "_data",
+        "owner_state",
+        "_converter",
+        "invalidated",
+    )
 
     def __init__(self, attr, owner_state, data):
         self.attr = attr
@@ -676,9 +697,8 @@ class CollectionAdapter(object):
             if self.invalidated:
                 self._warn_invalidated()
             return self.attr.fire_append_event(
-                self.owner_state,
-                self.owner_state.dict,
-                item, initiator)
+                self.owner_state, self.owner_state.dict, item, initiator
+            )
         else:
             return item
 
@@ -694,9 +714,8 @@ class CollectionAdapter(object):
             if self.invalidated:
                 self._warn_invalidated()
             self.attr.fire_remove_event(
-                self.owner_state,
-                self.owner_state.dict,
-                item, initiator)
+                self.owner_state, self.owner_state.dict, item, initiator
+            )
 
     def fire_pre_remove_event(self, initiator=None):
         """Notify that an entity is about to be removed from the collection.
@@ -708,25 +727,26 @@ class CollectionAdapter(object):
         if self.invalidated:
             self._warn_invalidated()
         self.attr.fire_pre_remove_event(
-            self.owner_state,
-            self.owner_state.dict,
-            initiator=initiator)
+            self.owner_state, self.owner_state.dict, initiator=initiator
+        )
 
     def __getstate__(self):
-        return {'key': self._key,
-                'owner_state': self.owner_state,
-                'owner_cls': self.owner_state.class_,
-                'data': self.data,
-                'invalidated': self.invalidated}
+        return {
+            "key": self._key,
+            "owner_state": self.owner_state,
+            "owner_cls": self.owner_state.class_,
+            "data": self.data,
+            "invalidated": self.invalidated,
+        }
 
     def __setstate__(self, d):
-        self._key = d['key']
-        self.owner_state = d['owner_state']
-        self._data = weakref.ref(d['data'])
-        self._converter = d['data']._sa_converter
-        d['data']._sa_adapter = self
-        self.invalidated = d['invalidated']
-        self.attr = getattr(d['owner_cls'], self._key).impl
+        self._key = d["key"]
+        self.owner_state = d["owner_state"]
+        self._data = weakref.ref(d["data"])
+        self._converter = d["data"]._sa_converter
+        d["data"]._sa_adapter = self
+        self.invalidated = d["invalidated"]
+        self.attr = getattr(d["owner_cls"], self._key).impl
 
 
 def bulk_replace(values, existing_adapter, new_adapter, initiator=None):
@@ -796,7 +816,7 @@ def prepare_instrumentation(factory):
     # Instrument the class if needed.
     if __instrumentation_mutex.acquire():
         try:
-            if getattr(cls, '_sa_instrumented', None) != id(cls):
+            if getattr(cls, "_sa_instrumented", None) != id(cls):
                 _instrument_class(cls)
         finally:
             __instrumentation_mutex.release()
@@ -829,10 +849,11 @@ def _instrument_class(cls):
     # In the normal call flow, a request for any of the 3 basic collection
     # types is transformed into one of our trivial subclasses
     # (e.g. InstrumentedList).  Catch anything else that sneaks in here...
-    if cls.__module__ == '__builtin__':
+    if cls.__module__ == "__builtin__":
         raise sa_exc.ArgumentError(
             "Can not instrument a built-in type. Use a "
-            "subclass, even a trivial one.")
+            "subclass, even a trivial one."
+        )
 
     roles, methods = _locate_roles_and_methods(cls)
 
@@ -858,25 +879,30 @@ def _locate_roles_and_methods(cls):
                 continue
 
             # note role declarations
-            if hasattr(method, '_sa_instrument_role'):
+            if hasattr(method, "_sa_instrument_role"):
                 role = method._sa_instrument_role
-                assert role in ('appender', 'remover', 'iterator',
-                                'linker', 'converter')
+                assert role in (
+                    "appender",
+                    "remover",
+                    "iterator",
+                    "linker",
+                    "converter",
+                )
                 roles.setdefault(role, name)
 
             # transfer instrumentation requests from decorated function
             # to the combined queue
             before, after = None, None
-            if hasattr(method, '_sa_instrument_before'):
+            if hasattr(method, "_sa_instrument_before"):
                 op, argument = method._sa_instrument_before
-                assert op in ('fire_append_event', 'fire_remove_event')
+                assert op in ("fire_append_event", "fire_remove_event")
                 before = op, argument
-            if hasattr(method, '_sa_instrument_after'):
+            if hasattr(method, "_sa_instrument_after"):
                 op = method._sa_instrument_after
-                assert op in ('fire_append_event', 'fire_remove_event')
+                assert op in ("fire_append_event", "fire_remove_event")
                 after = op
             if before:
-                methods[name] = before + (after, )
+                methods[name] = before + (after,)
             elif after:
                 methods[name] = None, None, after
     return roles, methods
@@ -898,8 +924,11 @@ def _setup_canned_roles(cls, roles, methods):
         # apply ABC auto-decoration to methods that need it
         for method, decorator in decorators.items():
             fn = getattr(cls, method, None)
-            if (fn and method not in methods and
-                    not hasattr(fn, '_sa_instrumented')):
+            if (
+                fn
+                and method not in methods
+                and not hasattr(fn, "_sa_instrumented")
+            ):
                 setattr(cls, method, decorator(fn))
 
 
@@ -908,26 +937,31 @@ def _assert_required_roles(cls, roles, methods):
     needed
 
     """
-    if 'appender' not in roles or not hasattr(cls, roles['appender']):
+    if "appender" not in roles or not hasattr(cls, roles["appender"]):
         raise sa_exc.ArgumentError(
             "Type %s must elect an appender method to be "
-            "a collection class" % cls.__name__)
-    elif (roles['appender'] not in methods and
-          not hasattr(getattr(cls, roles['appender']), '_sa_instrumented')):
-        methods[roles['appender']] = ('fire_append_event', 1, None)
-
-    if 'remover' not in roles or not hasattr(cls, roles['remover']):
+            "a collection class" % cls.__name__
+        )
+    elif roles["appender"] not in methods and not hasattr(
+        getattr(cls, roles["appender"]), "_sa_instrumented"
+    ):
+        methods[roles["appender"]] = ("fire_append_event", 1, None)
+
+    if "remover" not in roles or not hasattr(cls, roles["remover"]):
         raise sa_exc.ArgumentError(
             "Type %s must elect a remover method to be "
-            "a collection class" % cls.__name__)
-    elif (roles['remover'] not in methods and
-          not hasattr(getattr(cls, roles['remover']), '_sa_instrumented')):
-        methods[roles['remover']] = ('fire_remove_event', 1, None)
-
-    if 'iterator' not in roles or not hasattr(cls, roles['iterator']):
+            "a collection class" % cls.__name__
+        )
+    elif roles["remover"] not in methods and not hasattr(
+        getattr(cls, roles["remover"]), "_sa_instrumented"
+    ):
+        methods[roles["remover"]] = ("fire_remove_event", 1, None)
+
+    if "iterator" not in roles or not hasattr(cls, roles["iterator"]):
         raise sa_exc.ArgumentError(
             "Type %s must elect an iterator method to be "
-            "a collection class" % cls.__name__)
+            "a collection class" % cls.__name__
+        )
 
 
 def _set_collection_attributes(cls, roles, methods):
@@ -936,16 +970,20 @@ def _set_collection_attributes(cls, roles, methods):
 
     """
     for method_name, (before, argument, after) in methods.items():
-        setattr(cls, method_name,
-                _instrument_membership_mutator(getattr(cls, method_name),
-                                               before, argument, after))
+        setattr(
+            cls,
+            method_name,
+            _instrument_membership_mutator(
+                getattr(cls, method_name), before, argument, after
+            ),
+        )
     # intern the role map
     for role, method_name in roles.items():
-        setattr(cls, '_sa_%s' % role, getattr(cls, method_name))
+        setattr(cls, "_sa_%s" % role, getattr(cls, method_name))
 
     cls._sa_adapter = None
 
-    if not hasattr(cls, '_sa_converter'):
+    if not hasattr(cls, "_sa_converter"):
         cls._sa_converter = None
     cls._sa_instrumented = id(cls)
 
@@ -972,7 +1010,8 @@ def _instrument_membership_mutator(method, before, argument, after):
             if pos_arg is None:
                 if named_arg not in kw:
                     raise sa_exc.ArgumentError(
-                        "Missing argument %s" % argument)
+                        "Missing argument %s" % argument
+                    )
                 value = kw[named_arg]
             else:
                 if len(args) > pos_arg:
@@ -981,9 +1020,10 @@ def _instrument_membership_mutator(method, before, argument, after):
                     value = kw[named_arg]
                 else:
                     raise sa_exc.ArgumentError(
-                        "Missing argument %s" % argument)
+                        "Missing argument %s" % argument
+                    )
 
-        initiator = kw.pop('_sa_initiator', None)
+        initiator = kw.pop("_sa_initiator", None)
         if initiator is False:
             executor = None
         else:
@@ -1055,6 +1095,7 @@ def _list_decorators():
         def append(self, item, _sa_initiator=None):
             item = __set(self, item, _sa_initiator)
             fn(self, item)
+
         _tidy(append)
         return append
 
@@ -1063,6 +1104,7 @@ def _list_decorators():
             __del(self, value, _sa_initiator)
             # testlib.pragma exempt:__eq__
             fn(self, value)
+
         _tidy(remove)
         return remove
 
@@ -1070,6 +1112,7 @@ def _list_decorators():
         def insert(self, index, value):
             value = __set(self, value)
             fn(self, index, value)
+
         _tidy(insert)
         return insert
 
@@ -1106,10 +1149,12 @@ def _list_decorators():
                     if len(value) != len(rng):
                         raise ValueError(
                             "attempt to assign sequence of size %s to "
-                            "extended slice of size %s" % (len(value),
-                                                           len(rng)))
+                            "extended slice of size %s"
+                            % (len(value), len(rng))
+                        )
                     for i, item in zip(rng, value):
                         self.__setitem__(i, item)
+
         _tidy(__setitem__)
         return __setitem__
 
@@ -1126,16 +1171,19 @@ def _list_decorators():
                 for item in self[index]:
                     __del(self, item)
                 fn(self, index)
+
         _tidy(__delitem__)
         return __delitem__
 
     if util.py2k:
+
         def __setslice__(fn):
             def __setslice__(self, start, end, values):
                 for value in self[start:end]:
                     __del(self, value)
                 values = [__set(self, value) for value in values]
                 fn(self, start, end, values)
+
             _tidy(__setslice__)
             return __setslice__
 
@@ -1144,6 +1192,7 @@ def _list_decorators():
                 for value in self[start:end]:
                     __del(self, value)
                 fn(self, start, end)
+
             _tidy(__delslice__)
             return __delslice__
 
@@ -1151,6 +1200,7 @@ def _list_decorators():
         def extend(self, iterable):
             for value in iterable:
                 self.append(value)
+
         _tidy(extend)
         return extend
 
@@ -1161,6 +1211,7 @@ def _list_decorators():
             for value in iterable:
                 self.append(value)
             return self
+
         _tidy(__iadd__)
         return __iadd__
 
@@ -1170,15 +1221,18 @@ def _list_decorators():
             item = fn(self, index)
             __del(self, item)
             return item
+
         _tidy(pop)
         return pop
 
     if not util.py2k:
+
         def clear(fn):
             def clear(self, index=-1):
                 for item in self:
                     __del(self, item)
                 fn(self)
+
             _tidy(clear)
             return clear
 
@@ -1188,7 +1242,7 @@ def _list_decorators():
     # desired.  hard to imagine a use case for __imul__, though.
 
     l = locals().copy()
-    l.pop('_tidy')
+    l.pop("_tidy")
     return l
 
 
@@ -1199,7 +1253,7 @@ def _dict_decorators():
         fn._sa_instrumented = True
         fn.__doc__ = getattr(dict, fn.__name__).__doc__
 
-    Unspecified = util.symbol('Unspecified')
+    Unspecified = util.symbol("Unspecified")
 
     def __setitem__(fn):
         def __setitem__(self, key, value, _sa_initiator=None):
@@ -1207,6 +1261,7 @@ def _dict_decorators():
                 __del(self, self[key], _sa_initiator)
             value = __set(self, value, _sa_initiator)
             fn(self, key, value)
+
         _tidy(__setitem__)
         return __setitem__
 
@@ -1215,6 +1270,7 @@ def _dict_decorators():
             if key in self:
                 __del(self, self[key], _sa_initiator)
             fn(self, key)
+
         _tidy(__delitem__)
         return __delitem__
 
@@ -1223,6 +1279,7 @@ def _dict_decorators():
             for key in self:
                 __del(self, self[key])
             fn(self)
+
         _tidy(clear)
         return clear
 
@@ -1237,6 +1294,7 @@ def _dict_decorators():
             if _to_del:
                 __del(self, item)
             return item
+
         _tidy(pop)
         return pop
 
@@ -1246,6 +1304,7 @@ def _dict_decorators():
             item = fn(self)
             __del(self, item[1])
             return item
+
         _tidy(popitem)
         return popitem
 
@@ -1256,16 +1315,16 @@ def _dict_decorators():
                 return default
             else:
                 return self.__getitem__(key)
+
         _tidy(setdefault)
         return setdefault
 
     def update(fn):
         def update(self, __other=Unspecified, **kw):
             if __other is not Unspecified:
-                if hasattr(__other, 'keys'):
+                if hasattr(__other, "keys"):
                     for key in list(__other):
-                        if (key not in self or
-                                self[key] is not __other[key]):
+                        if key not in self or self[key] is not __other[key]:
                             self[key] = __other[key]
                 else:
                     for key, value in __other:
@@ -1274,14 +1333,16 @@ def _dict_decorators():
             for key in kw:
                 if key not in self or self[key] is not kw[key]:
                     self[key] = kw[key]
+
         _tidy(update)
         return update
 
     l = locals().copy()
-    l.pop('_tidy')
-    l.pop('Unspecified')
+    l.pop("_tidy")
+    l.pop("Unspecified")
     return l
 
+
 _set_binop_bases = (set, frozenset)
 
 
@@ -1293,8 +1354,10 @@ def _set_binops_check_strict(self, obj):
 
 def _set_binops_check_loose(self, obj):
     """Allow anything set-like to participate in set binops."""
-    return (isinstance(obj, _set_binop_bases + (self.__class__,)) or
-            util.duck_type_collection(obj) == set)
+    return (
+        isinstance(obj, _set_binop_bases + (self.__class__,))
+        or util.duck_type_collection(obj) == set
+    )
 
 
 def _set_decorators():
@@ -1304,7 +1367,7 @@ def _set_decorators():
         fn._sa_instrumented = True
         fn.__doc__ = getattr(set, fn.__name__).__doc__
 
-    Unspecified = util.symbol('Unspecified')
+    Unspecified = util.symbol("Unspecified")
 
     def add(fn):
         def add(self, value, _sa_initiator=None):
@@ -1312,6 +1375,7 @@ def _set_decorators():
                 value = __set(self, value, _sa_initiator)
             # testlib.pragma exempt:__hash__
             fn(self, value)
+
         _tidy(add)
         return add
 
@@ -1322,6 +1386,7 @@ def _set_decorators():
                 __del(self, value, _sa_initiator)
                 # testlib.pragma exempt:__hash__
             fn(self, value)
+
         _tidy(discard)
         return discard
 
@@ -1332,6 +1397,7 @@ def _set_decorators():
                 __del(self, value, _sa_initiator)
             # testlib.pragma exempt:__hash__
             fn(self, value)
+
         _tidy(remove)
         return remove
 
@@ -1343,6 +1409,7 @@ def _set_decorators():
             # that will be popped before pop is called.
             __del(self, item)
             return item
+
         _tidy(pop)
         return pop
 
@@ -1350,6 +1417,7 @@ def _set_decorators():
         def clear(self):
             for item in list(self):
                 self.remove(item)
+
         _tidy(clear)
         return clear
 
@@ -1357,6 +1425,7 @@ def _set_decorators():
         def update(self, value):
             for item in value:
                 self.add(item)
+
         _tidy(update)
         return update
 
@@ -1367,6 +1436,7 @@ def _set_decorators():
             for item in value:
                 self.add(item)
             return self
+
         _tidy(__ior__)
         return __ior__
 
@@ -1374,6 +1444,7 @@ def _set_decorators():
         def difference_update(self, value):
             for item in value:
                 self.discard(item)
+
         _tidy(difference_update)
         return difference_update
 
@@ -1384,6 +1455,7 @@ def _set_decorators():
             for item in value:
                 self.discard(item)
             return self
+
         _tidy(__isub__)
         return __isub__
 
@@ -1396,6 +1468,7 @@ def _set_decorators():
                 self.remove(item)
             for item in add:
                 self.add(item)
+
         _tidy(intersection_update)
         return intersection_update
 
@@ -1411,6 +1484,7 @@ def _set_decorators():
             for item in add:
                 self.add(item)
             return self
+
         _tidy(__iand__)
         return __iand__
 
@@ -1423,6 +1497,7 @@ def _set_decorators():
                 self.remove(item)
             for item in add:
                 self.add(item)
+
         _tidy(symmetric_difference_update)
         return symmetric_difference_update
 
@@ -1438,12 +1513,13 @@ def _set_decorators():
             for item in add:
                 self.add(item)
             return self
+
         _tidy(__ixor__)
         return __ixor__
 
     l = locals().copy()
-    l.pop('_tidy')
-    l.pop('Unspecified')
+    l.pop("_tidy")
+    l.pop("Unspecified")
     return l
 
 
@@ -1467,18 +1543,17 @@ __canned_instrumentation = {
 
 __interfaces = {
     list: (
-        {'appender': 'append', 'remover': 'remove',
-         'iterator': '__iter__'}, _list_decorators()
+        {"appender": "append", "remover": "remove", "iterator": "__iter__"},
+        _list_decorators(),
+    ),
+    set: (
+        {"appender": "add", "remover": "remove", "iterator": "__iter__"},
+        _set_decorators(),
     ),
-
-    set: ({'appender': 'add',
-           'remover': 'remove',
-           'iterator': '__iter__'}, _set_decorators()
-          ),
-
     # decorators are required for dicts and object collections.
-    dict: ({'iterator': 'values'}, _dict_decorators()) if util.py3k
-    else ({'iterator': 'itervalues'}, _dict_decorators()),
+    dict: ({"iterator": "values"}, _dict_decorators())
+    if util.py3k
+    else ({"iterator": "itervalues"}, _dict_decorators()),
 }
 
 
@@ -1529,10 +1604,11 @@ class MappedCollection(dict):
                 "Can not remove '%s': collection holds '%s' for key '%s'. "
                 "Possible cause: is the MappedCollection key function "
                 "based on mutable properties or properties that only obtain "
-                "values after flush?" %
-                (value, self[key], key))
+                "values after flush?" % (value, self[key], key)
+            )
         self.__delitem__(key, _sa_initiator)
 
+
 # ensure instrumentation is associated with
 # these built-in classes; if a user-defined class
 # subclasses these and uses @internally_instrumented,