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

3 files changed, 145 insertions, 112 deletions

diff --git a/examples/vertical/__init__.py b/examples/vertical/__init__.py
index 0b69f32ea..0e09b9a55 100644
--- a/examples/vertical/__init__.py
+++ b/examples/vertical/__init__.py
@@ -31,4 +31,4 @@ Example::
 
 .. autosource::
 
-"""
\ No newline at end of file
+"""
diff --git a/examples/vertical/dictlike-polymorphic.py b/examples/vertical/dictlike-polymorphic.py
index 7147ac40b..c000ff3cf 100644
--- a/examples/vertical/dictlike-polymorphic.py
+++ b/examples/vertical/dictlike-polymorphic.py
@@ -30,6 +30,7 @@ from sqlalchemy import event
 from sqlalchemy import literal_column
 from .dictlike import ProxiedDictMixin
 
+
 class PolymorphicVerticalProperty(object):
     """A key/value pair with polymorphic value storage.
 
@@ -69,6 +70,7 @@ class PolymorphicVerticalProperty(object):
         """A comparator for .value, builds a polymorphic comparison via CASE.
 
         """
+
         def __init__(self, cls):
             self.cls = cls
 
@@ -77,40 +79,59 @@ class PolymorphicVerticalProperty(object):
             whens = [
                 (
                     literal_column("'%s'" % discriminator),
-                    cast(getattr(self.cls, attribute), String)
-                ) for attribute, discriminator in pairs
+                    cast(getattr(self.cls, attribute), String),
+                )
+                for attribute, discriminator in pairs
                 if attribute is not None
             ]
             return case(whens, self.cls.type, null())
+
         def __eq__(self, other):
             return self._case() == cast(other, String)
+
         def __ne__(self, other):
             return self._case() != cast(other, String)
 
     def __repr__(self):
-        return '<%s %r=%r>' % (self.__class__.__name__, self.key, self.value)
+        return "<%s %r=%r>" % (self.__class__.__name__, self.key, self.value)
+
 
-@event.listens_for(PolymorphicVerticalProperty, "mapper_configured", propagate=True)
+@event.listens_for(
+    PolymorphicVerticalProperty, "mapper_configured", propagate=True
+)
 def on_new_class(mapper, cls_):
     """Look for Column objects with type info in them, and work up
     a lookup table."""
 
     info_dict = {}
-    info_dict[type(None)] = (None, 'none')
-    info_dict['none'] = (None, 'none')
+    info_dict[type(None)] = (None, "none")
+    info_dict["none"] = (None, "none")
 
     for k in mapper.c.keys():
         col = mapper.c[k]
-        if 'type' in col.info:
-            python_type, discriminator = col.info['type']
+        if "type" in col.info:
+            python_type, discriminator = col.info["type"]
             info_dict[python_type] = (k, discriminator)
             info_dict[discriminator] = (k, discriminator)
     cls_.type_map = info_dict
 
-if __name__ == '__main__':
-    from sqlalchemy import (Column, Integer, Unicode,
-        ForeignKey, UnicodeText, and_, or_, String, Boolean, cast,
-        null, case, create_engine)
+
+if __name__ == "__main__":
+    from sqlalchemy import (
+        Column,
+        Integer,
+        Unicode,
+        ForeignKey,
+        UnicodeText,
+        and_,
+        or_,
+        String,
+        Boolean,
+        cast,
+        null,
+        case,
+        create_engine,
+    )
     from sqlalchemy.orm import relationship, Session
     from sqlalchemy.orm.collections import attribute_mapped_collection
     from sqlalchemy.ext.declarative import declarative_base
@@ -118,36 +139,38 @@ if __name__ == '__main__':
 
     Base = declarative_base()
 
-
     class AnimalFact(PolymorphicVerticalProperty, Base):
         """A fact about an animal."""
 
-        __tablename__ = 'animal_fact'
+        __tablename__ = "animal_fact"
 
-        animal_id = Column(ForeignKey('animal.id'), primary_key=True)
+        animal_id = Column(ForeignKey("animal.id"), primary_key=True)
         key = Column(Unicode(64), primary_key=True)
         type = Column(Unicode(16))
 
         # add information about storage for different types
         # in the info dictionary of Columns
-        int_value = Column(Integer, info={'type': (int, 'integer')})
-        char_value = Column(UnicodeText, info={'type': (str, 'string')})
-        boolean_value = Column(Boolean, info={'type': (bool, 'boolean')})
+        int_value = Column(Integer, info={"type": (int, "integer")})
+        char_value = Column(UnicodeText, info={"type": (str, "string")})
+        boolean_value = Column(Boolean, info={"type": (bool, "boolean")})
 
     class Animal(ProxiedDictMixin, Base):
         """an Animal"""
 
-        __tablename__ = 'animal'
+        __tablename__ = "animal"
 
         id = Column(Integer, primary_key=True)
         name = Column(Unicode(100))
 
-        facts = relationship("AnimalFact",
-                    collection_class=attribute_mapped_collection('key'))
+        facts = relationship(
+            "AnimalFact", collection_class=attribute_mapped_collection("key")
+        )
 
-        _proxied = association_proxy("facts", "value",
-                            creator=
-                            lambda key, value: AnimalFact(key=key, value=value))
+        _proxied = association_proxy(
+            "facts",
+            "value",
+            creator=lambda key, value: AnimalFact(key=key, value=value),
+        )
 
         def __init__(self, name):
             self.name = name
@@ -159,66 +182,66 @@ if __name__ == '__main__':
         def with_characteristic(self, key, value):
             return self.facts.any(key=key, value=value)
 
-    engine = create_engine('sqlite://', echo=True)
+    engine = create_engine("sqlite://", echo=True)
 
     Base.metadata.create_all(engine)
     session = Session(engine)
 
-    stoat = Animal('stoat')
-    stoat['color'] = 'red'
-    stoat['cuteness'] = 7
-    stoat['weasel-like'] = True
+    stoat = Animal("stoat")
+    stoat["color"] = "red"
+    stoat["cuteness"] = 7
+    stoat["weasel-like"] = True
 
     session.add(stoat)
     session.commit()
 
-    critter = session.query(Animal).filter(Animal.name == 'stoat').one()
-    print(critter['color'])
-    print(critter['cuteness'])
+    critter = session.query(Animal).filter(Animal.name == "stoat").one()
+    print(critter["color"])
+    print(critter["cuteness"])
 
     print("changing cuteness value and type:")
-    critter['cuteness'] = 'very cute'
+    critter["cuteness"] = "very cute"
 
     session.commit()
 
-    marten = Animal('marten')
-    marten['cuteness'] = 5
-    marten['weasel-like'] = True
-    marten['poisonous'] = False
+    marten = Animal("marten")
+    marten["cuteness"] = 5
+    marten["weasel-like"] = True
+    marten["poisonous"] = False
     session.add(marten)
 
-    shrew = Animal('shrew')
-    shrew['cuteness'] = 5
-    shrew['weasel-like'] = False
-    shrew['poisonous'] = True
+    shrew = Animal("shrew")
+    shrew["cuteness"] = 5
+    shrew["weasel-like"] = False
+    shrew["poisonous"] = True
 
     session.add(shrew)
     session.commit()
 
-    q = (session.query(Animal).
-         filter(Animal.facts.any(
-           and_(AnimalFact.key == 'weasel-like',
-                AnimalFact.value == True))))
-    print('weasel-like animals', q.all())
-
-    q = (session.query(Animal).
-         filter(Animal.with_characteristic('weasel-like', True)))
-    print('weasel-like animals again', q.all())
-
-    q = (session.query(Animal).
-           filter(Animal.with_characteristic('poisonous', False)))
-    print('animals with poisonous=False', q.all())
-
-    q = (session.query(Animal).
-         filter(or_(
-                    Animal.with_characteristic('poisonous', False),
-                    ~Animal.facts.any(AnimalFact.key == 'poisonous')
-                    )
-                )
+    q = session.query(Animal).filter(
+        Animal.facts.any(
+            and_(AnimalFact.key == "weasel-like", AnimalFact.value == True)
         )
-    print('non-poisonous animals', q.all())
-
-    q = (session.query(Animal).
-         filter(Animal.facts.any(AnimalFact.value == 5)))
-    print('any animal with a .value of 5', q.all())
+    )
+    print("weasel-like animals", q.all())
+
+    q = session.query(Animal).filter(
+        Animal.with_characteristic("weasel-like", True)
+    )
+    print("weasel-like animals again", q.all())
+
+    q = session.query(Animal).filter(
+        Animal.with_characteristic("poisonous", False)
+    )
+    print("animals with poisonous=False", q.all())
+
+    q = session.query(Animal).filter(
+        or_(
+            Animal.with_characteristic("poisonous", False),
+            ~Animal.facts.any(AnimalFact.key == "poisonous"),
+        )
+    )
+    print("non-poisonous animals", q.all())
 
+    q = session.query(Animal).filter(Animal.facts.any(AnimalFact.value == 5))
+    print("any animal with a .value of 5", q.all())
diff --git a/examples/vertical/dictlike.py b/examples/vertical/dictlike.py
index 08989d8c2..f1f364207 100644
--- a/examples/vertical/dictlike.py
+++ b/examples/vertical/dictlike.py
@@ -32,6 +32,7 @@ can be used with many common vertical schemas as-is or with minor adaptations.
 """
 from __future__ import unicode_literals
 
+
 class ProxiedDictMixin(object):
     """Adds obj[key] access to a mapped class.
 
@@ -60,9 +61,16 @@ class ProxiedDictMixin(object):
         del self._proxied[key]
 
 
-if __name__ == '__main__':
-    from sqlalchemy import (Column, Integer, Unicode,
-        ForeignKey, UnicodeText, and_, create_engine)
+if __name__ == "__main__":
+    from sqlalchemy import (
+        Column,
+        Integer,
+        Unicode,
+        ForeignKey,
+        UnicodeText,
+        and_,
+        create_engine,
+    )
     from sqlalchemy.orm import relationship, Session
     from sqlalchemy.orm.collections import attribute_mapped_collection
     from sqlalchemy.ext.declarative import declarative_base
@@ -73,26 +81,29 @@ if __name__ == '__main__':
     class AnimalFact(Base):
         """A fact about an animal."""
 
-        __tablename__ = 'animal_fact'
+        __tablename__ = "animal_fact"
 
-        animal_id = Column(ForeignKey('animal.id'), primary_key=True)
+        animal_id = Column(ForeignKey("animal.id"), primary_key=True)
         key = Column(Unicode(64), primary_key=True)
         value = Column(UnicodeText)
 
     class Animal(ProxiedDictMixin, Base):
         """an Animal"""
 
-        __tablename__ = 'animal'
+        __tablename__ = "animal"
 
         id = Column(Integer, primary_key=True)
         name = Column(Unicode(100))
 
-        facts = relationship("AnimalFact",
-                    collection_class=attribute_mapped_collection('key'))
+        facts = relationship(
+            "AnimalFact", collection_class=attribute_mapped_collection("key")
+        )
 
-        _proxied = association_proxy("facts", "value",
-                            creator=
-                            lambda key, value: AnimalFact(key=key, value=value))
+        _proxied = association_proxy(
+            "facts",
+            "value",
+            creator=lambda key, value: AnimalFact(key=key, value=value),
+        )
 
         def __init__(self, name):
             self.name = name
@@ -109,57 +120,56 @@ if __name__ == '__main__':
 
     session = Session(bind=engine)
 
-    stoat = Animal('stoat')
-    stoat['color'] = 'reddish'
-    stoat['cuteness'] = 'somewhat'
+    stoat = Animal("stoat")
+    stoat["color"] = "reddish"
+    stoat["cuteness"] = "somewhat"
 
     # dict-like assignment transparently creates entries in the
     # stoat.facts collection:
-    print(stoat.facts['color'])
+    print(stoat.facts["color"])
 
     session.add(stoat)
     session.commit()
 
-    critter = session.query(Animal).filter(Animal.name == 'stoat').one()
-    print(critter['color'])
-    print(critter['cuteness'])
+    critter = session.query(Animal).filter(Animal.name == "stoat").one()
+    print(critter["color"])
+    print(critter["cuteness"])
 
-    critter['cuteness'] = 'very'
+    critter["cuteness"] = "very"
 
-    print('changing cuteness:')
+    print("changing cuteness:")
 
-    marten = Animal('marten')
-    marten['color'] = 'brown'
-    marten['cuteness'] = 'somewhat'
+    marten = Animal("marten")
+    marten["color"] = "brown"
+    marten["cuteness"] = "somewhat"
     session.add(marten)
 
-    shrew = Animal('shrew')
-    shrew['cuteness'] = 'somewhat'
-    shrew['poisonous-part'] = 'saliva'
+    shrew = Animal("shrew")
+    shrew["cuteness"] = "somewhat"
+    shrew["poisonous-part"] = "saliva"
     session.add(shrew)
 
-    loris = Animal('slow loris')
-    loris['cuteness'] = 'fairly'
-    loris['poisonous-part'] = 'elbows'
+    loris = Animal("slow loris")
+    loris["cuteness"] = "fairly"
+    loris["poisonous-part"] = "elbows"
     session.add(loris)
 
-    q = (session.query(Animal).
-         filter(Animal.facts.any(
-           and_(AnimalFact.key == 'color',
-                AnimalFact.value == 'reddish'))))
-    print('reddish animals', q.all())
+    q = session.query(Animal).filter(
+        Animal.facts.any(
+            and_(AnimalFact.key == "color", AnimalFact.value == "reddish")
+        )
+    )
+    print("reddish animals", q.all())
 
-    q = session.query(Animal).\
-            filter(Animal.with_characteristic("color", 'brown'))
-    print('brown animals', q.all())
+    q = session.query(Animal).filter(
+        Animal.with_characteristic("color", "brown")
+    )
+    print("brown animals", q.all())
 
-    q = session.query(Animal).\
-           filter(~Animal.with_characteristic("poisonous-part", 'elbows'))
-    print('animals without poisonous-part == elbows', q.all())
+    q = session.query(Animal).filter(
+        ~Animal.with_characteristic("poisonous-part", "elbows")
+    )
+    print("animals without poisonous-part == elbows", q.all())
 
-    q = (session.query(Animal).
-         filter(Animal.facts.any(value='somewhat')))
+    q = session.query(Animal).filter(Animal.facts.any(value="somewhat"))
     print('any animal with any .value of "somewhat"', q.all())
-
-
-