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

4 files changed, 62 insertions, 45 deletions

diff --git a/examples/custom_attributes/__init__.py b/examples/custom_attributes/__init__.py
index cbc65dfed..8d73d27e3 100644
--- a/examples/custom_attributes/__init__.py
+++ b/examples/custom_attributes/__init__.py
@@ -4,4 +4,4 @@ system.
 
 .. autosource::
 
-"""
\ No newline at end of file
+"""
diff --git a/examples/custom_attributes/active_column_defaults.py b/examples/custom_attributes/active_column_defaults.py
index dd823e814..f05a53173 100644
--- a/examples/custom_attributes/active_column_defaults.py
+++ b/examples/custom_attributes/active_column_defaults.py
@@ -35,6 +35,7 @@ def default_listener(col_attr, default):
     user integrating this feature.
 
     """
+
     @event.listens_for(col_attr, "init_scalar", retval=True, propagate=True)
     def init_scalar(target, value, dict_):
 
@@ -52,7 +53,8 @@ def default_listener(col_attr, default):
             # or can procure a connection from an Engine
             # or Session and actually run the SQL, if desired.
             raise NotImplementedError(
-                "Can't invoke pre-default for a SQL-level column default")
+                "Can't invoke pre-default for a SQL-level column default"
+            )
 
         # set the value in the given dict_; this won't emit any further
         # attribute set events or create attribute "history", but the value
@@ -63,7 +65,7 @@ def default_listener(col_attr, default):
         return value
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
 
     from sqlalchemy import Column, Integer, DateTime, create_engine
     from sqlalchemy.orm import Session
@@ -72,10 +74,10 @@ if __name__ == '__main__':
 
     Base = declarative_base()
 
-    event.listen(Base, 'mapper_configured', configure_listener, propagate=True)
+    event.listen(Base, "mapper_configured", configure_listener, propagate=True)
 
     class Widget(Base):
-        __tablename__ = 'widget'
+        __tablename__ = "widget"
 
         id = Column(Integer, primary_key=True)
 
@@ -96,8 +98,8 @@ if __name__ == '__main__':
     # Column-level default for the "timestamp" column will no longer fire
     # off.
     current_time = w1.timestamp
-    assert (
-        current_time > datetime.datetime.now() - datetime.timedelta(seconds=5)
+    assert current_time > datetime.datetime.now() - datetime.timedelta(
+        seconds=5
     )
 
     # persist
@@ -107,7 +109,7 @@ if __name__ == '__main__':
 
     # data is persisted.  The timestamp is also the one we generated above;
     # e.g. the default wasn't re-invoked later.
-    assert (
-        sess.query(Widget.radius, Widget.timestamp).first() ==
-        (30, current_time)
+    assert sess.query(Widget.radius, Widget.timestamp).first() == (
+        30,
+        current_time,
     )
diff --git a/examples/custom_attributes/custom_management.py b/examples/custom_attributes/custom_management.py
index 2199e0138..812385906 100644
--- a/examples/custom_attributes/custom_management.py
+++ b/examples/custom_attributes/custom_management.py
@@ -9,31 +9,44 @@ descriptors with a user-defined system.
 
 
 """
-from sqlalchemy import create_engine, MetaData, Table, Column, Integer, Text,\
-    ForeignKey
+from sqlalchemy import (
+    create_engine,
+    MetaData,
+    Table,
+    Column,
+    Integer,
+    Text,
+    ForeignKey,
+)
 from sqlalchemy.orm import mapper, relationship, Session
 
-from sqlalchemy.orm.attributes import set_attribute, get_attribute, \
-    del_attribute
+from sqlalchemy.orm.attributes import (
+    set_attribute,
+    get_attribute,
+    del_attribute,
+)
 from sqlalchemy.orm.instrumentation import is_instrumented
 
 from sqlalchemy.ext.instrumentation import InstrumentationManager
 
+
 class MyClassState(InstrumentationManager):
     def get_instance_dict(self, class_, instance):
         return instance._goofy_dict
 
     def initialize_instance_dict(self, class_, instance):
-        instance.__dict__['_goofy_dict'] = {}
+        instance.__dict__["_goofy_dict"] = {}
 
     def install_state(self, class_, instance, state):
-        instance.__dict__['_goofy_dict']['state'] = state
+        instance.__dict__["_goofy_dict"]["state"] = state
 
     def state_getter(self, class_):
         def find(instance):
-            return instance.__dict__['_goofy_dict']['state']
+            return instance.__dict__["_goofy_dict"]["state"]
+
         return find
 
+
 class MyClass(object):
     __sa_instrumentation_manager__ = MyClassState
 
@@ -63,17 +76,23 @@ class MyClass(object):
             del self._goofy_dict[key]
 
 
-if __name__ == '__main__':
-    engine = create_engine('sqlite://')
+if __name__ == "__main__":
+    engine = create_engine("sqlite://")
     meta = MetaData()
 
-    table1 = Table('table1', meta,
-                    Column('id', Integer, primary_key=True),
-                    Column('name', Text))
-    table2 = Table('table2', meta,
-                    Column('id', Integer, primary_key=True),
-                    Column('name', Text),
-                    Column('t1id', Integer, ForeignKey('table1.id')))
+    table1 = Table(
+        "table1",
+        meta,
+        Column("id", Integer, primary_key=True),
+        Column("name", Text),
+    )
+    table2 = Table(
+        "table2",
+        meta,
+        Column("id", Integer, primary_key=True),
+        Column("name", Text),
+        Column("t1id", Integer, ForeignKey("table1.id")),
+    )
     meta.create_all(engine)
 
     class A(MyClass):
@@ -82,16 +101,14 @@ if __name__ == '__main__':
     class B(MyClass):
         pass
 
-    mapper(A, table1, properties={
-        'bs': relationship(B)
-    })
+    mapper(A, table1, properties={"bs": relationship(B)})
 
     mapper(B, table2)
 
-    a1 = A(name='a1', bs=[B(name='b1'), B(name='b2')])
+    a1 = A(name="a1", bs=[B(name="b1"), B(name="b2")])
 
-    assert a1.name == 'a1'
-    assert a1.bs[0].name == 'b1'
+    assert a1.name == "a1"
+    assert a1.bs[0].name == "b1"
 
     sess = Session(engine)
     sess.add(a1)
@@ -100,8 +117,8 @@ if __name__ == '__main__':
 
     a1 = sess.query(A).get(a1.id)
 
-    assert a1.name == 'a1'
-    assert a1.bs[0].name == 'b1'
+    assert a1.name == "a1"
+    assert a1.bs[0].name == "b1"
 
     a1.bs.remove(a1.bs[0])
 
diff --git a/examples/custom_attributes/listen_for_events.py b/examples/custom_attributes/listen_for_events.py
index 0aeebc1d1..e3ef4cbea 100644
--- a/examples/custom_attributes/listen_for_events.py
+++ b/examples/custom_attributes/listen_for_events.py
@@ -5,6 +5,7 @@ and listen for change events.
 
 from sqlalchemy import event
 
+
 def configure_listener(class_, key, inst):
     def append(instance, value, initiator):
         instance.receive_change_event("append", key, value, None)
@@ -15,19 +16,18 @@ def configure_listener(class_, key, inst):
     def set_(instance, value, oldvalue, initiator):
         instance.receive_change_event("set", key, value, oldvalue)
 
-    event.listen(inst, 'append', append)
-    event.listen(inst, 'remove', remove)
-    event.listen(inst, 'set', set_)
+    event.listen(inst, "append", append)
+    event.listen(inst, "remove", remove)
+    event.listen(inst, "set", set_)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
 
     from sqlalchemy import Column, Integer, String, ForeignKey
     from sqlalchemy.orm import relationship
     from sqlalchemy.ext.declarative import declarative_base
 
     class Base(object):
-
         def receive_change_event(self, verb, key, value, oldvalue):
             s = "Value '%s' %s on attribute '%s', " % (value, verb, key)
             if oldvalue:
@@ -37,7 +37,7 @@ if __name__ == '__main__':
 
     Base = declarative_base(cls=Base)
 
-    event.listen(Base, 'attribute_instrument', configure_listener)
+    event.listen(Base, "attribute_instrument", configure_listener)
 
     class MyMappedClass(Base):
         __tablename__ = "mytable"
@@ -61,9 +61,7 @@ if __name__ == '__main__':
 
     # classes are instrumented.  Demonstrate the events !
 
-    m1 = MyMappedClass(data='m1', related=Related(data='r1'))
-    m1.data = 'm1mod'
-    m1.related.mapped.append(MyMappedClass(data='m2'))
+    m1 = MyMappedClass(data="m1", related=Related(data="r1"))
+    m1.data = "m1mod"
+    m1.related.mapped.append(MyMappedClass(data="m2"))
     del m1.data
-
-