Clean up most py3k compat

Change-Id: I8172fdcc3103ff92aa049827728484c8779af6b7

25 files changed, 88 insertions, 151 deletions

diff --git a/lib/sqlalchemy/dialects/mssql/base.py b/lib/sqlalchemy/dialects/mssql/base.py
index e5745bf69..353c78c76 100644
--- a/lib/sqlalchemy/dialects/mssql/base.py
+++ b/lib/sqlalchemy/dialects/mssql/base.py
@@ -847,7 +847,6 @@ from ...types import NVARCHAR
 from ...types import SMALLINT
 from ...types import TEXT
 from ...types import VARCHAR
-from ...util import compat
 from ...util import update_wrapper
 from ...util.langhelpers import public_factory
 
@@ -1084,7 +1083,7 @@ class _MSDate(sqltypes.Date):
         def process(value):
             if isinstance(value, datetime.datetime):
                 return value.date()
-            elif isinstance(value, util.string_types):
+            elif isinstance(value, str):
                 m = self._reg.match(value)
                 if not m:
                     raise ValueError(
@@ -1126,7 +1125,7 @@ class TIME(sqltypes.TIME):
         def process(value):
             if isinstance(value, datetime.datetime):
                 return value.time()
-            elif isinstance(value, util.string_types):
+            elif isinstance(value, str):
                 m = self._reg.match(value)
                 if not m:
                     raise ValueError(
@@ -2383,9 +2382,7 @@ class MSDDLCompiler(compiler.DDLCompiler):
         # handle other included columns
         if index.dialect_options["mssql"]["include"]:
             inclusions = [
-                index.table.c[col]
-                if isinstance(col, util.string_types)
-                else col
+                index.table.c[col] if isinstance(col, str) else col
                 for col in index.dialect_options["mssql"]["include"]
             ]
 
@@ -3256,8 +3253,8 @@ class MSDialect(default.DefaultDialect):
                     cdict["identity"] = {}
                 else:
                     if isinstance(coltype, sqltypes.BigInteger):
-                        start = compat.long_type(identity_start)
-                        increment = compat.long_type(identity_increment)
+                        start = int(identity_start)
+                        increment = int(identity_increment)
                     elif isinstance(coltype, sqltypes.Integer):
                         start = int(identity_start)
                         increment = int(identity_increment)
diff --git a/lib/sqlalchemy/dialects/mssql/pyodbc.py b/lib/sqlalchemy/dialects/mssql/pyodbc.py
index 6ce55d392..7bcc2a467 100644
--- a/lib/sqlalchemy/dialects/mssql/pyodbc.py
+++ b/lib/sqlalchemy/dialects/mssql/pyodbc.py
@@ -398,7 +398,7 @@ class _ODBCDateTimeBindProcessor:
         def process(value):
             if value is None:
                 return None
-            elif isinstance(value, util.string_types):
+            elif isinstance(value, str):
                 # if a string was passed directly, allow it through
                 return value
             elif not value.tzinfo or (not self.timezone and not self.has_tz):
@@ -577,7 +577,7 @@ class MSDialect_pyodbc(PyODBCConnector, MSDialect):
                 tup[4],
                 tup[5],
                 tup[6] // 1000,
-                util.timezone(
+                datetime.timezone(
                     datetime.timedelta(hours=tup[7], minutes=tup[8])
                 ),
             )
diff --git a/lib/sqlalchemy/dialects/mysql/__init__.py b/lib/sqlalchemy/dialects/mysql/__init__.py
index 9fe6f6d84..389720213 100644
--- a/lib/sqlalchemy/dialects/mysql/__init__.py
+++ b/lib/sqlalchemy/dialects/mysql/__init__.py
@@ -5,6 +5,8 @@
 # This module is part of SQLAlchemy and is released under
 # the MIT License: https://www.opensource.org/licenses/mit-license.php
 
+from . import aiomysql  # noqa
+from . import asyncmy  # noqa
 from . import base  # noqa
 from . import cymysql  # noqa
 from . import mariadbconnector  # noqa
@@ -51,10 +53,6 @@ from .dml import insert
 from .expression import match
 from ...util import compat
 
-if compat.py3k:
-    from . import aiomysql  # noqa
-    from . import asyncmy  # noqa
-
 # default dialect
 base.dialect = dialect = mysqldb.dialect
 
diff --git a/lib/sqlalchemy/dialects/mysql/asyncmy.py b/lib/sqlalchemy/dialects/mysql/asyncmy.py
index 0fca338f5..b59571460 100644
--- a/lib/sqlalchemy/dialects/mysql/asyncmy.py
+++ b/lib/sqlalchemy/dialects/mysql/asyncmy.py
@@ -28,11 +28,12 @@ This dialect should normally be used only with the
 
 """  # noqa
 
+from contextlib import asynccontextmanager
+
 from .pymysql import MySQLDialect_pymysql
 from ... import pool
 from ... import util
 from ...engine import AdaptedConnection
-from ...util.concurrency import asynccontextmanager
 from ...util.concurrency import asyncio
 from ...util.concurrency import await_fallback
 from ...util.concurrency import await_only
diff --git a/lib/sqlalchemy/dialects/mysql/base.py b/lib/sqlalchemy/dialects/mysql/base.py
index 54fe1f57f..f77d839f3 100644
--- a/lib/sqlalchemy/dialects/mysql/base.py
+++ b/lib/sqlalchemy/dialects/mysql/base.py
@@ -1469,7 +1469,7 @@ class MySQLCompiler(compiler.SQLCompiler):
            keywords at the start of a SELECT.
 
         """
-        if isinstance(select._distinct, util.string_types):
+        if isinstance(select._distinct, str):
             util.warn_deprecated(
                 "Sending string values for 'distinct' is deprecated in the "
                 "MySQL dialect and will be removed in a future release.  "
@@ -2425,7 +2425,7 @@ class MySQLDialect(default.DefaultDialect):
             raise NotImplementedError()
         val = row[0]
         cursor.close()
-        if util.py3k and isinstance(val, bytes):
+        if isinstance(val, bytes):
             val = val.decode()
         return val.upper().replace("-", " ")
 
@@ -2456,7 +2456,7 @@ class MySQLDialect(default.DefaultDialect):
         cursor.execute("SELECT VERSION()")
         val = cursor.fetchone()[0]
         cursor.close()
-        if util.py3k and isinstance(val, bytes):
+        if isinstance(val, bytes):
             val = val.decode()
 
         return self._parse_server_version(val)
@@ -2607,8 +2607,8 @@ class MySQLDialect(default.DefaultDialect):
                 sql.bindparam("table_name", type_=Unicode),
             ),
             {
-                "table_schema": util.text_type(schema),
-                "table_name": util.text_type(table_name),
+                "table_schema": str(schema),
+                "table_name": str(table_name),
             },
         )
         return bool(rs.scalar())
@@ -2627,8 +2627,8 @@ class MySQLDialect(default.DefaultDialect):
                 "TABLE_SCHEMA=:schema_name"
             ),
             dict(
-                name=util.text_type(sequence_name),
-                schema_name=util.text_type(schema),
+                name=str(sequence_name),
+                schema_name=str(schema),
             ),
         )
         return cursor.first() is not None
@@ -3228,7 +3228,7 @@ class _DecodingRow:
         if isinstance(item, _array):
             item = item.tostring()
 
-        if self.charset and isinstance(item, util.binary_type):
+        if self.charset and isinstance(item, bytes):
             return item.decode(self.charset)
         else:
             return item
@@ -3237,7 +3237,7 @@ class _DecodingRow:
         item = getattr(self.rowproxy, attr)
         if isinstance(item, _array):
             item = item.tostring()
-        if self.charset and isinstance(item, util.binary_type):
+        if self.charset and isinstance(item, bytes):
             return item.decode(self.charset)
         else:
             return item
diff --git a/lib/sqlalchemy/dialects/mysql/cymysql.py b/lib/sqlalchemy/dialects/mysql/cymysql.py
index f729e4a18..4fe441031 100644
--- a/lib/sqlalchemy/dialects/mysql/cymysql.py
+++ b/lib/sqlalchemy/dialects/mysql/cymysql.py
@@ -33,7 +33,7 @@ class _cymysqlBIT(BIT):
         def process(value):
             if value is not None:
                 v = 0
-                for i in util.iterbytes(value):
+                for i in iter(value):
                     v = v << 8 | i
                 return v
             return value
diff --git a/lib/sqlalchemy/dialects/mysql/enumerated.py b/lib/sqlalchemy/dialects/mysql/enumerated.py
index 9f9a838c5..b84608f58 100644
--- a/lib/sqlalchemy/dialects/mysql/enumerated.py
+++ b/lib/sqlalchemy/dialects/mysql/enumerated.py
@@ -201,7 +201,7 @@ class SET(_StringType):
             super_convert = super(SET, self).result_processor(dialect, coltype)
 
             def process(value):
-                if isinstance(value, util.string_types):
+                if isinstance(value, str):
                     # MySQLdb returns a string, let's parse
                     if super_convert:
                         value = super_convert(value)
@@ -222,7 +222,7 @@ class SET(_StringType):
             def process(value):
                 if value is None:
                     return None
-                elif isinstance(value, util.int_types + util.string_types):
+                elif isinstance(value, (int, str)):
                     if super_convert:
                         return super_convert(value)
                     else:
@@ -237,9 +237,7 @@ class SET(_StringType):
 
             def process(value):
                 # accept strings and int (actually bitflag) values directly
-                if value is not None and not isinstance(
-                    value, util.int_types + util.string_types
-                ):
+                if value is not None and not isinstance(value, (int, str)):
                     value = ",".join(value)
 
                 if super_convert:
diff --git a/lib/sqlalchemy/dialects/mysql/json.py b/lib/sqlalchemy/dialects/mysql/json.py
index 384d3b9b6..c46878fc3 100644
--- a/lib/sqlalchemy/dialects/mysql/json.py
+++ b/lib/sqlalchemy/dialects/mysql/json.py
@@ -4,9 +4,6 @@
 #
 # This module is part of SQLAlchemy and is released under
 # the MIT License: https://www.opensource.org/licenses/mit-license.php
-
-from __future__ import absolute_import
-
 from ... import types as sqltypes
 
 
diff --git a/lib/sqlalchemy/dialects/mysql/mysqlconnector.py b/lib/sqlalchemy/dialects/mysql/mysqlconnector.py
index fef4f14ca..7b62e9ed1 100644
--- a/lib/sqlalchemy/dialects/mysql/mysqlconnector.py
+++ b/lib/sqlalchemy/dialects/mysql/mysqlconnector.py
@@ -32,36 +32,17 @@ from ... import util
 
 class MySQLCompiler_mysqlconnector(MySQLCompiler):
     def visit_mod_binary(self, binary, operator, **kw):
-        if self.dialect._mysqlconnector_double_percents:
-            return (
-                self.process(binary.left, **kw)
-                + " %% "
-                + self.process(binary.right, **kw)
-            )
-        else:
-            return (
-                self.process(binary.left, **kw)
-                + " % "
-                + self.process(binary.right, **kw)
-            )
-
-    def post_process_text(self, text):
-        if self.dialect._mysqlconnector_double_percents:
-            return text.replace("%", "%%")
-        else:
-            return text
-
-    def escape_literal_column(self, text):
-        if self.dialect._mysqlconnector_double_percents:
-            return text.replace("%", "%%")
-        else:
-            return text
+        return (
+            self.process(binary.left, **kw)
+            + " % "
+            + self.process(binary.right, **kw)
+        )
 
 
 class MySQLIdentifierPreparer_mysqlconnector(MySQLIdentifierPreparer):
     @property
     def _double_percents(self):
-        return self.dialect._mysqlconnector_double_percents
+        return False
 
     @_double_percents.setter
     def _double_percents(self, value):
@@ -69,10 +50,7 @@ class MySQLIdentifierPreparer_mysqlconnector(MySQLIdentifierPreparer):
 
     def _escape_identifier(self, value):
         value = value.replace(self.escape_quote, self.escape_to_quote)
-        if self.dialect._mysqlconnector_double_percents:
-            return value.replace("%", "%%")
-        else:
-            return value
+        return value
 
 
 class _myconnpyBIT(BIT):
@@ -163,10 +141,6 @@ class MySQLDialect_mysqlconnector(MySQLDialect):
             if m:
                 return tuple(int(x) for x in m.group(1, 2, 3) if x is not None)
 
-    @util.memoized_property
-    def _mysqlconnector_double_percents(self):
-        return not util.py3k and self._mysqlconnector_version_info < (2, 0)
-
     def _detect_charset(self, connection):
         return connection.connection.charset
 
diff --git a/lib/sqlalchemy/dialects/mysql/pymysql.py b/lib/sqlalchemy/dialects/mysql/pymysql.py
index 3c30fb9ea..dd7bd8bda 100644
--- a/lib/sqlalchemy/dialects/mysql/pymysql.py
+++ b/lib/sqlalchemy/dialects/mysql/pymysql.py
@@ -39,7 +39,6 @@ to the pymysql driver as well.
 
 from .mysqldb import MySQLDialect_mysqldb
 from ...util import langhelpers
-from ...util import py3k
 
 
 class MySQLDialect_pymysql(MySQLDialect_mysqldb):
@@ -81,12 +80,10 @@ class MySQLDialect_pymysql(MySQLDialect_mysqldb):
         else:
             return False
 
-    if py3k:
-
-        def _extract_error_code(self, exception):
-            if isinstance(exception.args[0], Exception):
-                exception = exception.args[0]
-            return exception.args[0]
+    def _extract_error_code(self, exception):
+        if isinstance(exception.args[0], Exception):
+            exception = exception.args[0]
+        return exception.args[0]
 
 
 dialect = MySQLDialect_pymysql
diff --git a/lib/sqlalchemy/dialects/oracle/base.py b/lib/sqlalchemy/dialects/oracle/base.py
index a1d0f80d6..7df2422b3 100644
--- a/lib/sqlalchemy/dialects/oracle/base.py
+++ b/lib/sqlalchemy/dialects/oracle/base.py
@@ -564,7 +564,6 @@ from ...types import NCHAR
 from ...types import NVARCHAR
 from ...types import TIMESTAMP
 from ...types import VARCHAR
-from ...util import compat
 
 RESERVED_WORDS = set(
     "SHARE RAW DROP BETWEEN FROM DESC OPTION PRIOR LONG THEN "
@@ -1414,7 +1413,7 @@ class OracleIdentifierPreparer(compiler.IdentifierPreparer):
         return (
             lc_value in self.reserved_words
             or value[0] in self.illegal_initial_characters
-            or not self.legal_characters.match(util.text_type(value))
+            or not self.legal_characters.match(str(value))
         )
 
     def format_savepoint(self, savepoint):
@@ -2029,17 +2028,17 @@ class OracleDialect(default.DefaultDialect):
             value = value.strip()
 
             if "START WITH" in option:
-                identity["start"] = compat.long_type(value)
+                identity["start"] = int(value)
             elif "INCREMENT BY" in option:
-                identity["increment"] = compat.long_type(value)
+                identity["increment"] = int(value)
             elif "MAX_VALUE" in option:
-                identity["maxvalue"] = compat.long_type(value)
+                identity["maxvalue"] = int(value)
             elif "MIN_VALUE" in option:
-                identity["minvalue"] = compat.long_type(value)
+                identity["minvalue"] = int(value)
             elif "CYCLE_FLAG" in option:
                 identity["cycle"] = value == "Y"
             elif "CACHE_SIZE" in option:
-                identity["cache"] = compat.long_type(value)
+                identity["cache"] = int(value)
             elif "ORDER_FLAG" in option:
                 identity["order"] = value == "Y"
         return identity
diff --git a/lib/sqlalchemy/dialects/oracle/cx_oracle.py b/lib/sqlalchemy/dialects/oracle/cx_oracle.py
index 2cfcb0e5c..07317126d 100644
--- a/lib/sqlalchemy/dialects/oracle/cx_oracle.py
+++ b/lib/sqlalchemy/dialects/oracle/cx_oracle.py
@@ -430,9 +430,6 @@ SQLAlchemy type (or a subclass of such).
    as better integration of outputtypehandlers.
 
 """  # noqa
-
-from __future__ import absolute_import
-
 import decimal
 import random
 import re
@@ -1127,7 +1124,7 @@ class OracleDialect_cx_oracle(OracleDialect):
                 and default_type is not cx_Oracle.NCLOB
             ):
                 return cursor.var(
-                    util.text_type,
+                    str,
                     size,
                     cursor.arraysize,
                     **dialect._cursor_var_unicode_kwargs
@@ -1213,7 +1210,7 @@ class OracleDialect_cx_oracle(OracleDialect):
             opts.setdefault("threaded", self._cx_oracle_threaded)
 
         def convert_cx_oracle_constant(value):
-            if isinstance(value, util.string_types):
+            if isinstance(value, str):
                 try:
                     int_val = int(value)
                 except ValueError:
diff --git a/lib/sqlalchemy/dialects/postgresql/__init__.py b/lib/sqlalchemy/dialects/postgresql/__init__.py
index 056de66be..08b05dc74 100644
--- a/lib/sqlalchemy/dialects/postgresql/__init__.py
+++ b/lib/sqlalchemy/dialects/postgresql/__init__.py
@@ -4,6 +4,7 @@
 #
 # This module is part of SQLAlchemy and is released under
 # the MIT License: https://www.opensource.org/licenses/mit-license.php
+from . import asyncpg  # noqa
 from . import base
 from . import pg8000  # noqa
 from . import psycopg2  # noqa
@@ -57,9 +58,6 @@ from .ranges import TSRANGE
 from .ranges import TSTZRANGE
 from ...util import compat
 
-if compat.py3k:
-    from . import asyncpg  # noqa
-
 base.dialect = dialect = psycopg2.dialect
 
 
diff --git a/lib/sqlalchemy/dialects/postgresql/array.py b/lib/sqlalchemy/dialects/postgresql/array.py
index 0cb574dac..614559035 100644
--- a/lib/sqlalchemy/dialects/postgresql/array.py
+++ b/lib/sqlalchemy/dialects/postgresql/array.py
@@ -374,12 +374,12 @@ class ARRAY(sqltypes.ARRAY):
             def process(value):
                 if value is None:
                     return value
-                # isinstance(value, util.string_types) is required to handle
+                # isinstance(value, str) is required to handle
                 # the case where a TypeDecorator for and Array of Enum is
                 # used like was required in sa < 1.3.17
                 return super_rp(
                     handle_raw_string(value)
-                    if isinstance(value, util.string_types)
+                    if isinstance(value, str)
                     else value
                 )
 
diff --git a/lib/sqlalchemy/dialects/postgresql/asyncpg.py b/lib/sqlalchemy/dialects/postgresql/asyncpg.py
index fe1f9fd5a..d6cde0087 100644
--- a/lib/sqlalchemy/dialects/postgresql/asyncpg.py
+++ b/lib/sqlalchemy/dialects/postgresql/asyncpg.py
@@ -99,6 +99,7 @@ To disable the prepared statement cache, use a value of zero::
 """  # noqa
 
 import collections
+import collections.abc as collections_abc
 import decimal
 import json as _py_json
 import re
@@ -216,8 +217,8 @@ class AsyncpgJSONStrIndexType(sqltypes.JSON.JSONStrIndexType):
 class AsyncpgJSONPathType(json.JSONPathType):
     def bind_processor(self, dialect):
         def process(value):
-            assert isinstance(value, util.collections_abc.Sequence)
-            tokens = [util.text_type(elem) for elem in value]
+            assert isinstance(value, collections_abc.Sequence)
+            tokens = [str(elem) for elem in value]
             return tokens
 
         return process
diff --git a/lib/sqlalchemy/dialects/postgresql/base.py b/lib/sqlalchemy/dialects/postgresql/base.py
index 583d9c263..d00318fc8 100644
--- a/lib/sqlalchemy/dialects/postgresql/base.py
+++ b/lib/sqlalchemy/dialects/postgresql/base.py
@@ -1721,7 +1721,7 @@ class UUID(sqltypes.TypeEngine):
     def coerce_compared_value(self, op, value):
         """See :meth:`.TypeEngine.coerce_compared_value` for a description."""
 
-        if isinstance(value, util.string_types):
+        if isinstance(value, str):
             return self
         else:
             return super(UUID, self).coerce_compared_value(op, value)
@@ -1731,7 +1731,7 @@ class UUID(sqltypes.TypeEngine):
 
             def process(value):
                 if value is not None:
-                    value = util.text_type(value)
+                    value = str(value)
                 return value
 
             return process
@@ -2375,7 +2375,7 @@ class PGCompiler(compiler.SQLCompiler):
             target_text = "(%s)" % ", ".join(
                 (
                     self.preparer.quote(c)
-                    if isinstance(c, util.string_types)
+                    if isinstance(c, str)
                     else self.process(c, include_table=False, use_schema=False)
                 )
                 for c in clause.inferred_target_elements
@@ -2451,7 +2451,7 @@ class PGCompiler(compiler.SQLCompiler):
             for k, v in set_parameters.items():
                 key_text = (
                     self.preparer.quote(k)
-                    if isinstance(k, util.string_types)
+                    if isinstance(k, str)
                     else self.process(k, use_schema=False)
                 )
                 value_text = self.process(
@@ -2653,9 +2653,7 @@ class PGDDLCompiler(compiler.DDLCompiler):
         includeclause = index.dialect_options["postgresql"]["include"]
         if includeclause:
             inclusions = [
-                index.table.c[col]
-                if isinstance(col, util.string_types)
-                else col
+                index.table.c[col] if isinstance(col, str) else col
                 for col in includeclause
             ]
             text += " INCLUDE (%s)" % ", ".join(
@@ -3326,7 +3324,7 @@ class PGDialect(default.DefaultDialect):
             sql.text(query).bindparams(
                 sql.bindparam(
                     "schema",
-                    util.text_type(schema.lower()),
+                    str(schema.lower()),
                     type_=sqltypes.Unicode,
                 )
             )
@@ -3347,7 +3345,7 @@ class PGDialect(default.DefaultDialect):
                 ).bindparams(
                     sql.bindparam(
                         "name",
-                        util.text_type(table_name),
+                        str(table_name),
                         type_=sqltypes.Unicode,
                     )
                 )
@@ -3361,12 +3359,12 @@ class PGDialect(default.DefaultDialect):
                 ).bindparams(
                     sql.bindparam(
                         "name",
-                        util.text_type(table_name),
+                        str(table_name),
                         type_=sqltypes.Unicode,
                     ),
                     sql.bindparam(
                         "schema",
-                        util.text_type(schema),
+                        str(schema),
                         type_=sqltypes.Unicode,
                     ),
                 )
@@ -3384,12 +3382,12 @@ class PGDialect(default.DefaultDialect):
             ).bindparams(
                 sql.bindparam(
                     "name",
-                    util.text_type(sequence_name),
+                    str(sequence_name),
                     type_=sqltypes.Unicode,
                 ),
                 sql.bindparam(
                     "schema",
-                    util.text_type(schema),
+                    str(schema),
                     type_=sqltypes.Unicode,
                 ),
             )
@@ -3418,15 +3416,11 @@ class PGDialect(default.DefaultDialect):
                 """
             query = sql.text(query)
         query = query.bindparams(
-            sql.bindparam(
-                "typname", util.text_type(type_name), type_=sqltypes.Unicode
-            )
+            sql.bindparam("typname", str(type_name), type_=sqltypes.Unicode)
         )
         if schema is not None:
             query = query.bindparams(
-                sql.bindparam(
-                    "nspname", util.text_type(schema), type_=sqltypes.Unicode
-                )
+                sql.bindparam("nspname", str(schema), type_=sqltypes.Unicode)
             )
         cursor = connection.execute(query)
         return bool(cursor.scalar())
@@ -3471,9 +3465,9 @@ class PGDialect(default.DefaultDialect):
         )
         # Since we're binding to unicode, table_name and schema_name must be
         # unicode.
-        table_name = util.text_type(table_name)
+        table_name = str(table_name)
         if schema is not None:
-            schema = util.text_type(schema)
+            schema = str(schema)
         s = sql.text(query).bindparams(table_name=sqltypes.Unicode)
         s = s.columns(oid=sqltypes.Integer)
         if schema:
@@ -3573,7 +3567,7 @@ class PGDialect(default.DefaultDialect):
             ).bindparams(
                 sql.bindparam(
                     "schema",
-                    util.text_type(schema),
+                    str(schema),
                     type_=sqltypes.Unicode,
                 ),
             )
diff --git a/lib/sqlalchemy/dialects/postgresql/dml.py b/lib/sqlalchemy/dialects/postgresql/dml.py
index bb6345cf4..c561b73a1 100644
--- a/lib/sqlalchemy/dialects/postgresql/dml.py
+++ b/lib/sqlalchemy/dialects/postgresql/dml.py
@@ -185,7 +185,7 @@ class OnConflictClause(ClauseElement):
     def __init__(self, constraint=None, index_elements=None, index_where=None):
 
         if constraint is not None:
-            if not isinstance(constraint, util.string_types) and isinstance(
+            if not isinstance(constraint, str) and isinstance(
                 constraint,
                 (schema.Index, schema.Constraint, ext.ExcludeConstraint),
             ):
@@ -197,7 +197,7 @@ class OnConflictClause(ClauseElement):
                     "'constraint' and 'index_elements' are mutually exclusive"
                 )
 
-            if isinstance(constraint, util.string_types):
+            if isinstance(constraint, str):
                 self.constraint_target = constraint
                 self.inferred_target_elements = None
                 self.inferred_target_whereclause = None
diff --git a/lib/sqlalchemy/dialects/postgresql/ext.py b/lib/sqlalchemy/dialects/postgresql/ext.py
index f9e4c1d6c..f779a8010 100644
--- a/lib/sqlalchemy/dialects/postgresql/ext.py
+++ b/lib/sqlalchemy/dialects/postgresql/ext.py
@@ -4,9 +4,9 @@
 #
 # This module is part of SQLAlchemy and is released under
 # the MIT License: https://www.opensource.org/licenses/mit-license.php
+from itertools import zip_longest
 
 from .array import ARRAY
-from ... import util
 from ...sql import coercions
 from ...sql import elements
 from ...sql import expression
@@ -237,7 +237,7 @@ class ExcludeConstraint(ColumnCollectionConstraint):
                 name,
                 operator,
             )
-            for (expr, name, operator), colexpr in util.zip_longest(
+            for (expr, name, operator), colexpr in zip_longest(
                 self._render_exprs, self.columns
             )
         ]
diff --git a/lib/sqlalchemy/dialects/postgresql/hstore.py b/lib/sqlalchemy/dialects/postgresql/hstore.py
index 85d678ef5..2ade4b7c1 100644
--- a/lib/sqlalchemy/dialects/postgresql/hstore.py
+++ b/lib/sqlalchemy/dialects/postgresql/hstore.py
@@ -9,7 +9,6 @@ import re
 
 from .array import ARRAY
 from ... import types as sqltypes
-from ... import util
 from ...sql import functions as sqlfunc
 from ...sql import operators
 
@@ -413,7 +412,7 @@ def _serialize_hstore(val):
     def esc(s, position):
         if position == "value" and s is None:
             return "NULL"
-        elif isinstance(s, util.string_types):
+        elif isinstance(s, str):
             return '"%s"' % s.replace("\\", "\\\\").replace('"', r"\"")
         else:
             raise ValueError(
diff --git a/lib/sqlalchemy/dialects/postgresql/json.py b/lib/sqlalchemy/dialects/postgresql/json.py
index ef046e3ae..fb7621365 100644
--- a/lib/sqlalchemy/dialects/postgresql/json.py
+++ b/lib/sqlalchemy/dialects/postgresql/json.py
@@ -4,10 +4,9 @@
 #
 # This module is part of SQLAlchemy and is released under
 # the MIT License: https://www.opensource.org/licenses/mit-license.php
-from __future__ import absolute_import
+import collections.abc as collections_abc
 
 from ... import types as sqltypes
-from ... import util
 from ...sql import operators
 
 
@@ -71,8 +70,8 @@ class JSONPathType(sqltypes.JSON.JSONPathType):
         super_proc = self.string_bind_processor(dialect)
 
         def process(value):
-            assert isinstance(value, util.collections_abc.Sequence)
-            tokens = [util.text_type(elem) for elem in value]
+            assert isinstance(value, collections_abc.Sequence)
+            tokens = [str(elem) for elem in value]
             value = "{%s}" % (", ".join(tokens))
             if super_proc:
                 value = super_proc(value)
@@ -84,8 +83,8 @@ class JSONPathType(sqltypes.JSON.JSONPathType):
         super_proc = self.string_literal_processor(dialect)
 
         def process(value):
-            assert isinstance(value, util.collections_abc.Sequence)
-            tokens = [util.text_type(elem) for elem in value]
+            assert isinstance(value, collections_abc.Sequence)
+            tokens = [str(elem) for elem in value]
             value = "{%s}" % (", ".join(tokens))
             if super_proc:
                 value = super_proc(value)
diff --git a/lib/sqlalchemy/dialects/postgresql/pg8000.py b/lib/sqlalchemy/dialects/postgresql/pg8000.py
index 324007e7e..ac29b28e9 100644
--- a/lib/sqlalchemy/dialects/postgresql/pg8000.py
+++ b/lib/sqlalchemy/dialects/postgresql/pg8000.py
@@ -554,7 +554,7 @@ class PGDialect_pg8000(PGDialect):
         fns = []
 
         def on_connect(conn):
-            conn.py_types[quoted_name] = conn.py_types[util.text_type]
+            conn.py_types[quoted_name] = conn.py_types[str]
 
         fns.append(on_connect)
 
diff --git a/lib/sqlalchemy/dialects/postgresql/psycopg2.py b/lib/sqlalchemy/dialects/postgresql/psycopg2.py
index f62830a0d..11a5f31a3 100644
--- a/lib/sqlalchemy/dialects/postgresql/psycopg2.py
+++ b/lib/sqlalchemy/dialects/postgresql/psycopg2.py
@@ -441,8 +441,7 @@ place within SQLAlchemy's own marshalling logic, and not that of ``psycopg2``
 which may be more performant.
 
 """  # noqa
-from __future__ import absolute_import
-
+import collections.abc as collections_abc
 import decimal
 import logging
 import re
@@ -466,7 +465,6 @@ from ... import processors
 from ... import types as sqltypes
 from ... import util
 from ...engine import cursor as _cursor
-from ...util import collections_abc
 
 
 logger = logging.getLogger("sqlalchemy.dialects.postgresql")
diff --git a/lib/sqlalchemy/dialects/sqlite/__init__.py b/lib/sqlalchemy/dialects/sqlite/__init__.py
index 6e3ad0e66..e2f59907e 100644
--- a/lib/sqlalchemy/dialects/sqlite/__init__.py
+++ b/lib/sqlalchemy/dialects/sqlite/__init__.py
@@ -5,6 +5,7 @@
 # This module is part of SQLAlchemy and is released under
 # the MIT License: https://www.opensource.org/licenses/mit-license.php
 
+from . import aiosqlite  # noqa
 from . import base  # noqa
 from . import pysqlcipher  # noqa
 from . import pysqlite  # noqa
@@ -26,10 +27,6 @@ from .base import TIMESTAMP
 from .base import VARCHAR
 from .dml import Insert
 from .dml import insert
-from ...util import compat
-
-if compat.py3k:
-    from . import aiosqlite  # noqa
 
 # default dialect
 base.dialect = dialect = pysqlite.dialect
diff --git a/lib/sqlalchemy/dialects/sqlite/base.py b/lib/sqlalchemy/dialects/sqlite/base.py
index 7ded73973..3dea23e18 100644
--- a/lib/sqlalchemy/dialects/sqlite/base.py
+++ b/lib/sqlalchemy/dialects/sqlite/base.py
@@ -1324,7 +1324,7 @@ class SQLiteCompiler(compiler.SQLCompiler):
             target_text = "(%s)" % ", ".join(
                 (
                     self.preparer.quote(c)
-                    if isinstance(c, util.string_types)
+                    if isinstance(c, str)
                     else self.process(c, include_table=False, use_schema=False)
                 )
                 for c in clause.inferred_target_elements
@@ -1401,7 +1401,7 @@ class SQLiteCompiler(compiler.SQLCompiler):
             for k, v in set_parameters.items():
                 key_text = (
                     self.preparer.quote(k)
-                    if isinstance(k, util.string_types)
+                    if isinstance(k, str)
                     else self.process(k, use_schema=False)
                 )
                 value_text = self.process(
@@ -2110,7 +2110,7 @@ class SQLiteDialect(default.DefaultDialect):
         coltype = self._resolve_type_affinity(type_)
 
         if default is not None:
-            default = util.text_type(default)
+            default = str(default)
 
         colspec = {
             "name": name,
diff --git a/lib/sqlalchemy/dialects/sqlite/pysqlcipher.py b/lib/sqlalchemy/dialects/sqlite/pysqlcipher.py
index 3765191c1..d3c504fd4 100644
--- a/lib/sqlalchemy/dialects/sqlite/pysqlcipher.py
+++ b/lib/sqlalchemy/dialects/sqlite/pysqlcipher.py
@@ -94,11 +94,8 @@ time, at the expense of slower startup time for new connections.
 
 """  # noqa
 
-from __future__ import absolute_import
-
 from .pysqlite import SQLiteDialect_pysqlite
 from ... import pool
-from ... import util
 
 
 class SQLiteDialect_pysqlcipher(SQLiteDialect_pysqlite):
@@ -109,18 +106,14 @@ class SQLiteDialect_pysqlcipher(SQLiteDialect_pysqlite):
 
     @classmethod
     def dbapi(cls):
-        if util.py3k:
-            try:
-                import sqlcipher3 as sqlcipher
-            except ImportError:
-                pass
-            else:
-                return sqlcipher
-
-            from pysqlcipher3 import dbapi2 as sqlcipher
-
+        try:
+            import sqlcipher3 as sqlcipher
+        except ImportError:
+            pass
         else:
-            from pysqlcipher import dbapi2 as sqlcipher
+            return sqlcipher
+
+        from pysqlcipher3 import dbapi2 as sqlcipher
 
         return sqlcipher