Try running pyupgrade on the code

command run is "pyupgrade --py37-plus --keep-runtime-typing --keep-percent-format <files...>"
pyupgrade will change assert_ to assertTrue. That was reverted since assertTrue does not
exists in sqlalchemy fixtures

Change-Id: Ie1ed2675c7b11d893d78e028aad0d1576baebb55

22 files changed, 91 insertions, 133 deletions

diff --git a/test/dialect/mssql/test_compiler.py b/test/dialect/mssql/test_compiler.py
index b575595ac..00bbc2af4 100644
--- a/test/dialect/mssql/test_compiler.py
+++ b/test/dialect/mssql/test_compiler.py
@@ -1,4 +1,3 @@
-# -*- encoding: utf-8
 from sqlalchemy import bindparam
 from sqlalchemy import Column
 from sqlalchemy import Computed
diff --git a/test/dialect/mssql/test_deprecations.py b/test/dialect/mssql/test_deprecations.py
index 972ce413b..019712376 100644
--- a/test/dialect/mssql/test_deprecations.py
+++ b/test/dialect/mssql/test_deprecations.py
@@ -1,4 +1,3 @@
-# -*- encoding: utf-8
 from unittest.mock import Mock
 
 from sqlalchemy import Column
diff --git a/test/dialect/mssql/test_engine.py b/test/dialect/mssql/test_engine.py
index d19e591b4..6b895e3f1 100644
--- a/test/dialect/mssql/test_engine.py
+++ b/test/dialect/mssql/test_engine.py
@@ -1,5 +1,3 @@
-# -*- encoding: utf-8
-
 from decimal import Decimal
 import re
 from unittest.mock import Mock
diff --git a/test/dialect/mssql/test_query.py b/test/dialect/mssql/test_query.py
index 29bf4c812..b65e27445 100644
--- a/test/dialect/mssql/test_query.py
+++ b/test/dialect/mssql/test_query.py
@@ -1,4 +1,3 @@
-# -*- encoding: utf-8
 import decimal
 
 from sqlalchemy import and_
diff --git a/test/dialect/mssql/test_reflection.py b/test/dialect/mssql/test_reflection.py
index f682538b3..1716d68e3 100644
--- a/test/dialect/mssql/test_reflection.py
+++ b/test/dialect/mssql/test_reflection.py
@@ -1,4 +1,3 @@
-# -*- encoding: utf-8
 import datetime
 import decimal
 import random
@@ -514,7 +513,7 @@ class ReflectionTest(fixtures.TestBase, ComparesTables, AssertsCompiledSQL):
         m2 = MetaData()
         t2 = Table("t", m2, autoload_with=connection)
 
-        eq_(set(list(t2.indexes)[0].columns), set([t2.c["x"], t2.c.y]))
+        eq_(set(list(t2.indexes)[0].columns), {t2.c["x"], t2.c.y})
 
     def test_indexes_cols_with_commas(self, metadata, connection):
 
@@ -530,7 +529,7 @@ class ReflectionTest(fixtures.TestBase, ComparesTables, AssertsCompiledSQL):
         m2 = MetaData()
         t2 = Table("t", m2, autoload_with=connection)
 
-        eq_(set(list(t2.indexes)[0].columns), set([t2.c["x, col"], t2.c.y]))
+        eq_(set(list(t2.indexes)[0].columns), {t2.c["x, col"], t2.c.y})
 
     def test_indexes_cols_with_spaces(self, metadata, connection):
 
@@ -546,7 +545,7 @@ class ReflectionTest(fixtures.TestBase, ComparesTables, AssertsCompiledSQL):
         m2 = MetaData()
         t2 = Table("t", m2, autoload_with=connection)
 
-        eq_(set(list(t2.indexes)[0].columns), set([t2.c["x col"], t2.c.y]))
+        eq_(set(list(t2.indexes)[0].columns), {t2.c["x col"], t2.c.y})
 
     def test_indexes_with_filtered(self, metadata, connection):
 
diff --git a/test/dialect/mssql/test_types.py b/test/dialect/mssql/test_types.py
index eb14cb30f..867e42202 100644
--- a/test/dialect/mssql/test_types.py
+++ b/test/dialect/mssql/test_types.py
@@ -1,4 +1,3 @@
-# -*- encoding: utf-8
 import codecs
 import datetime
 import decimal
diff --git a/test/dialect/mysql/test_compiler.py b/test/dialect/mysql/test_compiler.py
index a4a0b24e4..414f73ad7 100644
--- a/test/dialect/mysql/test_compiler.py
+++ b/test/dialect/mysql/test_compiler.py
@@ -1,5 +1,3 @@
-# coding: utf-8
-
 from sqlalchemy import BLOB
 from sqlalchemy import BOOLEAN
 from sqlalchemy import Boolean
diff --git a/test/dialect/mysql/test_dialect.py b/test/dialect/mysql/test_dialect.py
index d79f2629f..ed0fc6fac 100644
--- a/test/dialect/mysql/test_dialect.py
+++ b/test/dialect/mysql/test_dialect.py
@@ -1,5 +1,3 @@
-# coding: utf-8
-
 import datetime
 
 from sqlalchemy import bindparam
diff --git a/test/dialect/mysql/test_query.py b/test/dialect/mysql/test_query.py
index f56cd98aa..0ce361182 100644
--- a/test/dialect/mysql/test_query.py
+++ b/test/dialect/mysql/test_query.py
@@ -1,5 +1,3 @@
-# coding: utf-8
-
 from sqlalchemy import all_
 from sqlalchemy import and_
 from sqlalchemy import any_
diff --git a/test/dialect/mysql/test_reflection.py b/test/dialect/mysql/test_reflection.py
index 8f093f134..5e582a492 100644
--- a/test/dialect/mysql/test_reflection.py
+++ b/test/dialect/mysql/test_reflection.py
@@ -1,5 +1,3 @@
-# coding: utf-8
-
 import re
 
 from sqlalchemy import BigInteger
@@ -875,10 +873,10 @@ class ReflectionTest(fixtures.TestBase, AssertsCompiledSQL):
 
         # MySQL converts unique constraints into unique indexes.
         # separately we get both
-        indexes = dict((i["name"], i) for i in insp.get_indexes("mysql_uc"))
-        constraints = set(
+        indexes = {i["name"]: i for i in insp.get_indexes("mysql_uc")}
+        constraints = {
             i["name"] for i in insp.get_unique_constraints("mysql_uc")
-        )
+        }
 
         self.assert_("uc_a" in indexes)
         self.assert_(indexes["uc_a"]["unique"])
@@ -888,8 +886,8 @@ class ReflectionTest(fixtures.TestBase, AssertsCompiledSQL):
         # more "official" MySQL construct
         reflected = Table("mysql_uc", MetaData(), autoload_with=testing.db)
 
-        indexes = dict((i.name, i) for i in reflected.indexes)
-        constraints = set(uc.name for uc in reflected.constraints)
+        indexes = {i.name: i for i in reflected.indexes}
+        constraints = {uc.name for uc in reflected.constraints}
 
         self.assert_("uc_a" in indexes)
         self.assert_(indexes["uc_a"].unique)
@@ -1259,10 +1257,10 @@ class ReflectionTest(fixtures.TestBase, AssertsCompiledSQL):
         m.create_all(connection)
 
         eq_(
-            dict(
-                (rec["name"], rec)
+            {
+                rec["name"]: rec
                 for rec in inspect(connection).get_foreign_keys("t2")
-            ),
+            },
             {
                 "cap_t1id_fk": {
                     "name": "cap_t1id_fk",
diff --git a/test/dialect/mysql/test_types.py b/test/dialect/mysql/test_types.py
index 76e800e86..eca1051e2 100644
--- a/test/dialect/mysql/test_types.py
+++ b/test/dialect/mysql/test_types.py
@@ -1,4 +1,3 @@
-# coding: utf-8
 from collections import OrderedDict
 import datetime
 import decimal
@@ -990,14 +989,14 @@ class EnumSetTest(
             t.insert(),
             [
                 {"id": 1, "data": set()},
-                {"id": 2, "data": set([""])},
-                {"id": 3, "data": set(["a", ""])},
-                {"id": 4, "data": set(["b"])},
+                {"id": 2, "data": {""}},
+                {"id": 3, "data": {"a", ""}},
+                {"id": 4, "data": {"b"}},
             ],
         )
         eq_(
             connection.execute(t.select().order_by(t.c.id)).fetchall(),
-            [(1, set()), (2, set()), (3, set(["a"])), (4, set(["b"]))],
+            [(1, set()), (2, set()), (3, {"a"}), (4, {"b"})],
         )
 
     def test_bitwise_required_for_empty(self):
@@ -1023,18 +1022,18 @@ class EnumSetTest(
             t.insert(),
             [
                 {"id": 1, "data": set()},
-                {"id": 2, "data": set([""])},
-                {"id": 3, "data": set(["a", ""])},
-                {"id": 4, "data": set(["b"])},
+                {"id": 2, "data": {""}},
+                {"id": 3, "data": {"a", ""}},
+                {"id": 4, "data": {"b"}},
             ],
         )
         eq_(
             connection.execute(t.select().order_by(t.c.id)).fetchall(),
             [
                 (1, set()),
-                (2, set([""])),
-                (3, set(["a", ""])),
-                (4, set(["b"])),
+                (2, {""}),
+                (3, {"a", ""}),
+                (4, {"b"}),
             ],
         )
 
@@ -1052,18 +1051,18 @@ class EnumSetTest(
 
         expected = [
             (
-                set(["a"]),
-                set(["a"]),
-                set(["a"]),
-                set(["'a'"]),
-                set(["a", "b"]),
+                {"a"},
+                {"a"},
+                {"a"},
+                {"'a'"},
+                {"a", "b"},
             ),
             (
-                set(["b"]),
-                set(["b"]),
-                set(["b"]),
-                set(["b"]),
-                set(["a", "b"]),
+                {"b"},
+                {"b"},
+                {"b"},
+                {"b"},
+                {"a", "b"},
             ),
         ]
         res = connection.execute(set_table.select()).fetchall()
@@ -1079,13 +1078,11 @@ class EnumSetTest(
         )
 
         set_table.create(connection)
-        connection.execute(
-            set_table.insert(), {"data": set(["réveillé", "drôle"])}
-        )
+        connection.execute(set_table.insert(), {"data": {"réveillé", "drôle"}})
 
         row = connection.execute(set_table.select()).first()
 
-        eq_(row, (1, set(["réveillé", "drôle"])))
+        eq_(row, (1, {"réveillé", "drôle"}))
 
     def test_int_roundtrip(self, metadata, connection):
         set_table = self._set_fixture_one(metadata)
@@ -1097,11 +1094,11 @@ class EnumSetTest(
         eq_(
             res,
             (
-                set(["a"]),
-                set(["b"]),
-                set(["a", "b"]),
-                set(["'a'", "b"]),
-                set([]),
+                {"a"},
+                {"b"},
+                {"a", "b"},
+                {"'a'", "b"},
+                set(),
             ),
         )
 
@@ -1129,24 +1126,24 @@ class EnumSetTest(
                 connection.execute(table.delete())
 
             roundtrip([None, None, None], [None] * 3)
-            roundtrip(["", "", ""], [set([])] * 3)
-            roundtrip([set(["dq"]), set(["a"]), set(["5"])])
-            roundtrip(["dq", "a", "5"], [set(["dq"]), set(["a"]), set(["5"])])
-            roundtrip([1, 1, 1], [set(["dq"]), set(["a"]), set(["5"])])
-            roundtrip([set(["dq", "sq"]), None, set(["9", "5", "7"])])
+            roundtrip(["", "", ""], [set()] * 3)
+            roundtrip([{"dq"}, {"a"}, {"5"}])
+            roundtrip(["dq", "a", "5"], [{"dq"}, {"a"}, {"5"}])
+            roundtrip([1, 1, 1], [{"dq"}, {"a"}, {"5"}])
+            roundtrip([{"dq", "sq"}, None, {"9", "5", "7"}])
         connection.execute(
             set_table.insert(),
             [
-                {"s3": set(["5"])},
-                {"s3": set(["5", "7"])},
-                {"s3": set(["5", "7", "9"])},
-                {"s3": set(["7", "9"])},
+                {"s3": {"5"}},
+                {"s3": {"5", "7"}},
+                {"s3": {"5", "7", "9"}},
+                {"s3": {"7", "9"}},
             ],
         )
 
         rows = connection.execute(
             select(set_table.c.s3).where(
-                set_table.c.s3.in_([set(["5"]), ["5", "7"]])
+                set_table.c.s3.in_([{"5"}, ["5", "7"]])
             )
         ).fetchall()
 
diff --git a/test/dialect/oracle/test_compiler.py b/test/dialect/oracle/test_compiler.py
index 8981e74e8..dff8584e3 100644
--- a/test/dialect/oracle/test_compiler.py
+++ b/test/dialect/oracle/test_compiler.py
@@ -1,4 +1,3 @@
-# coding: utf-8
 from sqlalchemy import and_
 from sqlalchemy import bindparam
 from sqlalchemy import cast
diff --git a/test/dialect/oracle/test_dialect.py b/test/dialect/oracle/test_dialect.py
index 9c2496b05..4370992e8 100644
--- a/test/dialect/oracle/test_dialect.py
+++ b/test/dialect/oracle/test_dialect.py
@@ -1,5 +1,3 @@
-# coding: utf-8
-
 from multiprocessing import get_context
 import re
 from unittest import mock
diff --git a/test/dialect/oracle/test_reflection.py b/test/dialect/oracle/test_reflection.py
index 901db9f4e..60a05a6b6 100644
--- a/test/dialect/oracle/test_reflection.py
+++ b/test/dialect/oracle/test_reflection.py
@@ -1,6 +1,3 @@
-# coding: utf-8
-
-
 from sqlalchemy import CHAR
 from sqlalchemy import Double
 from sqlalchemy import exc
@@ -426,7 +423,7 @@ class SystemTableTablenamesTest(fixtures.TestBase):
             set(insp.get_table_names()).intersection(
                 ["my_table", "foo_table"]
             ),
-            set(["my_table", "foo_table"]),
+            {"my_table", "foo_table"},
         )
 
     def test_reflect_system_table(self):
@@ -469,7 +466,7 @@ class DontReflectIOTTest(fixtures.TestBase):
     def test_reflect_all(self, connection):
         m = MetaData()
         m.reflect(connection)
-        eq_(set(t.name for t in m.tables.values()), set(["admin_docindex"]))
+        eq_({t.name for t in m.tables.values()}, {"admin_docindex"})
 
 
 def all_tables_compression_missing():
@@ -924,12 +921,10 @@ class RoundTripIndexTest(fixtures.TestBase):
 
         # make a dictionary of the reflected objects:
 
-        reflected = dict(
-            [
-                (obj_definition(i), i)
-                for i in reflectedtable.indexes | reflectedtable.constraints
-            ]
-        )
+        reflected = {
+            obj_definition(i): i
+            for i in reflectedtable.indexes | reflectedtable.constraints
+        }
 
         # assert we got primary key constraint and its name, Error
         # if not in dict
diff --git a/test/dialect/oracle/test_types.py b/test/dialect/oracle/test_types.py
index 8c78fe85b..2ba42f584 100644
--- a/test/dialect/oracle/test_types.py
+++ b/test/dialect/oracle/test_types.py
@@ -1,6 +1,3 @@
-# coding: utf-8
-
-
 import datetime
 import decimal
 import os
diff --git a/test/dialect/postgresql/test_compiler.py b/test/dialect/postgresql/test_compiler.py
index 338d0da4e..431cd7ded 100644
--- a/test/dialect/postgresql/test_compiler.py
+++ b/test/dialect/postgresql/test_compiler.py
@@ -1,4 +1,3 @@
-# coding: utf-8
 from sqlalchemy import and_
 from sqlalchemy import BigInteger
 from sqlalchemy import bindparam
@@ -2871,7 +2870,7 @@ class InsertOnConflictTest(fixtures.TablesTest, AssertsCompiledSQL):
         i = i.on_conflict_do_update(
             constraint=self.excl_constr_anon,
             set_=dict(name=i.excluded.name),
-            where=((self.table1.c.name != i.excluded.name)),
+            where=(self.table1.c.name != i.excluded.name),
         )
         self.assert_compile(
             i,
@@ -2913,7 +2912,7 @@ class InsertOnConflictTest(fixtures.TablesTest, AssertsCompiledSQL):
             i.on_conflict_do_update(
                 constraint=self.excl_constr_anon,
                 set_=dict(name=i.excluded.name),
-                where=((self.table1.c.name != i.excluded.name)),
+                where=(self.table1.c.name != i.excluded.name),
             )
             .returning(literal_column("1"))
             .cte("i_upsert")
diff --git a/test/dialect/postgresql/test_dialect.py b/test/dialect/postgresql/test_dialect.py
index 27d4a4cf9..e8d9a8eb6 100644
--- a/test/dialect/postgresql/test_dialect.py
+++ b/test/dialect/postgresql/test_dialect.py
@@ -1,4 +1,3 @@
-# coding: utf-8
 import dataclasses
 import datetime
 import logging
diff --git a/test/dialect/postgresql/test_on_conflict.py b/test/dialect/postgresql/test_on_conflict.py
index 9c1aaf78e..3cdad78f0 100644
--- a/test/dialect/postgresql/test_on_conflict.py
+++ b/test/dialect/postgresql/test_on_conflict.py
@@ -1,5 +1,3 @@
-# coding: utf-8
-
 from sqlalchemy import Column
 from sqlalchemy import exc
 from sqlalchemy import Integer
diff --git a/test/dialect/postgresql/test_query.py b/test/dialect/postgresql/test_query.py
index 6afc2f7c1..42ec20743 100644
--- a/test/dialect/postgresql/test_query.py
+++ b/test/dialect/postgresql/test_query.py
@@ -1,5 +1,3 @@
-# coding: utf-8
-
 import datetime
 
 from sqlalchemy import and_
diff --git a/test/dialect/postgresql/test_reflection.py b/test/dialect/postgresql/test_reflection.py
index f0893d822..88b0b73cc 100644
--- a/test/dialect/postgresql/test_reflection.py
+++ b/test/dialect/postgresql/test_reflection.py
@@ -1,5 +1,3 @@
-# coding: utf-8
-
 import itertools
 from operator import itemgetter
 import re
@@ -120,7 +118,7 @@ class ForeignTableReflectionTest(
         table = Table("test_foreigntable", metadata, autoload_with=connection)
         eq_(
             set(table.columns.keys()),
-            set(["id", "data"]),
+            {"id", "data"},
             "Columns of reflected foreign table didn't equal expected columns",
         )
 
@@ -286,7 +284,7 @@ class MaterializedViewReflectionTest(
         table = Table("test_mview", metadata, autoload_with=connection)
         eq_(
             set(table.columns.keys()),
-            set(["id", "data"]),
+            {"id", "data"},
             "Columns of reflected mview didn't equal expected columns",
         )
 
@@ -297,24 +295,24 @@ class MaterializedViewReflectionTest(
 
     def test_get_view_names(self, inspect_fixture):
         insp, conn = inspect_fixture
-        eq_(set(insp.get_view_names()), set(["test_regview"]))
+        eq_(set(insp.get_view_names()), {"test_regview"})
 
     def test_get_materialized_view_names(self, inspect_fixture):
         insp, conn = inspect_fixture
-        eq_(set(insp.get_materialized_view_names()), set(["test_mview"]))
+        eq_(set(insp.get_materialized_view_names()), {"test_mview"})
 
     def test_get_view_names_reflection_cache_ok(self, connection):
         insp = inspect(connection)
-        eq_(set(insp.get_view_names()), set(["test_regview"]))
+        eq_(set(insp.get_view_names()), {"test_regview"})
         eq_(
             set(insp.get_materialized_view_names()),
-            set(["test_mview"]),
+            {"test_mview"},
         )
         eq_(
             set(insp.get_view_names()).union(
                 insp.get_materialized_view_names()
             ),
-            set(["test_regview", "test_mview"]),
+            {"test_regview", "test_mview"},
         )
 
     def test_get_view_definition(self, connection):
@@ -481,7 +479,7 @@ class DomainReflectionTest(fixtures.TestBase, AssertsExecutionResults):
         table = Table("testtable", metadata, autoload_with=connection)
         eq_(
             set(table.columns.keys()),
-            set(["question", "answer"]),
+            {"question", "answer"},
             "Columns of reflected table didn't equal expected columns",
         )
         assert isinstance(table.c.answer.type, Integer)
@@ -532,7 +530,7 @@ class DomainReflectionTest(fixtures.TestBase, AssertsExecutionResults):
         )
         eq_(
             set(table.columns.keys()),
-            set(["question", "answer", "anything"]),
+            {"question", "answer", "anything"},
             "Columns of reflected table didn't equal expected columns",
         )
         assert isinstance(table.c.anything.type, Integer)
@@ -1081,7 +1079,7 @@ class ReflectionTest(
 
         eq_(
             set(meta2.tables),
-            set(["test_schema_2.some_other_table", "some_table"]),
+            {"test_schema_2.some_other_table", "some_table"},
         )
 
         meta3 = MetaData()
@@ -1093,12 +1091,10 @@ class ReflectionTest(
 
         eq_(
             set(meta3.tables),
-            set(
-                [
-                    "test_schema_2.some_other_table",
-                    "test_schema.some_table",
-                ]
-            ),
+            {
+                "test_schema_2.some_other_table",
+                "test_schema.some_table",
+            },
         )
 
     def test_cross_schema_reflection_metadata_uses_schema(
@@ -1125,7 +1121,7 @@ class ReflectionTest(
 
         eq_(
             set(meta2.tables),
-            set(["some_other_table", "test_schema.some_table"]),
+            {"some_other_table", "test_schema.some_table"},
         )
 
     def test_uppercase_lowercase_table(self, metadata, connection):
@@ -1881,10 +1877,10 @@ class ReflectionTest(
 
         # PostgreSQL will create an implicit index for a unique
         # constraint.   Separately we get both
-        indexes = set(i["name"] for i in insp.get_indexes("pgsql_uc"))
-        constraints = set(
+        indexes = {i["name"] for i in insp.get_indexes("pgsql_uc")}
+        constraints = {
             i["name"] for i in insp.get_unique_constraints("pgsql_uc")
-        )
+        }
 
         self.assert_("uc_a" in indexes)
         self.assert_("uc_a" in constraints)
@@ -1892,8 +1888,8 @@ class ReflectionTest(
         # reflection corrects for the dupe
         reflected = Table("pgsql_uc", MetaData(), autoload_with=connection)
 
-        indexes = set(i.name for i in reflected.indexes)
-        constraints = set(uc.name for uc in reflected.constraints)
+        indexes = {i.name for i in reflected.indexes}
+        constraints = {uc.name for uc in reflected.constraints}
 
         self.assert_("uc_a" not in indexes)
         self.assert_("uc_a" in constraints)
@@ -1951,10 +1947,10 @@ class ReflectionTest(
 
         uc_table.create(connection)
 
-        indexes = dict((i["name"], i) for i in insp.get_indexes("pgsql_uc"))
-        constraints = set(
+        indexes = {i["name"]: i for i in insp.get_indexes("pgsql_uc")}
+        constraints = {
             i["name"] for i in insp.get_unique_constraints("pgsql_uc")
-        )
+        }
 
         self.assert_("ix_a" in indexes)
         assert indexes["ix_a"]["unique"]
@@ -1962,8 +1958,8 @@ class ReflectionTest(
 
         reflected = Table("pgsql_uc", MetaData(), autoload_with=connection)
 
-        indexes = dict((i.name, i) for i in reflected.indexes)
-        constraints = set(uc.name for uc in reflected.constraints)
+        indexes = {i.name: i for i in reflected.indexes}
+        constraints = {uc.name for uc in reflected.constraints}
 
         self.assert_("ix_a" in indexes)
         assert indexes["ix_a"].unique
@@ -2005,11 +2001,11 @@ class ReflectionTest(
 
         reflected = Table("pgsql_cc", MetaData(), autoload_with=connection)
 
-        check_constraints = dict(
-            (uc.name, uc.sqltext.text)
+        check_constraints = {
+            uc.name: uc.sqltext.text
             for uc in reflected.constraints
             if isinstance(uc, CheckConstraint)
-        )
+        }
 
         eq_(
             check_constraints,
diff --git a/test/dialect/postgresql/test_types.py b/test/dialect/postgresql/test_types.py
index 39e7d7317..61de57ed4 100644
--- a/test/dialect/postgresql/test_types.py
+++ b/test/dialect/postgresql/test_types.py
@@ -1,4 +1,3 @@
-# coding: utf-8
 import datetime
 import decimal
 from enum import Enum as _PY_Enum
@@ -2235,8 +2234,8 @@ class ArrayRoundTripTest:
         )
         # hashable
         eq_(
-            set(row[1] for row in r),
-            set([("1", "2", "3"), ("4", "5", "6"), (("4", "5"), ("6", "7"))]),
+            {row[1] for row in r},
+            {("1", "2", "3"), ("4", "5", "6"), (("4", "5"), ("6", "7"))},
         )
 
     def test_array_plus_native_enum_create(self, metadata, connection):
@@ -2261,8 +2260,8 @@ class ArrayRoundTripTest:
 
         t.create(connection)
         eq_(
-            set(e["name"] for e in inspect(connection).get_enums()),
-            set(["my_enum_1", "my_enum_2", "my_enum_3"]),
+            {e["name"] for e in inspect(connection).get_enums()},
+            {"my_enum_1", "my_enum_2", "my_enum_3"},
         )
         t.drop(connection)
         eq_(inspect(connection).get_enums(), [])
@@ -2686,7 +2685,7 @@ class _ArrayOfEnum(TypeDecorator):
         return sa.cast(bindvalue, self)
 
     def result_processor(self, dialect, coltype):
-        super_rp = super(_ArrayOfEnum, self).result_processor(dialect, coltype)
+        super_rp = super().result_processor(dialect, coltype)
 
         def handle_raw_string(value):
             inner = re.match(r"^{(.*)}$", value).group(1)
@@ -5253,7 +5252,7 @@ class JSONBTest(JSONTest):
         ),
     )
     def test_where(self, whereclause_fn, expected):
-        super(JSONBTest, self).test_where(whereclause_fn, expected)
+        super().test_where(whereclause_fn, expected)
 
 
 class JSONBRoundTripTest(JSONRoundTripTest):
@@ -5263,7 +5262,7 @@ class JSONBRoundTripTest(JSONRoundTripTest):
 
     @testing.requires.postgresql_utf8_server_encoding
     def test_unicode_round_trip(self, connection):
-        super(JSONBRoundTripTest, self).test_unicode_round_trip(connection)
+        super().test_unicode_round_trip(connection)
 
     @testing.only_on("postgresql >= 12")
     def test_cast_jsonpath(self, connection):
diff --git a/test/dialect/test_sqlite.py b/test/dialect/test_sqlite.py
index 643a56c1b..5bda6577f 100644
--- a/test/dialect/test_sqlite.py
+++ b/test/dialect/test_sqlite.py
@@ -1,5 +1,3 @@
-#!coding: utf-8
-
 """SQLite-specific tests."""
 import datetime
 import json