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, 150 insertions, 112 deletions

diff --git a/test/dialect/mysql/test_query.py b/test/dialect/mysql/test_query.py
index 04f3ca67d..ecd79257f 100644
--- a/test/dialect/mysql/test_query.py
+++ b/test/dialect/mysql/test_query.py
@@ -7,29 +7,29 @@ from sqlalchemy import testing
 
 
 class IdiosyncrasyTest(fixtures.TestBase):
-    __only_on__ = 'mysql'
+    __only_on__ = "mysql"
     __backend__ = True
 
     @testing.emits_warning()
     def test_is_boolean_symbols_despite_no_native(self):
         is_(
             testing.db.scalar(select([cast(true().is_(true()), Boolean)])),
-            True
+            True,
         )
 
         is_(
             testing.db.scalar(select([cast(true().isnot(true()), Boolean)])),
-            False
+            False,
         )
 
         is_(
             testing.db.scalar(select([cast(false().is_(false()), Boolean)])),
-            True
+            True,
         )
 
 
 class MatchTest(fixtures.TestBase):
-    __only_on__ = 'mysql'
+    __only_on__ = "mysql"
     __backend__ = True
 
     @classmethod
@@ -37,138 +37,182 @@ class MatchTest(fixtures.TestBase):
         global metadata, cattable, matchtable
         metadata = MetaData(testing.db)
 
-        cattable = Table('cattable', metadata,
-                         Column('id', Integer, primary_key=True),
-                         Column('description', String(50)),
-                         mysql_engine='MyISAM')
-        matchtable = Table('matchtable', metadata,
-                           Column('id', Integer, primary_key=True),
-                           Column('title', String(200)),
-                           Column('category_id',
-                                  Integer,
-                                  ForeignKey('cattable.id')),
-                           mysql_engine='MyISAM')
+        cattable = Table(
+            "cattable",
+            metadata,
+            Column("id", Integer, primary_key=True),
+            Column("description", String(50)),
+            mysql_engine="MyISAM",
+        )
+        matchtable = Table(
+            "matchtable",
+            metadata,
+            Column("id", Integer, primary_key=True),
+            Column("title", String(200)),
+            Column("category_id", Integer, ForeignKey("cattable.id")),
+            mysql_engine="MyISAM",
+        )
         metadata.create_all()
 
-        cattable.insert().execute([
-            {'id': 1, 'description': 'Python'},
-            {'id': 2, 'description': 'Ruby'},
-        ])
-        matchtable.insert().execute([
-            {'id': 1,
-             'title': 'Agile Web Development with Ruby On Rails',
-             'category_id': 2},
-            {'id': 2,
-             'title': 'Dive Into Python',
-             'category_id': 1},
-            {'id': 3,
-             'title': "Programming Matz's Ruby",
-             'category_id': 2},
-            {'id': 4,
-             'title': 'The Definitive Guide to Django',
-             'category_id': 1},
-            {'id': 5,
-             'title': 'Python in a Nutshell',
-             'category_id': 1}
-        ])
+        cattable.insert().execute(
+            [
+                {"id": 1, "description": "Python"},
+                {"id": 2, "description": "Ruby"},
+            ]
+        )
+        matchtable.insert().execute(
+            [
+                {
+                    "id": 1,
+                    "title": "Agile Web Development with Ruby On Rails",
+                    "category_id": 2,
+                },
+                {"id": 2, "title": "Dive Into Python", "category_id": 1},
+                {
+                    "id": 3,
+                    "title": "Programming Matz's Ruby",
+                    "category_id": 2,
+                },
+                {
+                    "id": 4,
+                    "title": "The Definitive Guide to Django",
+                    "category_id": 1,
+                },
+                {"id": 5, "title": "Python in a Nutshell", "category_id": 1},
+            ]
+        )
 
     @classmethod
     def teardown_class(cls):
         metadata.drop_all()
 
     def test_simple_match(self):
-        results = (matchtable.select().
-                   where(matchtable.c.title.match('python')).
-                   order_by(matchtable.c.id).
-                   execute().
-                   fetchall())
+        results = (
+            matchtable.select()
+            .where(matchtable.c.title.match("python"))
+            .order_by(matchtable.c.id)
+            .execute()
+            .fetchall()
+        )
         eq_([2, 5], [r.id for r in results])
 
     def test_not_match(self):
-        results = (matchtable.select().
-                   where(~matchtable.c.title.match('python')).
-                   order_by(matchtable.c.id).
-                   execute().
-                   fetchall())
+        results = (
+            matchtable.select()
+            .where(~matchtable.c.title.match("python"))
+            .order_by(matchtable.c.id)
+            .execute()
+            .fetchall()
+        )
         eq_([1, 3, 4], [r.id for r in results])
 
     def test_simple_match_with_apostrophe(self):
-        results = (matchtable.select().
-                   where(matchtable.c.title.match("Matz's")).
-                   execute().
-                   fetchall())
+        results = (
+            matchtable.select()
+            .where(matchtable.c.title.match("Matz's"))
+            .execute()
+            .fetchall()
+        )
         eq_([3], [r.id for r in results])
 
     def test_return_value(self):
         # test [ticket:3263]
         result = testing.db.execute(
-            select([
-                matchtable.c.title.match('Agile Ruby Programming')
-                .label('ruby'),
-                matchtable.c.title.match('Dive Python').label('python'),
-                matchtable.c.title
-            ]).order_by(matchtable.c.id)
+            select(
+                [
+                    matchtable.c.title.match("Agile Ruby Programming").label(
+                        "ruby"
+                    ),
+                    matchtable.c.title.match("Dive Python").label("python"),
+                    matchtable.c.title,
+                ]
+            ).order_by(matchtable.c.id)
         ).fetchall()
         eq_(
             result,
             [
-                (2.0, 0.0, 'Agile Web Development with Ruby On Rails'),
-                (0.0, 2.0, 'Dive Into Python'),
+                (2.0, 0.0, "Agile Web Development with Ruby On Rails"),
+                (0.0, 2.0, "Dive Into Python"),
                 (2.0, 0.0, "Programming Matz's Ruby"),
-                (0.0, 0.0, 'The Definitive Guide to Django'),
-                (0.0, 1.0, 'Python in a Nutshell')
-            ]
+                (0.0, 0.0, "The Definitive Guide to Django"),
+                (0.0, 1.0, "Python in a Nutshell"),
+            ],
         )
 
     def test_or_match(self):
-        results1 = (matchtable.select().
-                    where(or_(matchtable.c.title.match('nutshell'),
-                              matchtable.c.title.match('ruby'))).
-                    order_by(matchtable.c.id).
-                    execute().
-                    fetchall())
+        results1 = (
+            matchtable.select()
+            .where(
+                or_(
+                    matchtable.c.title.match("nutshell"),
+                    matchtable.c.title.match("ruby"),
+                )
+            )
+            .order_by(matchtable.c.id)
+            .execute()
+            .fetchall()
+        )
         eq_([1, 3, 5], [r.id for r in results1])
-        results2 = (matchtable.select().
-                    where(matchtable.c.title.match('nutshell ruby')).
-                    order_by(matchtable.c.id).
-                    execute().
-                    fetchall())
+        results2 = (
+            matchtable.select()
+            .where(matchtable.c.title.match("nutshell ruby"))
+            .order_by(matchtable.c.id)
+            .execute()
+            .fetchall()
+        )
         eq_([1, 3, 5], [r.id for r in results2])
 
     def test_and_match(self):
-        results1 = (matchtable.select().
-                    where(and_(matchtable.c.title.match('python'),
-                               matchtable.c.title.match('nutshell'))).
-                    execute().
-                    fetchall())
+        results1 = (
+            matchtable.select()
+            .where(
+                and_(
+                    matchtable.c.title.match("python"),
+                    matchtable.c.title.match("nutshell"),
+                )
+            )
+            .execute()
+            .fetchall()
+        )
         eq_([5], [r.id for r in results1])
-        results2 = (matchtable.select().
-                    where(matchtable.c.title.match('+python +nutshell')).
-                    execute().
-                    fetchall())
+        results2 = (
+            matchtable.select()
+            .where(matchtable.c.title.match("+python +nutshell"))
+            .execute()
+            .fetchall()
+        )
         eq_([5], [r.id for r in results2])
 
     def test_match_across_joins(self):
-        results = (matchtable.select().
-                   where(and_(cattable.c.id == matchtable.c.category_id,
-                              or_(cattable.c.description.match('Ruby'),
-                                  matchtable.c.title.match('nutshell')))).
-                   order_by(matchtable.c.id).
-                   execute().
-                   fetchall())
+        results = (
+            matchtable.select()
+            .where(
+                and_(
+                    cattable.c.id == matchtable.c.category_id,
+                    or_(
+                        cattable.c.description.match("Ruby"),
+                        matchtable.c.title.match("nutshell"),
+                    ),
+                )
+            )
+            .order_by(matchtable.c.id)
+            .execute()
+            .fetchall()
+        )
         eq_([1, 3, 5], [r.id for r in results])
 
 
 class AnyAllTest(fixtures.TablesTest):
-    __only_on__ = 'mysql'
+    __only_on__ = "mysql"
     __backend__ = True
 
     @classmethod
     def define_tables(cls, metadata):
         Table(
-            'stuff', metadata,
-            Column('id', Integer, primary_key=True),
-            Column('value', Integer)
+            "stuff",
+            metadata,
+            Column("id", Integer, primary_key=True),
+            Column("value", Integer),
         )
 
     @classmethod
@@ -177,38 +221,32 @@ class AnyAllTest(fixtures.TablesTest):
         testing.db.execute(
             stuff.insert(),
             [
-                {'id': 1, 'value': 1},
-                {'id': 2, 'value': 2},
-                {'id': 3, 'value': 3},
-                {'id': 4, 'value': 4},
-                {'id': 5, 'value': 5},
-            ]
+                {"id": 1, "value": 1},
+                {"id": 2, "value": 2},
+                {"id": 3, "value": 3},
+                {"id": 4, "value": 4},
+                {"id": 5, "value": 5},
+            ],
         )
 
     def test_any_w_comparator(self):
         stuff = self.tables.stuff
         stmt = select([stuff.c.id]).where(
-            stuff.c.value > any_(select([stuff.c.value])))
-
-        eq_(
-            testing.db.execute(stmt).fetchall(),
-            [(2,), (3,), (4,), (5,)]
+            stuff.c.value > any_(select([stuff.c.value]))
         )
 
+        eq_(testing.db.execute(stmt).fetchall(), [(2,), (3,), (4,), (5,)])
+
     def test_all_w_comparator(self):
         stuff = self.tables.stuff
         stmt = select([stuff.c.id]).where(
-            stuff.c.value >= all_(select([stuff.c.value])))
-
-        eq_(
-            testing.db.execute(stmt).fetchall(),
-            [(5,)]
+            stuff.c.value >= all_(select([stuff.c.value]))
         )
 
+        eq_(testing.db.execute(stmt).fetchall(), [(5,)])
+
     def test_any_literal(self):
         stuff = self.tables.stuff
         stmt = select([4 == any_(select([stuff.c.value]))])
 
-        is_(
-            testing.db.execute(stmt).scalar(), True
-        )
+        is_(testing.db.execute(stmt).scalar(), True)