Post black reformatting

Applied on top of a pure run of black -l 79 in
I7eda77fed3d8e73df84b3651fd6cfcfe858d4dc9,  this set of changes
resolves all remaining flake8 conditions for those codes
we have enabled in setup.cfg.

Included are resolutions for all remaining flake8 issues
including shadowed builtins, long lines, import order, unused
imports, duplicate imports, and docstring issues.

Change-Id: I4f72d3ba1380dd601610ff80b8fb06a2aff8b0fe

30 files changed, 851 insertions, 768 deletions

diff --git a/test/sql/test_case_statement.py b/test/sql/test_case_statement.py
index 181dd79a1..7bb612cfa 100644
--- a/test/sql/test_case_statement.py
+++ b/test/sql/test_case_statement.py
@@ -1,21 +1,23 @@
-from sqlalchemy.testing import assert_raises, eq_, assert_raises_message
-from sqlalchemy.testing import fixtures, AssertsCompiledSQL
-from sqlalchemy import (
-    testing,
-    exc,
-    case,
-    select,
-    literal_column,
-    text,
-    and_,
-    Integer,
-    cast,
-    String,
-    Column,
-    Table,
-    MetaData,
-)
-from sqlalchemy.sql import table, column
+from sqlalchemy import and_
+from sqlalchemy import case
+from sqlalchemy import cast
+from sqlalchemy import Column
+from sqlalchemy import exc
+from sqlalchemy import Integer
+from sqlalchemy import literal_column
+from sqlalchemy import MetaData
+from sqlalchemy import select
+from sqlalchemy import String
+from sqlalchemy import Table
+from sqlalchemy import testing
+from sqlalchemy import text
+from sqlalchemy.sql import column
+from sqlalchemy.sql import table
+from sqlalchemy.testing import assert_raises_message
+from sqlalchemy.testing import AssertsCompiledSQL
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing import fixtures
+
 
 info_table = None
 
diff --git a/test/sql/test_compiler.py b/test/sql/test_compiler.py
index f3305743a..f152d0ed9 100644
--- a/test/sql/test_compiler.py
+++ b/test/sql/test_compiler.py
@@ -10,76 +10,79 @@ styling and coherent test organization.
 
 """
 
-from sqlalchemy.testing import (
-    eq_,
-    is_,
-    assert_raises,
-    assert_raises_message,
-    eq_ignore_whitespace,
-)
-from sqlalchemy import testing
-from sqlalchemy.testing import fixtures, AssertsCompiledSQL
-from sqlalchemy import (
-    Integer,
-    String,
-    MetaData,
-    Table,
-    Column,
-    select,
-    func,
-    not_,
-    cast,
-    text,
-    tuple_,
-    exists,
-    update,
-    bindparam,
-    literal,
-    and_,
-    null,
-    type_coerce,
-    alias,
-    or_,
-    literal_column,
-    Float,
-    TIMESTAMP,
-    Numeric,
-    Date,
-    Text,
-    union,
-    except_,
-    intersect,
-    union_all,
-    Boolean,
-    distinct,
-    join,
-    outerjoin,
-    asc,
-    desc,
-    over,
-    subquery,
-    case,
-    true,
-    CheckConstraint,
-    Sequence,
-)
 import decimal
-from sqlalchemy.util import u
-from sqlalchemy import exc, sql, util, types, schema
-from sqlalchemy.sql import table, column, label
-from sqlalchemy.sql.expression import ClauseList, _literal_as_text, HasPrefixes
+
+from sqlalchemy import alias
+from sqlalchemy import and_
+from sqlalchemy import asc
+from sqlalchemy import bindparam
+from sqlalchemy import Boolean
+from sqlalchemy import case
+from sqlalchemy import cast
+from sqlalchemy import CheckConstraint
+from sqlalchemy import Column
+from sqlalchemy import Date
+from sqlalchemy import desc
+from sqlalchemy import distinct
+from sqlalchemy import exc
+from sqlalchemy import except_
+from sqlalchemy import exists
+from sqlalchemy import Float
+from sqlalchemy import func
+from sqlalchemy import Integer
+from sqlalchemy import intersect
+from sqlalchemy import join
+from sqlalchemy import literal
+from sqlalchemy import literal_column
+from sqlalchemy import MetaData
+from sqlalchemy import not_
+from sqlalchemy import null
+from sqlalchemy import Numeric
+from sqlalchemy import or_
+from sqlalchemy import outerjoin
+from sqlalchemy import over
+from sqlalchemy import schema
+from sqlalchemy import select
+from sqlalchemy import Sequence
+from sqlalchemy import sql
+from sqlalchemy import String
+from sqlalchemy import subquery
+from sqlalchemy import Table
+from sqlalchemy import Text
+from sqlalchemy import text
+from sqlalchemy import TIMESTAMP
+from sqlalchemy import true
+from sqlalchemy import tuple_
+from sqlalchemy import type_coerce
+from sqlalchemy import types
+from sqlalchemy import union
+from sqlalchemy import union_all
+from sqlalchemy import util
+from sqlalchemy.dialects import mysql
+from sqlalchemy.dialects import oracle
+from sqlalchemy.dialects import postgresql
+from sqlalchemy.dialects import sqlite
+from sqlalchemy.dialects import sybase
+from sqlalchemy.dialects.postgresql.base import PGCompiler
+from sqlalchemy.dialects.postgresql.base import PGDialect
 from sqlalchemy.engine import default
-from sqlalchemy.dialects import (
-    mysql,
-    mssql,
-    postgresql,
-    oracle,
-    sqlite,
-    sybase,
-)
-from sqlalchemy.dialects.postgresql.base import PGCompiler, PGDialect
 from sqlalchemy.ext.compiler import compiles
+from sqlalchemy.sql import column
 from sqlalchemy.sql import compiler
+from sqlalchemy.sql import label
+from sqlalchemy.sql import table
+from sqlalchemy.sql.expression import _literal_as_text
+from sqlalchemy.sql.expression import ClauseList
+from sqlalchemy.sql.expression import HasPrefixes
+from sqlalchemy.testing import assert_raises
+from sqlalchemy.testing import assert_raises_message
+from sqlalchemy.testing import AssertsCompiledSQL
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing import eq_ignore_whitespace
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing import is_
+from sqlalchemy.util import u
+
 
 table1 = table(
     "mytable",
@@ -958,14 +961,14 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL):
             "zips", column("zipcode"), column("latitude"), column("longitude")
         )
         places = table("places", column("id"), column("nm"))
-        zip = "12345"
+        zipcode = "12345"
         qlat = (
-            select([zips.c.latitude], zips.c.zipcode == zip)
+            select([zips.c.latitude], zips.c.zipcode == zipcode)
             .correlate(None)
             .as_scalar()
         )
         qlng = (
-            select([zips.c.longitude], zips.c.zipcode == zip)
+            select([zips.c.longitude], zips.c.zipcode == zipcode)
             .correlate(None)
             .as_scalar()
         )
@@ -977,7 +980,7 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL):
                 zips.c.zipcode,
                 func.latlondist(qlat, qlng).label("dist"),
             ],
-            zips.c.zipcode == zip,
+            zips.c.zipcode == zipcode,
             order_by=["dist", places.c.nm],
         )
 
@@ -3380,7 +3383,7 @@ class DDLTest(fixtures.TestBase, AssertsCompiledSQL):
             pass
 
         @compiles(MyType)
-        def compile(element, compiler, **kw):
+        def compile_(element, compiler, **kw):
             raise exc.CompileError("Couldn't compile type")
 
         return MyType
diff --git a/test/sql/test_constraints.py b/test/sql/test_constraints.py
index a5d2043ce..fdc973156 100644
--- a/test/sql/test_constraints.py
+++ b/test/sql/test_constraints.py
@@ -1,37 +1,32 @@
-from sqlalchemy.testing import assert_raises, assert_raises_message
-from sqlalchemy import (
-    Table,
-    Integer,
-    String,
-    Column,
-    PrimaryKeyConstraint,
-    ForeignKeyConstraint,
-    ForeignKey,
-    UniqueConstraint,
-    Index,
-    MetaData,
-    CheckConstraint,
-    func,
-    text,
-)
-from sqlalchemy import exc, schema
-from sqlalchemy.testing import (
-    fixtures,
-    AssertsExecutionResults,
-    AssertsCompiledSQL,
-)
+from sqlalchemy import CheckConstraint
+from sqlalchemy import Column
+from sqlalchemy import exc
+from sqlalchemy import ForeignKey
+from sqlalchemy import ForeignKeyConstraint
+from sqlalchemy import func
+from sqlalchemy import Index
+from sqlalchemy import Integer
+from sqlalchemy import MetaData
+from sqlalchemy import PrimaryKeyConstraint
+from sqlalchemy import schema
+from sqlalchemy import String
+from sqlalchemy import Table
 from sqlalchemy import testing
+from sqlalchemy import text
+from sqlalchemy import UniqueConstraint
 from sqlalchemy.engine import default
+from sqlalchemy.testing import assert_raises
+from sqlalchemy.testing import assert_raises_message
+from sqlalchemy.testing import AssertsCompiledSQL
+from sqlalchemy.testing import AssertsExecutionResults
 from sqlalchemy.testing import engines
-from sqlalchemy.testing.assertions import expect_warnings
 from sqlalchemy.testing import eq_
-from sqlalchemy.testing.assertsql import (
-    AllOf,
-    RegexSQL,
-    CompiledSQL,
-    DialectSQL,
-)
-from sqlalchemy.sql import table, column
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing.assertions import expect_warnings
+from sqlalchemy.testing.assertsql import AllOf
+from sqlalchemy.testing.assertsql import CompiledSQL
+from sqlalchemy.testing.assertsql import DialectSQL
+from sqlalchemy.testing.assertsql import RegexSQL
 
 
 class ConstraintGenTest(fixtures.TestBase, AssertsExecutionResults):
diff --git a/test/sql/test_cte.py b/test/sql/test_cte.py
index 74c32387f..ed2787b0f 100644
--- a/test/sql/test_cte.py
+++ b/test/sql/test_cte.py
@@ -1,20 +1,20 @@
-from sqlalchemy.testing import fixtures, eq_
-from sqlalchemy.testing import AssertsCompiledSQL, assert_raises_message
-from sqlalchemy.sql import (
-    table,
-    column,
-    select,
-    func,
-    literal,
-    exists,
-    and_,
-    bindparam,
-)
 from sqlalchemy.dialects import mssql
 from sqlalchemy.engine import default
 from sqlalchemy.exc import CompileError
+from sqlalchemy.sql import and_
+from sqlalchemy.sql import bindparam
+from sqlalchemy.sql import column
+from sqlalchemy.sql import exists
+from sqlalchemy.sql import func
+from sqlalchemy.sql import literal
+from sqlalchemy.sql import select
+from sqlalchemy.sql import table
 from sqlalchemy.sql.elements import quoted_name
 from sqlalchemy.sql.visitors import cloned_traverse
+from sqlalchemy.testing import assert_raises_message
+from sqlalchemy.testing import AssertsCompiledSQL
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing import fixtures
 
 
 class CTETest(fixtures.TestBase, AssertsCompiledSQL):
@@ -245,7 +245,7 @@ class CTETest(fixtures.TestBase, AssertsCompiledSQL):
     def test_recursive_union_no_alias_two(self):
         """
 
-        pg's example:
+        pg's example::
 
             WITH RECURSIVE t(n) AS (
                 VALUES (1)
diff --git a/test/sql/test_ddlemit.py b/test/sql/test_ddlemit.py
index 6c949f9ee..3cdbfaecc 100644
--- a/test/sql/test_ddlemit.py
+++ b/test/sql/test_ddlemit.py
@@ -1,7 +1,13 @@
-from sqlalchemy.testing import fixtures
-from sqlalchemy.sql.ddl import SchemaGenerator, SchemaDropper
-from sqlalchemy import MetaData, Table, Column, Integer, Sequence, ForeignKey
+from sqlalchemy import Column
+from sqlalchemy import ForeignKey
+from sqlalchemy import Integer
+from sqlalchemy import MetaData
 from sqlalchemy import schema
+from sqlalchemy import Sequence
+from sqlalchemy import Table
+from sqlalchemy.sql.ddl import SchemaDropper
+from sqlalchemy.sql.ddl import SchemaGenerator
+from sqlalchemy.testing import fixtures
 from sqlalchemy.testing.mock import Mock
 
 
diff --git a/test/sql/test_defaults.py b/test/sql/test_defaults.py
index b518a606f..5ede46ede 100644
--- a/test/sql/test_defaults.py
+++ b/test/sql/test_defaults.py
@@ -1,39 +1,45 @@
-from sqlalchemy.testing import (
-    eq_,
-    assert_raises_message,
-    assert_raises,
-    AssertsCompiledSQL,
-    expect_warnings,
-)
 import datetime
-from sqlalchemy.schema import CreateSequence, DropSequence, CreateTable
-from sqlalchemy.sql import select, text, literal_column
+import itertools
+
 import sqlalchemy as sa
+from sqlalchemy import Boolean
+from sqlalchemy import cast
+from sqlalchemy import DateTime
+from sqlalchemy import exc
+from sqlalchemy import ForeignKey
+from sqlalchemy import func
+from sqlalchemy import Integer
+from sqlalchemy import literal
+from sqlalchemy import MetaData
+from sqlalchemy import Sequence
+from sqlalchemy import String
 from sqlalchemy import testing
-from sqlalchemy.testing import engines
-from sqlalchemy import (
-    MetaData,
-    Integer,
-    String,
-    ForeignKey,
-    Boolean,
-    exc,
-    Sequence,
-    func,
-    literal,
-    Unicode,
-    cast,
-    DateTime,
-)
-from sqlalchemy.types import TypeDecorator, TypeEngine
-from sqlalchemy.testing.schema import Table, Column
+from sqlalchemy import Unicode
+from sqlalchemy import util
 from sqlalchemy.dialects import sqlite
+from sqlalchemy.schema import CreateSequence
+from sqlalchemy.schema import CreateTable
+from sqlalchemy.schema import DropSequence
+from sqlalchemy.sql import literal_column
+from sqlalchemy.sql import select
+from sqlalchemy.sql import text
+from sqlalchemy.testing import assert_raises_message
+from sqlalchemy.testing import AssertsCompiledSQL
+from sqlalchemy.testing import engines
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing import expect_warnings
 from sqlalchemy.testing import fixtures
-from sqlalchemy.util import u, b
-from sqlalchemy import util
 from sqlalchemy.testing import mock
-import itertools
-from sqlalchemy.testing.assertsql import CompiledSQL, AllOf, EachOf
+from sqlalchemy.testing.assertsql import AllOf
+from sqlalchemy.testing.assertsql import CompiledSQL
+from sqlalchemy.testing.assertsql import EachOf
+from sqlalchemy.testing.schema import Column
+from sqlalchemy.testing.schema import Table
+from sqlalchemy.types import TypeDecorator
+from sqlalchemy.types import TypeEngine
+from sqlalchemy.util import b
+from sqlalchemy.util import u
+
 
 t = f = f2 = ts = currenttime = metadata = default_generator = None
 
diff --git a/test/sql/test_delete.py b/test/sql/test_delete.py
index cb5e696f2..f572a510c 100644
--- a/test/sql/test_delete.py
+++ b/test/sql/test_delete.py
@@ -1,26 +1,23 @@
 #! coding:utf-8
 
-from sqlalchemy import (
-    Integer,
-    String,
-    ForeignKey,
-    delete,
-    select,
-    and_,
-    or_,
-    exists,
-)
+from sqlalchemy import and_
+from sqlalchemy import delete
+from sqlalchemy import exc
+from sqlalchemy import exists
+from sqlalchemy import ForeignKey
+from sqlalchemy import Integer
+from sqlalchemy import or_
+from sqlalchemy import select
+from sqlalchemy import String
+from sqlalchemy import testing
 from sqlalchemy.dialects import mysql
 from sqlalchemy.engine import default
-from sqlalchemy import testing
-from sqlalchemy import exc
-from sqlalchemy.testing import (
-    AssertsCompiledSQL,
-    fixtures,
-    eq_,
-    assert_raises_message,
-)
-from sqlalchemy.testing.schema import Table, Column
+from sqlalchemy.testing import assert_raises_message
+from sqlalchemy.testing import AssertsCompiledSQL
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing.schema import Column
+from sqlalchemy.testing.schema import Table
 
 
 class _DeleteTestBase(object):
diff --git a/test/sql/test_functions.py b/test/sql/test_functions.py
index b775df740..83277ae98 100644
--- a/test/sql/test_functions.py
+++ b/test/sql/test_functions.py
@@ -1,36 +1,46 @@
-from sqlalchemy.testing import eq_, is_
 import datetime
-from sqlalchemy import (
-    func,
-    select,
-    Integer,
-    literal,
-    DateTime,
-    Table,
-    Column,
-    Sequence,
-    MetaData,
-    extract,
-    Date,
-    String,
-    bindparam,
-    literal_column,
-    ARRAY,
-    Numeric,
-    Boolean,
-)
-from sqlalchemy.sql import table, column
-from sqlalchemy import sql, util
-from sqlalchemy.sql.compiler import BIND_TEMPLATES
-from sqlalchemy.testing.engines import all_dialects
-from sqlalchemy import types as sqltypes
-from sqlalchemy.sql import functions
-from sqlalchemy.sql.functions import GenericFunction, FunctionElement
 import decimal
+
+from sqlalchemy import ARRAY
+from sqlalchemy import bindparam
+from sqlalchemy import Boolean
+from sqlalchemy import Column
+from sqlalchemy import Date
+from sqlalchemy import DateTime
+from sqlalchemy import extract
+from sqlalchemy import func
+from sqlalchemy import Integer
+from sqlalchemy import literal
+from sqlalchemy import literal_column
+from sqlalchemy import MetaData
+from sqlalchemy import Numeric
+from sqlalchemy import select
+from sqlalchemy import Sequence
+from sqlalchemy import sql
+from sqlalchemy import String
+from sqlalchemy import Table
 from sqlalchemy import testing
-from sqlalchemy.testing import fixtures, AssertsCompiledSQL, engines
-from sqlalchemy.dialects import sqlite, postgresql, mysql, oracle
-from sqlalchemy.testing import assert_raises_message, assert_raises
+from sqlalchemy import types as sqltypes
+from sqlalchemy import util
+from sqlalchemy.dialects import mysql
+from sqlalchemy.dialects import oracle
+from sqlalchemy.dialects import postgresql
+from sqlalchemy.dialects import sqlite
+from sqlalchemy.sql import column
+from sqlalchemy.sql import functions
+from sqlalchemy.sql import table
+from sqlalchemy.sql.compiler import BIND_TEMPLATES
+from sqlalchemy.sql.functions import FunctionElement
+from sqlalchemy.sql.functions import GenericFunction
+from sqlalchemy.testing import assert_raises
+from sqlalchemy.testing import assert_raises_message
+from sqlalchemy.testing import AssertsCompiledSQL
+from sqlalchemy.testing import engines
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing import is_
+from sqlalchemy.testing.engines import all_dialects
+
 
 table1 = table(
     "mytable",
@@ -795,7 +805,7 @@ class ExecuteTest(fixtures.TestBase):
             type = Date()
 
         @compiles(myfunc)
-        def compile(elem, compiler, **kw):
+        def compile_(elem, compiler, **kw):
             return compiler.process(func.current_date())
 
         conn = testing.db.connect()
@@ -861,8 +871,8 @@ class ExecuteTest(fixtures.TestBase):
         assert t.select().execute().first()["value"] == 5
 
         r = t.insert(values=dict(value=func.length("sfsaafsda"))).execute()
-        id = r.inserted_primary_key[0]
-        assert t.select(t.c.id == id).execute().first()["value"] == 9
+        id_ = r.inserted_primary_key[0]
+        assert t.select(t.c.id == id_).execute().first()["value"] == 9
         t.update(values={t.c.value: func.length("asdf")}).execute()
         assert t.select().execute().first()["value"] == 4
         t2.insert().execute()
@@ -897,6 +907,7 @@ class ExecuteTest(fixtures.TestBase):
         t2.update(
             values={t2.c.value: func.length("asfdaasdf"), t2.c.stuff: "foo"}
         ).execute()
+
         eq_(select([t2.c.value, t2.c.stuff]).execute().first(), (9, "foo"))
 
     @testing.fails_on_everything_except("postgresql")
diff --git a/test/sql/test_generative.py b/test/sql/test_generative.py
index 1d064dd3a..1e6221cdc 100644
--- a/test/sql/test_generative.py
+++ b/test/sql/test_generative.py
@@ -1,45 +1,42 @@
-from sqlalchemy.sql import table, column, ClauseElement, operators
-from sqlalchemy.sql.expression import _clone, _from_objects
-from sqlalchemy import (
-    func,
-    select,
-    Integer,
-    Table,
-    Column,
-    MetaData,
-    extract,
-    String,
-    bindparam,
-    tuple_,
-    and_,
-    union,
-    text,
-    case,
-    ForeignKey,
-    literal_column,
-)
-from sqlalchemy.testing import (
-    fixtures,
-    AssertsExecutionResults,
-    AssertsCompiledSQL,
-)
-from sqlalchemy import testing
-from sqlalchemy.sql.visitors import (
-    ClauseVisitor,
-    CloningVisitor,
-    cloned_traverse,
-    ReplacingCloningVisitor,
-)
-from sqlalchemy.sql import visitors
+from sqlalchemy import and_
+from sqlalchemy import bindparam
+from sqlalchemy import case
+from sqlalchemy import Column
 from sqlalchemy import exc
+from sqlalchemy import extract
+from sqlalchemy import ForeignKey
+from sqlalchemy import func
+from sqlalchemy import Integer
+from sqlalchemy import literal_column
+from sqlalchemy import MetaData
+from sqlalchemy import select
+from sqlalchemy import String
+from sqlalchemy import Table
+from sqlalchemy import testing
+from sqlalchemy import text
+from sqlalchemy import tuple_
+from sqlalchemy import union
+from sqlalchemy.sql import ClauseElement
+from sqlalchemy.sql import column
+from sqlalchemy.sql import operators
+from sqlalchemy.sql import table
 from sqlalchemy.sql import util as sql_util
-from sqlalchemy.testing import (
-    eq_,
-    is_,
-    is_not_,
-    assert_raises,
-    assert_raises_message,
-)
+from sqlalchemy.sql import visitors
+from sqlalchemy.sql.expression import _clone
+from sqlalchemy.sql.expression import _from_objects
+from sqlalchemy.sql.visitors import ClauseVisitor
+from sqlalchemy.sql.visitors import cloned_traverse
+from sqlalchemy.sql.visitors import CloningVisitor
+from sqlalchemy.sql.visitors import ReplacingCloningVisitor
+from sqlalchemy.testing import assert_raises
+from sqlalchemy.testing import assert_raises_message
+from sqlalchemy.testing import AssertsCompiledSQL
+from sqlalchemy.testing import AssertsExecutionResults
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing import is_
+from sqlalchemy.testing import is_not_
+
 
 A = B = t1 = t2 = t3 = table1 = table2 = table3 = table4 = None
 
@@ -230,9 +227,9 @@ class TraversalTest(fixtures.TestBase, AssertsExecutionResults):
         assert CustomObj.__visit_name__ == Column.__visit_name__ == "column"
 
         foo, bar = CustomObj("foo", String), CustomObj("bar", String)
-        bin = foo == bar
-        set(ClauseVisitor().iterate(bin))
-        assert set(ClauseVisitor().iterate(bin)) == set([foo, bar, bin])
+        bin_ = foo == bar
+        set(ClauseVisitor().iterate(bin_))
+        assert set(ClauseVisitor().iterate(bin_)) == set([foo, bar, bin_])
 
 
 class BinaryEndpointTraversalTest(fixtures.TestBase):
diff --git a/test/sql/test_insert.py b/test/sql/test_insert.py
index 3643deabd..066e54e93 100644
--- a/test/sql/test_insert.py
+++ b/test/sql/test_insert.py
@@ -1,32 +1,29 @@
 #! coding:utf-8
 
-from sqlalchemy import (
-    Column,
-    Integer,
-    MetaData,
-    String,
-    Table,
-    bindparam,
-    exc,
-    func,
-    insert,
-    select,
-    column,
-    text,
-    table,
-    Sequence,
-)
-from sqlalchemy.dialects import mysql, postgresql
+from sqlalchemy import bindparam
+from sqlalchemy import Column
+from sqlalchemy import column
+from sqlalchemy import exc
+from sqlalchemy import func
+from sqlalchemy import insert
+from sqlalchemy import Integer
+from sqlalchemy import MetaData
+from sqlalchemy import select
+from sqlalchemy import Sequence
+from sqlalchemy import String
+from sqlalchemy import Table
+from sqlalchemy import table
+from sqlalchemy import text
+from sqlalchemy.dialects import mysql
+from sqlalchemy.dialects import postgresql
 from sqlalchemy.engine import default
-from sqlalchemy.testing import (
-    AssertsCompiledSQL,
-    assert_raises_message,
-    fixtures,
-    eq_,
-    expect_warnings,
-    assert_raises,
-)
 from sqlalchemy.sql import crud
+from sqlalchemy.testing import assert_raises
+from sqlalchemy.testing import assert_raises_message
+from sqlalchemy.testing import AssertsCompiledSQL
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing import expect_warnings
+from sqlalchemy.testing import fixtures
 
 
 class _InsertTestBase(object):
diff --git a/test/sql/test_insert_exec.py b/test/sql/test_insert_exec.py
index 7803de75e..fafe7cc9b 100644
--- a/test/sql/test_insert_exec.py
+++ b/test/sql/test_insert_exec.py
@@ -1,20 +1,22 @@
-from sqlalchemy.testing import eq_, assert_raises_message, is_
+from sqlalchemy import and_
+from sqlalchemy import exc
+from sqlalchemy import ForeignKey
+from sqlalchemy import func
+from sqlalchemy import INT
+from sqlalchemy import Integer
+from sqlalchemy import MetaData
+from sqlalchemy import Sequence
+from sqlalchemy import sql
+from sqlalchemy import String
 from sqlalchemy import testing
-from sqlalchemy.testing import fixtures, engines
-from sqlalchemy import (
-    exc,
-    sql,
-    String,
-    Integer,
-    MetaData,
-    and_,
-    ForeignKey,
-    VARCHAR,
-    INT,
-    Sequence,
-    func,
-)
-from sqlalchemy.testing.schema import Table, Column
+from sqlalchemy import VARCHAR
+from sqlalchemy.testing import assert_raises_message
+from sqlalchemy.testing import engines
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing import is_
+from sqlalchemy.testing.schema import Column
+from sqlalchemy.testing.schema import Table
 
 
 class InsertExecTest(fixtures.TablesTest):
@@ -94,16 +96,16 @@ class InsertExecTest(fixtures.TablesTest):
             result = engine.execute(table_.insert(), **values)
             ret = values.copy()
 
-            for col, id in zip(
+            for col, id_ in zip(
                 table_.primary_key, result.inserted_primary_key
             ):
-                ret[col.key] = id
+                ret[col.key] = id_
 
             if result.lastrow_has_defaults():
                 criterion = and_(
                     *[
-                        col == id
-                        for col, id in zip(
+                        col == id_
+                        for col, id_ in zip(
                             table_.primary_key, result.inserted_primary_key
                         )
                     ]
diff --git a/test/sql/test_inspect.py b/test/sql/test_inspect.py
index 0e78c06c8..0b7aa7a55 100644
--- a/test/sql/test_inspect.py
+++ b/test/sql/test_inspect.py
@@ -1,7 +1,10 @@
 """test the inspection registry system."""
 
+from sqlalchemy import Column
 from sqlalchemy import inspect
-from sqlalchemy import Table, Column, Integer, MetaData
+from sqlalchemy import Integer
+from sqlalchemy import MetaData
+from sqlalchemy import Table
 from sqlalchemy.testing import fixtures
 from sqlalchemy.testing import is_
 
diff --git a/test/sql/test_join_rewriting.py b/test/sql/test_join_rewriting.py
index dd74406fd..59bbc1104 100644
--- a/test/sql/test_join_rewriting.py
+++ b/test/sql/test_join_rewriting.py
@@ -3,20 +3,19 @@ to support SQLite's lack of right-nested joins.  SQlite as of
 version 3.7.16 no longer has this limitation.
 
 """
-from sqlalchemy import (
-    Table,
-    Column,
-    Integer,
-    MetaData,
-    ForeignKey,
-    select,
-    exists,
-    union,
-)
-from sqlalchemy.testing import fixtures, AssertsCompiledSQL
+from sqlalchemy import Column
+from sqlalchemy import exists
+from sqlalchemy import ForeignKey
+from sqlalchemy import Integer
+from sqlalchemy import MetaData
+from sqlalchemy import select
+from sqlalchemy import Table
+from sqlalchemy import testing
+from sqlalchemy import union
 from sqlalchemy import util
 from sqlalchemy.engine import default
-from sqlalchemy import testing
+from sqlalchemy.testing import AssertsCompiledSQL
+from sqlalchemy.testing import fixtures
 
 
 m = MetaData()
diff --git a/test/sql/test_labels.py b/test/sql/test_labels.py
index 8dfaa6859..901f941be 100644
--- a/test/sql/test_labels.py
+++ b/test/sql/test_labels.py
@@ -1,22 +1,21 @@
-from sqlalchemy import (
-    exc as exceptions,
-    select,
-    MetaData,
-    Integer,
-    or_,
-    bindparam,
-)
+from sqlalchemy import bindparam
+from sqlalchemy import exc as exceptions
+from sqlalchemy import Integer
+from sqlalchemy import MetaData
+from sqlalchemy import or_
+from sqlalchemy import select
 from sqlalchemy.engine import default
-from sqlalchemy.sql import table, column
+from sqlalchemy.sql import column
+from sqlalchemy.sql import table
 from sqlalchemy.sql.elements import _truncated_label
-from sqlalchemy.testing import (
-    AssertsCompiledSQL,
-    assert_raises,
-    engines,
-    fixtures,
-    eq_,
-)
-from sqlalchemy.testing.schema import Table, Column
+from sqlalchemy.testing import assert_raises
+from sqlalchemy.testing import AssertsCompiledSQL
+from sqlalchemy.testing import engines
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing.schema import Column
+from sqlalchemy.testing.schema import Table
+
 
 IDENT_LENGTH = 29
 
diff --git a/test/sql/test_lateral.py b/test/sql/test_lateral.py
index 163f636f6..ee43475c8 100644
--- a/test/sql/test_lateral.py
+++ b/test/sql/test_lateral.py
@@ -1,10 +1,16 @@
-from sqlalchemy.testing import fixtures
-from sqlalchemy.testing import AssertsCompiledSQL, assert_raises_message
-from sqlalchemy.sql import select, func
+from sqlalchemy import Column
+from sqlalchemy import ForeignKey
+from sqlalchemy import Integer
+from sqlalchemy import join
+from sqlalchemy import lateral
+from sqlalchemy import String
+from sqlalchemy import Table
+from sqlalchemy import true
 from sqlalchemy.engine import default
-from sqlalchemy import exc
-from sqlalchemy import Table, Integer, String, ForeignKey, Column, true
-from sqlalchemy import lateral, outerjoin, join
+from sqlalchemy.sql import func
+from sqlalchemy.sql import select
+from sqlalchemy.testing import AssertsCompiledSQL
+from sqlalchemy.testing import fixtures
 
 
 class LateralTest(fixtures.TablesTest, AssertsCompiledSQL):
diff --git a/test/sql/test_metadata.py b/test/sql/test_metadata.py
index 9a28b0c7b..a6d4b2d1a 100644
--- a/test/sql/test_metadata.py
+++ b/test/sql/test_metadata.py
@@ -1,45 +1,49 @@
-from sqlalchemy.testing import assert_raises
-from sqlalchemy.testing import assert_raises_message
-from sqlalchemy.testing import emits_warning
+from contextlib import contextmanager
 import pickle
-from sqlalchemy import (
-    Integer,
-    String,
-    UniqueConstraint,
-    CheckConstraint,
-    ForeignKey,
-    MetaData,
-    Sequence,
-    ForeignKeyConstraint,
-    PrimaryKeyConstraint,
-    ColumnDefault,
-    Index,
-    event,
-    events,
-    Unicode,
-    types as sqltypes,
-    bindparam,
-    Table,
-    Column,
-    Boolean,
-    Enum,
-    func,
-    text,
-    TypeDecorator,
-    BLANK_SCHEMA,
-    ARRAY,
-)
-from sqlalchemy import schema, exc
-from sqlalchemy.engine import default
-from sqlalchemy.sql import elements, naming
+
 import sqlalchemy as tsa
-from sqlalchemy.testing import fixtures
+from sqlalchemy import ARRAY
+from sqlalchemy import bindparam
+from sqlalchemy import BLANK_SCHEMA
+from sqlalchemy import Boolean
+from sqlalchemy import CheckConstraint
+from sqlalchemy import Column
+from sqlalchemy import ColumnDefault
+from sqlalchemy import Enum
+from sqlalchemy import event
+from sqlalchemy import exc
+from sqlalchemy import ForeignKey
+from sqlalchemy import ForeignKeyConstraint
+from sqlalchemy import func
+from sqlalchemy import Index
+from sqlalchemy import Integer
+from sqlalchemy import MetaData
+from sqlalchemy import PrimaryKeyConstraint
+from sqlalchemy import schema
+from sqlalchemy import Sequence
+from sqlalchemy import String
+from sqlalchemy import Table
 from sqlalchemy import testing
-from sqlalchemy.testing import ComparesTables, AssertsCompiledSQL
-from sqlalchemy.testing import eq_, is_, mock, is_true, is_false
-from contextlib import contextmanager
+from sqlalchemy import text
+from sqlalchemy import TypeDecorator
+from sqlalchemy import types as sqltypes
+from sqlalchemy import Unicode
+from sqlalchemy import UniqueConstraint
 from sqlalchemy import util
-from sqlalchemy.testing import engines
+from sqlalchemy.engine import default
+from sqlalchemy.sql import elements
+from sqlalchemy.sql import naming
+from sqlalchemy.testing import assert_raises
+from sqlalchemy.testing import assert_raises_message
+from sqlalchemy.testing import AssertsCompiledSQL
+from sqlalchemy.testing import ComparesTables
+from sqlalchemy.testing import emits_warning
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing import is_
+from sqlalchemy.testing import is_false
+from sqlalchemy.testing import is_true
+from sqlalchemy.testing import mock
 
 
 class MetaDataTest(fixtures.TestBase, ComparesTables):
@@ -526,7 +530,7 @@ class MetaDataTest(fixtures.TestBase, ComparesTables):
             (
                 name,
                 metadata,
-                schema,
+                schema_,
                 quote_schema,
                 exp_schema,
                 exp_quote_schema,
@@ -554,8 +558,8 @@ class MetaDataTest(fixtures.TestBase, ComparesTables):
             ]
         ):
             kw = {}
-            if schema is not None:
-                kw["schema"] = schema
+            if schema_ is not None:
+                kw["schema"] = schema_
             if quote_schema is not None:
                 kw["quote_schema"] = quote_schema
             t = Table(name, metadata, **kw)
@@ -3512,12 +3516,12 @@ class ColumnDefinitionTest(AssertsCompiledSQL, fixtures.TestBase):
         from sqlalchemy.sql import select
 
         class MyColumn(Column):
-            def _constructor(self, name, type, **kw):
+            def _constructor(self, name, type_, **kw):
                 kw["name"] = name
-                return MyColumn(type, **kw)
+                return MyColumn(type_, **kw)
 
-            def __init__(self, type, **kw):
-                Column.__init__(self, type, **kw)
+            def __init__(self, type_, **kw):
+                Column.__init__(self, type_, **kw)
 
             def my_goofy_thing(self):
                 return "hi"
@@ -3527,11 +3531,11 @@ class ColumnDefinitionTest(AssertsCompiledSQL, fixtures.TestBase):
             s = compiler.visit_column(element, **kw)
             return s + "-"
 
-        id = MyColumn(Integer, primary_key=True)
-        id.name = "id"
+        id_ = MyColumn(Integer, primary_key=True)
+        id_.name = "id"
         name = MyColumn(String)
         name.name = "name"
-        t1 = Table("foo", MetaData(), id, name)
+        t1 = Table("foo", MetaData(), id_, name)
 
         # goofy thing
         eq_(t1.c.name.my_goofy_thing(), "hi")
@@ -3555,14 +3559,14 @@ class ColumnDefinitionTest(AssertsCompiledSQL, fixtures.TestBase):
         from sqlalchemy.sql import select
 
         class MyColumn(Column):
-            def __init__(self, type, **kw):
-                Column.__init__(self, type, **kw)
+            def __init__(self, type_, **kw):
+                Column.__init__(self, type_, **kw)
 
-        id = MyColumn(Integer, primary_key=True)
-        id.name = "id"
+        id_ = MyColumn(Integer, primary_key=True)
+        id_.name = "id"
         name = MyColumn(String)
         name.name = "name"
-        t1 = Table("foo", MetaData(), id, name)
+        t1 = Table("foo", MetaData(), id_, name)
         assert_raises_message(
             TypeError,
             "Could not create a copy of this <class "
@@ -3577,7 +3581,7 @@ class ColumnDefinitionTest(AssertsCompiledSQL, fixtures.TestBase):
         from sqlalchemy.ext.compiler import compiles, deregister
 
         @compiles(schema.CreateColumn)
-        def compile(element, compiler, **kw):
+        def compile_(element, compiler, **kw):
             column = element.element
 
             if "special" not in column.info:
diff --git a/test/sql/test_operators.py b/test/sql/test_operators.py
index 2ce842caf..978d3101d 100644
--- a/test/sql/test_operators.py
+++ b/test/sql/test_operators.py
@@ -1,63 +1,68 @@
-from sqlalchemy.testing import fixtures, eq_, is_, is_not_
-from sqlalchemy import testing
-from sqlalchemy.testing import assert_raises_message
-from sqlalchemy.testing import expect_warnings
-from sqlalchemy.sql import (
-    column,
-    desc,
-    asc,
-    literal,
-    collate,
-    null,
-    true,
-    false,
-    any_,
-    all_,
-)
-from sqlalchemy.sql import sqltypes
-from sqlalchemy.sql.expression import (
-    BinaryExpression,
-    ClauseList,
-    Grouping,
-    UnaryExpression,
-    select,
-    union,
-    func,
-    tuple_,
-)
-from sqlalchemy.sql import operators, table
+import datetime
 import operator
-from sqlalchemy import String, Integer, LargeBinary
+
+from sqlalchemy import and_
+from sqlalchemy import between
 from sqlalchemy import exc
+from sqlalchemy import Integer
+from sqlalchemy import LargeBinary
+from sqlalchemy import literal_column
+from sqlalchemy import not_
+from sqlalchemy import or_
+from sqlalchemy import String
+from sqlalchemy import testing
+from sqlalchemy import text
+from sqlalchemy import util
+from sqlalchemy.dialects import firebird
+from sqlalchemy.dialects import mssql
+from sqlalchemy.dialects import mysql
+from sqlalchemy.dialects import oracle
+from sqlalchemy.dialects import postgresql
+from sqlalchemy.dialects import sqlite
 from sqlalchemy.engine import default
-from sqlalchemy.sql.elements import _literal_as_text, Label
-from sqlalchemy.schema import Column, Table, MetaData
+from sqlalchemy.schema import Column
+from sqlalchemy.schema import MetaData
+from sqlalchemy.schema import Table
+from sqlalchemy.sql import all_
+from sqlalchemy.sql import any_
+from sqlalchemy.sql import asc
+from sqlalchemy.sql import collate
+from sqlalchemy.sql import column
 from sqlalchemy.sql import compiler
-from sqlalchemy.types import (
-    TypeEngine,
-    TypeDecorator,
-    UserDefinedType,
-    Boolean,
-    MatchType,
-    Indexable,
-    Concatenable,
-    ARRAY,
-    JSON,
-    DateTime,
-)
-from sqlalchemy.dialects import (
-    mysql,
-    firebird,
-    postgresql,
-    oracle,
-    sqlite,
-    mssql,
-)
-from sqlalchemy import util
-import datetime
-import collections
-from sqlalchemy import text, literal_column
-from sqlalchemy import and_, not_, between, or_
+from sqlalchemy.sql import desc
+from sqlalchemy.sql import false
+from sqlalchemy.sql import literal
+from sqlalchemy.sql import null
+from sqlalchemy.sql import operators
+from sqlalchemy.sql import sqltypes
+from sqlalchemy.sql import table
+from sqlalchemy.sql import true
+from sqlalchemy.sql.elements import _literal_as_text
+from sqlalchemy.sql.elements import Label
+from sqlalchemy.sql.expression import BinaryExpression
+from sqlalchemy.sql.expression import ClauseList
+from sqlalchemy.sql.expression import func
+from sqlalchemy.sql.expression import Grouping
+from sqlalchemy.sql.expression import select
+from sqlalchemy.sql.expression import tuple_
+from sqlalchemy.sql.expression import UnaryExpression
+from sqlalchemy.sql.expression import union
+from sqlalchemy.testing import assert_raises_message
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing import expect_warnings
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing import is_
+from sqlalchemy.testing import is_not_
+from sqlalchemy.types import ARRAY
+from sqlalchemy.types import Boolean
+from sqlalchemy.types import Concatenable
+from sqlalchemy.types import DateTime
+from sqlalchemy.types import Indexable
+from sqlalchemy.types import JSON
+from sqlalchemy.types import MatchType
+from sqlalchemy.types import TypeDecorator
+from sqlalchemy.types import TypeEngine
+from sqlalchemy.types import UserDefinedType
 
 
 class LoopOperate(operators.ColumnOperators):
@@ -604,10 +609,10 @@ class ExtensionOperatorTest(fixtures.TestBase, testing.AssertsCompiledSQL):
 class JSONIndexOpTest(fixtures.TestBase, testing.AssertsCompiledSQL):
     def setUp(self):
         class MyTypeCompiler(compiler.GenericTypeCompiler):
-            def visit_mytype(self, type, **kw):
+            def visit_mytype(self, type_, **kw):
                 return "MYTYPE"
 
-            def visit_myothertype(self, type, **kw):
+            def visit_myothertype(self, type_, **kw):
                 return "MYOTHERTYPE"
 
         class MyCompiler(compiler.SQLCompiler):
@@ -721,10 +726,10 @@ class JSONIndexOpTest(fixtures.TestBase, testing.AssertsCompiledSQL):
 class ArrayIndexOpTest(fixtures.TestBase, testing.AssertsCompiledSQL):
     def setUp(self):
         class MyTypeCompiler(compiler.GenericTypeCompiler):
-            def visit_mytype(self, type, **kw):
+            def visit_mytype(self, type_, **kw):
                 return "MYTYPE"
 
-            def visit_myothertype(self, type, **kw):
+            def visit_myothertype(self, type_, **kw):
                 return "MYOTHERTYPE"
 
         class MyCompiler(compiler.SQLCompiler):
diff --git a/test/sql/test_query.py b/test/sql/test_query.py
index 13f3b01ff..2726b3f3c 100644
--- a/test/sql/test_query.py
+++ b/test/sql/test_query.py
@@ -1,43 +1,39 @@
-from sqlalchemy.testing import (
-    eq_,
-    assert_raises_message,
-    assert_raises,
-    is_,
-    in_,
-    not_in_,
-)
+from sqlalchemy import and_
+from sqlalchemy import asc
+from sqlalchemy import bindparam
+from sqlalchemy import cast
+from sqlalchemy import desc
+from sqlalchemy import exc
+from sqlalchemy import except_
+from sqlalchemy import ForeignKey
+from sqlalchemy import func
+from sqlalchemy import INT
+from sqlalchemy import Integer
+from sqlalchemy import intersect
+from sqlalchemy import literal
+from sqlalchemy import literal_column
+from sqlalchemy import MetaData
+from sqlalchemy import not_
+from sqlalchemy import or_
+from sqlalchemy import select
+from sqlalchemy import sql
+from sqlalchemy import String
 from sqlalchemy import testing
-from sqlalchemy.testing import fixtures, engines
-from sqlalchemy import (
-    exc,
-    sql,
-    func,
-    select,
-    String,
-    Integer,
-    MetaData,
-    and_,
-    ForeignKey,
-    union,
-    intersect,
-    except_,
-    union_all,
-    VARCHAR,
-    INT,
-    text,
-    bindparam,
-    literal,
-    not_,
-    literal_column,
-    desc,
-    asc,
-    TypeDecorator,
-    or_,
-    cast,
-    tuple_,
-)
+from sqlalchemy import text
+from sqlalchemy import tuple_
+from sqlalchemy import TypeDecorator
+from sqlalchemy import union
+from sqlalchemy import union_all
+from sqlalchemy import VARCHAR
 from sqlalchemy.engine import default
-from sqlalchemy.testing.schema import Table, Column
+from sqlalchemy.testing import assert_raises_message
+from sqlalchemy.testing import engines
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing import is_
+from sqlalchemy.testing.schema import Column
+from sqlalchemy.testing.schema import Table
+
 
 # ongoing - these are old tests.  those which are of general use
 # to test a dialect are being slowly migrated to
diff --git a/test/sql/test_quote.py b/test/sql/test_quote.py
index 4cc185298..49dfbba9f 100644
--- a/test/sql/test_quote.py
+++ b/test/sql/test_quote.py
@@ -1,22 +1,24 @@
-from sqlalchemy import (
-    MetaData,
-    Table,
-    Column,
-    Integer,
-    select,
-    ForeignKey,
-    Index,
-    CheckConstraint,
-    inspect,
-    column,
-)
-from sqlalchemy import sql, schema, types as sqltypes
-from sqlalchemy.sql import compiler
-from sqlalchemy.testing import fixtures, AssertsCompiledSQL, eq_
+from sqlalchemy import CheckConstraint
+from sqlalchemy import Column
+from sqlalchemy import column
+from sqlalchemy import ForeignKey
+from sqlalchemy import Index
+from sqlalchemy import inspect
+from sqlalchemy import Integer
+from sqlalchemy import MetaData
+from sqlalchemy import schema
+from sqlalchemy import select
+from sqlalchemy import sql
+from sqlalchemy import Table
 from sqlalchemy import testing
-from sqlalchemy.sql.elements import quoted_name, _anonymous_label
-from sqlalchemy.testing.util import picklers
 from sqlalchemy.engine import default
+from sqlalchemy.sql import compiler
+from sqlalchemy.sql.elements import _anonymous_label
+from sqlalchemy.sql.elements import quoted_name
+from sqlalchemy.testing import AssertsCompiledSQL
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing.util import picklers
 
 
 class QuoteExecTest(fixtures.TestBase):
@@ -215,18 +217,18 @@ class QuoteTest(fixtures.TestBase, AssertsCompiledSQL):
         """test the quoting of labels.
 
         If labels aren't quoted, a query in postgresql in particular will
-        fail since it produces:
-
-        SELECT
-            LaLa.lowercase, LaLa."UPPERCASE", LaLa."MixedCase", LaLa."ASC"
-        FROM (
-            SELECT DISTINCT
-                "WorstCase1".lowercase AS lowercase,
-                "WorstCase1"."UPPERCASE" AS UPPERCASE,
-                "WorstCase1"."MixedCase" AS MixedCase,
-                "WorstCase1"."ASC" AS ASC
-            FROM "WorstCase1"
-        ) AS LaLa
+        fail since it produces::
+
+            SELECT
+                LaLa.lowercase, LaLa."UPPERCASE", LaLa."MixedCase", LaLa."ASC"
+            FROM (
+                SELECT DISTINCT
+                    "WorstCase1".lowercase AS lowercase,
+                    "WorstCase1"."UPPERCASE" AS UPPERCASE,
+                    "WorstCase1"."MixedCase" AS MixedCase,
+                    "WorstCase1"."ASC" AS ASC
+                FROM "WorstCase1"
+            ) AS LaLa
 
         where the "UPPERCASE" column of "LaLa" doesn't exist.
         """
diff --git a/test/sql/test_resultset.py b/test/sql/test_resultset.py
index c5e1efef6..3bd61b1f8 100644
--- a/test/sql/test_resultset.py
+++ b/test/sql/test_resultset.py
@@ -1,44 +1,44 @@
-from sqlalchemy.testing import (
-    eq_,
-    assert_raises_message,
-    assert_raises,
-    in_,
-    not_in_,
-    is_,
-    ne_,
-    le_,
-)
+from contextlib import contextmanager
+import operator
+
+from sqlalchemy import CHAR
+from sqlalchemy import column
+from sqlalchemy import exc
+from sqlalchemy import exc as sa_exc
+from sqlalchemy import ForeignKey
+from sqlalchemy import func
+from sqlalchemy import INT
+from sqlalchemy import Integer
+from sqlalchemy import literal
+from sqlalchemy import literal_column
+from sqlalchemy import MetaData
+from sqlalchemy import select
+from sqlalchemy import sql
+from sqlalchemy import String
+from sqlalchemy import table
 from sqlalchemy import testing
-from sqlalchemy.testing import fixtures, engines
+from sqlalchemy import text
+from sqlalchemy import type_coerce
+from sqlalchemy import TypeDecorator
 from sqlalchemy import util
-from sqlalchemy import (
-    exc,
-    sql,
-    func,
-    select,
-    String,
-    Integer,
-    MetaData,
-    ForeignKey,
-    VARCHAR,
-    INT,
-    CHAR,
-    text,
-    type_coerce,
-    literal_column,
-    TypeDecorator,
-    table,
-    column,
-    literal,
-)
+from sqlalchemy import VARCHAR
+from sqlalchemy.engine import default
 from sqlalchemy.engine import result as _result
-from sqlalchemy.testing.schema import Table, Column
-import operator
+from sqlalchemy.testing import assert_raises
+from sqlalchemy.testing import assert_raises_message
 from sqlalchemy.testing import assertions
-from sqlalchemy import exc as sa_exc
-from sqlalchemy.testing.mock import patch, Mock
-from contextlib import contextmanager
-from sqlalchemy.engine import default
+from sqlalchemy.testing import engines
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing import in_
+from sqlalchemy.testing import is_
+from sqlalchemy.testing import le_
+from sqlalchemy.testing import ne_
+from sqlalchemy.testing import not_in_
+from sqlalchemy.testing.mock import Mock
+from sqlalchemy.testing.mock import patch
+from sqlalchemy.testing.schema import Column
+from sqlalchemy.testing.schema import Table
 
 
 class ResultProxyTest(fixtures.TablesTest):
diff --git a/test/sql/test_returning.py b/test/sql/test_returning.py
index e298a2d55..aa10626c5 100644
--- a/test/sql/test_returning.py
+++ b/test/sql/test_returning.py
@@ -1,24 +1,23 @@
-from sqlalchemy.testing import eq_
+import itertools
+
+from sqlalchemy import Boolean
+from sqlalchemy import exc as sa_exc
+from sqlalchemy import func
+from sqlalchemy import Integer
+from sqlalchemy import MetaData
+from sqlalchemy import select
+from sqlalchemy import Sequence
+from sqlalchemy import String
 from sqlalchemy import testing
-from sqlalchemy.testing.schema import Table, Column
+from sqlalchemy.testing import assert_raises_message
+from sqlalchemy.testing import AssertsExecutionResults
+from sqlalchemy.testing import engines
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing.schema import Column
+from sqlalchemy.testing.schema import Table
 from sqlalchemy.types import TypeDecorator
-from sqlalchemy.testing import (
-    fixtures,
-    AssertsExecutionResults,
-    engines,
-    assert_raises_message,
-)
-from sqlalchemy import exc as sa_exc
-from sqlalchemy import (
-    MetaData,
-    String,
-    Integer,
-    Boolean,
-    func,
-    select,
-    Sequence,
-)
-import itertools
+
 
 table = GoofyType = seq = None
 
@@ -313,7 +312,7 @@ class ReturnDefaultsTest(fixtures.TablesTest):
             pass
 
         @compiles(IncDefault)
-        def compile(element, compiler, **kw):
+        def compile_(element, compiler, **kw):
             return str(next(counter))
 
         Table(
diff --git a/test/sql/test_rowcount.py b/test/sql/test_rowcount.py
index 126e1f0cd..8cff8c98f 100644
--- a/test/sql/test_rowcount.py
+++ b/test/sql/test_rowcount.py
@@ -1,7 +1,15 @@
-from sqlalchemy import *
-from sqlalchemy.testing import fixtures, AssertsExecutionResults
+from sqlalchemy import bindparam
+from sqlalchemy import Column
+from sqlalchemy import Integer
+from sqlalchemy import MetaData
+from sqlalchemy import Sequence
+from sqlalchemy import String
+from sqlalchemy import Table
 from sqlalchemy import testing
+from sqlalchemy import text
+from sqlalchemy.testing import AssertsExecutionResults
 from sqlalchemy.testing import eq_
+from sqlalchemy.testing import fixtures
 
 
 class FoundRowsTest(fixtures.TestBase, AssertsExecutionResults):
diff --git a/test/sql/test_selectable.py b/test/sql/test_selectable.py
index 023a0bc61..5456dfb4f 100644
--- a/test/sql/test_selectable.py
+++ b/test/sql/test_selectable.py
@@ -1,19 +1,47 @@
 """Test various algorithmic properties of selectables."""
 
-from sqlalchemy.testing import eq_, assert_raises, assert_raises_message, is_
-from sqlalchemy import *
-from sqlalchemy.testing import (
-    fixtures,
-    AssertsCompiledSQL,
-    AssertsExecutionResults,
-)
-from sqlalchemy.sql import elements
-from sqlalchemy import testing
-from sqlalchemy.sql import util as sql_util, visitors, expression
+from sqlalchemy import alias
+from sqlalchemy import and_
+from sqlalchemy import bindparam
+from sqlalchemy import Boolean
+from sqlalchemy import cast
+from sqlalchemy import Column
 from sqlalchemy import exc
-from sqlalchemy.sql import table, column, null
+from sqlalchemy import exists
+from sqlalchemy import ForeignKey
+from sqlalchemy import func
+from sqlalchemy import Integer
+from sqlalchemy import join
+from sqlalchemy import literal_column
+from sqlalchemy import MetaData
+from sqlalchemy import not_
+from sqlalchemy import null
+from sqlalchemy import or_
+from sqlalchemy import outerjoin
+from sqlalchemy import select
+from sqlalchemy import Sequence
+from sqlalchemy import String
+from sqlalchemy import Table
+from sqlalchemy import testing
+from sqlalchemy import text
+from sqlalchemy import type_coerce
+from sqlalchemy import TypeDecorator
+from sqlalchemy import union
 from sqlalchemy import util
-from sqlalchemy.schema import Column, Table, MetaData
+from sqlalchemy.sql import column
+from sqlalchemy.sql import elements
+from sqlalchemy.sql import expression
+from sqlalchemy.sql import table
+from sqlalchemy.sql import util as sql_util
+from sqlalchemy.sql import visitors
+from sqlalchemy.testing import assert_raises
+from sqlalchemy.testing import assert_raises_message
+from sqlalchemy.testing import AssertsCompiledSQL
+from sqlalchemy.testing import AssertsExecutionResults
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing import is_
+
 
 metadata = MetaData()
 table1 = Table(
@@ -691,7 +719,8 @@ class SelectableTest(
         assert s.c.b is not None
         self.assert_compile(
             s.select(),
-            "SELECT b FROM (SELECT (SELECT table1.col1 AS a FROM table1) AS b)",
+            "SELECT b FROM "
+            "(SELECT (SELECT table1.col1 AS a FROM table1) AS b)",
         )
 
         s2 = select([s.label("c")])
@@ -1980,17 +2009,17 @@ class AnnotationsTest(fixtures.TestBase):
     def test_annotated_visit(self):
         table1 = table("table1", column("col1"), column("col2"))
 
-        bin = table1.c.col1 == bindparam("foo", value=None)
-        assert str(bin) == "table1.col1 = :foo"
+        bin_ = table1.c.col1 == bindparam("foo", value=None)
+        assert str(bin_) == "table1.col1 = :foo"
 
         def visit_binary(b):
             b.right = table1.c.col2
 
-        b2 = visitors.cloned_traverse(bin, {}, {"binary": visit_binary})
+        b2 = visitors.cloned_traverse(bin_, {}, {"binary": visit_binary})
         assert str(b2) == "table1.col1 = table1.col2"
 
         b3 = visitors.cloned_traverse(
-            bin._annotate({}), {}, {"binary": visit_binary}
+            bin_._annotate({}), {}, {"binary": visit_binary}
         )
         assert str(b3) == "table1.col1 = table1.col2"
 
@@ -2041,11 +2070,11 @@ class AnnotationsTest(fixtures.TestBase):
     def test_deannotate(self):
         table1 = table("table1", column("col1"), column("col2"))
 
-        bin = table1.c.col1 == bindparam("foo", value=None)
+        bin_ = table1.c.col1 == bindparam("foo", value=None)
 
-        b2 = sql_util._deep_annotate(bin, {"_orm_adapt": True})
+        b2 = sql_util._deep_annotate(bin_, {"_orm_adapt": True})
         b3 = sql_util._deep_deannotate(b2)
-        b4 = sql_util._deep_deannotate(bin)
+        b4 = sql_util._deep_deannotate(bin_)
 
         for elem in (b2._annotations, b2.left._annotations):
             assert "_orm_adapt" in elem
@@ -2058,12 +2087,12 @@ class AnnotationsTest(fixtures.TestBase):
         ):
             assert elem == {}
 
-        assert b2.left is not bin.left
-        assert b3.left is not b2.left and b2.left is not bin.left
-        assert b4.left is bin.left  # since column is immutable
+        assert b2.left is not bin_.left
+        assert b3.left is not b2.left and b2.left is not bin_.left
+        assert b4.left is bin_.left  # since column is immutable
         # deannotate copies the element
         assert (
-            bin.right is not b2.right
+            bin_.right is not b2.right
             and b2.right is not b3.right
             and b3.right is not b4.right
         )
diff --git a/test/sql/test_tablesample.py b/test/sql/test_tablesample.py
index 712450d9f..d2c57c930 100644
--- a/test/sql/test_tablesample.py
+++ b/test/sql/test_tablesample.py
@@ -1,10 +1,14 @@
-from sqlalchemy.testing import fixtures
-from sqlalchemy.testing import AssertsCompiledSQL, assert_raises_message
-from sqlalchemy.sql import select, func, text
-from sqlalchemy.engine import default
-from sqlalchemy import exc
-from sqlalchemy import Table, Integer, String, Column
+from sqlalchemy import Column
+from sqlalchemy import Integer
+from sqlalchemy import String
+from sqlalchemy import Table
 from sqlalchemy import tablesample
+from sqlalchemy.engine import default
+from sqlalchemy.sql import func
+from sqlalchemy.sql import select
+from sqlalchemy.sql import text
+from sqlalchemy.testing import AssertsCompiledSQL
+from sqlalchemy.testing import fixtures
 
 
 class TableSampleTest(fixtures.TablesTest, AssertsCompiledSQL):
diff --git a/test/sql/test_text.py b/test/sql/test_text.py
index 34415600e..6b419f599 100644
--- a/test/sql/test_text.py
+++ b/test/sql/test_text.py
@@ -1,36 +1,34 @@
 """Test the TextClause and related constructs."""
 
-from sqlalchemy.testing import (
-    fixtures,
-    AssertsCompiledSQL,
-    eq_,
-    assert_raises_message,
-    expect_warnings,
-    assert_warnings,
-)
-from sqlalchemy import (
-    text,
-    select,
-    Integer,
-    String,
-    Float,
-    bindparam,
-    and_,
-    func,
-    literal_column,
-    exc,
-    MetaData,
-    Table,
-    Column,
-    asc,
-    func,
-    desc,
-    union,
-    literal,
-)
-from sqlalchemy.types import NullType
-from sqlalchemy.sql import table, column, util as sql_util
+from sqlalchemy import and_
+from sqlalchemy import asc
+from sqlalchemy import bindparam
+from sqlalchemy import Column
+from sqlalchemy import desc
+from sqlalchemy import exc
+from sqlalchemy import Float
+from sqlalchemy import func
+from sqlalchemy import Integer
+from sqlalchemy import literal
+from sqlalchemy import literal_column
+from sqlalchemy import MetaData
+from sqlalchemy import select
+from sqlalchemy import String
+from sqlalchemy import Table
+from sqlalchemy import text
+from sqlalchemy import union
 from sqlalchemy import util
+from sqlalchemy.sql import column
+from sqlalchemy.sql import table
+from sqlalchemy.sql import util as sql_util
+from sqlalchemy.testing import assert_raises_message
+from sqlalchemy.testing import assert_warnings
+from sqlalchemy.testing import AssertsCompiledSQL
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing import expect_warnings
+from sqlalchemy.testing import fixtures
+from sqlalchemy.types import NullType
+
 
 table1 = table(
     "mytable",
diff --git a/test/sql/test_type_expressions.py b/test/sql/test_type_expressions.py
index 8c5fb1f07..18877c338 100644
--- a/test/sql/test_type_expressions.py
+++ b/test/sql/test_type_expressions.py
@@ -1,16 +1,15 @@
-from sqlalchemy import (
-    Table,
-    Column,
-    String,
-    func,
-    MetaData,
-    select,
-    TypeDecorator,
-    cast,
-)
-from sqlalchemy.testing import fixtures, AssertsCompiledSQL
+from sqlalchemy import cast
+from sqlalchemy import Column
+from sqlalchemy import func
+from sqlalchemy import MetaData
+from sqlalchemy import select
+from sqlalchemy import String
+from sqlalchemy import Table
 from sqlalchemy import testing
+from sqlalchemy import TypeDecorator
+from sqlalchemy.testing import AssertsCompiledSQL
 from sqlalchemy.testing import eq_
+from sqlalchemy.testing import fixtures
 
 
 class _ExprFixture(object):
diff --git a/test/sql/test_types.py b/test/sql/test_types.py
index 179f1050c..c54fe1e54 100644
--- a/test/sql/test_types.py
+++ b/test/sql/test_types.py
@@ -1,86 +1,89 @@
 # coding: utf-8
-from sqlalchemy.testing import (
-    eq_,
-    is_,
-    is_not_,
-    assert_raises,
-    assert_raises_message,
-    expect_warnings,
-)
-import decimal
 import datetime
+import decimal
+import importlib
+import operator
 import os
-from sqlalchemy import (
-    Unicode,
-    MetaData,
-    PickleType,
-    Boolean,
-    TypeDecorator,
-    Integer,
-    Interval,
-    Float,
-    Numeric,
-    Text,
-    CHAR,
-    String,
-    distinct,
-    select,
-    bindparam,
-    and_,
-    func,
-    Date,
-    LargeBinary,
-    literal,
-    cast,
-    text,
-    Enum,
-    type_coerce,
-    VARCHAR,
-    Time,
-    DateTime,
-    BigInteger,
-    SmallInteger,
-    BOOLEAN,
-    BLOB,
-    NCHAR,
-    NVARCHAR,
-    CLOB,
-    TIME,
-    DATE,
-    DATETIME,
-    TIMESTAMP,
-    SMALLINT,
-    INTEGER,
-    DECIMAL,
-    NUMERIC,
-    FLOAT,
-    REAL,
-    ARRAY,
-    JSON,
-)
-from sqlalchemy.sql import ddl
-from sqlalchemy.sql import visitors
+
+from sqlalchemy import and_
+from sqlalchemy import ARRAY
+from sqlalchemy import BigInteger
+from sqlalchemy import bindparam
+from sqlalchemy import BLOB
+from sqlalchemy import BOOLEAN
+from sqlalchemy import Boolean
+from sqlalchemy import cast
+from sqlalchemy import CHAR
+from sqlalchemy import CLOB
+from sqlalchemy import DATE
+from sqlalchemy import Date
+from sqlalchemy import DATETIME
+from sqlalchemy import DateTime
+from sqlalchemy import DECIMAL
+from sqlalchemy import dialects
+from sqlalchemy import distinct
+from sqlalchemy import Enum
+from sqlalchemy import exc
+from sqlalchemy import FLOAT
+from sqlalchemy import Float
+from sqlalchemy import func
 from sqlalchemy import inspection
-from sqlalchemy import exc, types, util, dialects
-from sqlalchemy.util import OrderedDict
-from sqlalchemy.sql import operators, column, table, null
-from sqlalchemy.schema import CheckConstraint, AddConstraint
-from sqlalchemy.engine import default
-from sqlalchemy.testing.schema import Table, Column
+from sqlalchemy import INTEGER
+from sqlalchemy import Integer
+from sqlalchemy import Interval
+from sqlalchemy import JSON
+from sqlalchemy import LargeBinary
+from sqlalchemy import literal
+from sqlalchemy import MetaData
+from sqlalchemy import NCHAR
+from sqlalchemy import NUMERIC
+from sqlalchemy import Numeric
+from sqlalchemy import NVARCHAR
+from sqlalchemy import PickleType
+from sqlalchemy import REAL
+from sqlalchemy import select
+from sqlalchemy import SMALLINT
+from sqlalchemy import SmallInteger
+from sqlalchemy import String
 from sqlalchemy import testing
-from sqlalchemy.testing import (
-    AssertsCompiledSQL,
-    AssertsExecutionResults,
-    engines,
-    pickleable,
-)
-from sqlalchemy.testing.util import picklers
-from sqlalchemy.testing.util import round_decimal
+from sqlalchemy import Text
+from sqlalchemy import text
+from sqlalchemy import TIME
+from sqlalchemy import Time
+from sqlalchemy import TIMESTAMP
+from sqlalchemy import type_coerce
+from sqlalchemy import TypeDecorator
+from sqlalchemy import types
+from sqlalchemy import Unicode
+from sqlalchemy import util
+from sqlalchemy import VARCHAR
+from sqlalchemy.engine import default
+from sqlalchemy.schema import AddConstraint
+from sqlalchemy.schema import CheckConstraint
+from sqlalchemy.sql import column
+from sqlalchemy.sql import ddl
+from sqlalchemy.sql import null
+from sqlalchemy.sql import operators
+from sqlalchemy.sql import sqltypes
+from sqlalchemy.sql import table
+from sqlalchemy.sql import visitors
+from sqlalchemy.testing import assert_raises
+from sqlalchemy.testing import assert_raises_message
+from sqlalchemy.testing import AssertsCompiledSQL
+from sqlalchemy.testing import AssertsExecutionResults
+from sqlalchemy.testing import engines
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing import expect_warnings
 from sqlalchemy.testing import fixtures
+from sqlalchemy.testing import is_
+from sqlalchemy.testing import is_not_
 from sqlalchemy.testing import mock
-from sqlalchemy.sql import column
-import operator
-import importlib
+from sqlalchemy.testing import pickleable
+from sqlalchemy.testing.schema import Column
+from sqlalchemy.testing.schema import Table
+from sqlalchemy.testing.util import picklers
+from sqlalchemy.testing.util import round_decimal
+from sqlalchemy.util import OrderedDict
 
 
 class AdaptTest(fixtures.TestBase):
@@ -198,8 +201,6 @@ class AdaptTest(fixtures.TestBase):
                     ):
                         yield True, subcl, [typ]
 
-        from sqlalchemy.sql import sqltypes
-
         for is_down_adaption, typ, target_adaptions in adaptions():
             if typ in (types.TypeDecorator, types.TypeEngine, types.Variant):
                 continue
@@ -2754,8 +2755,8 @@ class NumericRawSQLTest(fixtures.TestBase):
 
     """
 
-    def _fixture(self, metadata, type, data):
-        t = Table("t", metadata, Column("val", type))
+    def _fixture(self, metadata, type_, data):
+        t = Table("t", metadata, Column("val", type_))
         metadata.create_all()
         t.insert().execute(val=data)
 
diff --git a/test/sql/test_unicode.py b/test/sql/test_unicode.py
index fafdb03a3..5b51644e6 100644
--- a/test/sql/test_unicode.py
+++ b/test/sql/test_unicode.py
@@ -1,11 +1,18 @@
 # coding: utf-8
 """verrrrry basic unicode column name testing"""
 
-from sqlalchemy import *
-from sqlalchemy.testing import fixtures, engines, eq_
+from sqlalchemy import desc
+from sqlalchemy import ForeignKey
+from sqlalchemy import Integer
+from sqlalchemy import MetaData
 from sqlalchemy import testing
-from sqlalchemy.testing.schema import Table, Column
-from sqlalchemy.util import u, ue
+from sqlalchemy.testing import engines
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing.schema import Column
+from sqlalchemy.testing.schema import Table
+from sqlalchemy.util import u
+from sqlalchemy.util import ue
 
 
 class UnicodeSchemaTest(fixtures.TestBase):
@@ -189,7 +196,8 @@ class UnicodeSchemaTest(fixtures.TestBase):
             repr(t),
             (
                 "Table('\\u6e2c\\u8a66', MetaData(bind=None), "
-                "Column('\\u6e2c\\u8a66_id', Integer(), table=<\u6e2c\u8a66>), "
+                "Column('\\u6e2c\\u8a66_id', Integer(), "
+                "table=<\u6e2c\u8a66>), "
                 "schema=None)"
             ),
         )
diff --git a/test/sql/test_update.py b/test/sql/test_update.py
index 191ecb4d6..514076daa 100644
--- a/test/sql/test_update.py
+++ b/test/sql/test_update.py
@@ -1,33 +1,30 @@
-from sqlalchemy import (
-    Integer,
-    String,
-    ForeignKey,
-    and_,
-    or_,
-    func,
-    literal,
-    update,
-    table,
-    bindparam,
-    column,
-    select,
-    exc,
-    exists,
-    text,
-    MetaData,
-)
+from sqlalchemy import and_
+from sqlalchemy import bindparam
+from sqlalchemy import column
+from sqlalchemy import exc
+from sqlalchemy import exists
+from sqlalchemy import ForeignKey
+from sqlalchemy import func
+from sqlalchemy import Integer
+from sqlalchemy import literal
+from sqlalchemy import MetaData
+from sqlalchemy import or_
+from sqlalchemy import select
+from sqlalchemy import String
+from sqlalchemy import table
 from sqlalchemy import testing
+from sqlalchemy import text
+from sqlalchemy import update
+from sqlalchemy import util
 from sqlalchemy.dialects import mysql
 from sqlalchemy.engine import default
-from sqlalchemy.testing import (
-    AssertsCompiledSQL,
-    eq_,
-    fixtures,
-    assert_raises_message,
-    assert_raises,
-)
-from sqlalchemy.testing.schema import Table, Column
-from sqlalchemy import util
+from sqlalchemy.testing import assert_raises
+from sqlalchemy.testing import assert_raises_message
+from sqlalchemy.testing import AssertsCompiledSQL
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing.schema import Column
+from sqlalchemy.testing.schema import Table
 
 
 class _UpdateFromTestBase(object):
diff --git a/test/sql/test_utils.py b/test/sql/test_utils.py
index bc124ada9..023c483fc 100644
--- a/test/sql/test_utils.py
+++ b/test/sql/test_utils.py
@@ -1,9 +1,19 @@
-from sqlalchemy.testing import fixtures, is_true, is_false, eq_
-from sqlalchemy import MetaData, Table, Column, Integer, String
-from sqlalchemy import and_, or_, bindparam
-from sqlalchemy.sql.elements import ClauseList, ColumnElement
+from sqlalchemy import and_
+from sqlalchemy import bindparam
+from sqlalchemy import Column
+from sqlalchemy import Integer
+from sqlalchemy import MetaData
+from sqlalchemy import or_
+from sqlalchemy import String
+from sqlalchemy import Table
 from sqlalchemy.sql import operators
 from sqlalchemy.sql import util as sql_util
+from sqlalchemy.sql.elements import ClauseList
+from sqlalchemy.sql.elements import ColumnElement
+from sqlalchemy.testing import eq_
+from sqlalchemy.testing import fixtures
+from sqlalchemy.testing import is_false
+from sqlalchemy.testing import is_true
 
 
 class CompareClausesTest(fixtures.TestBase):