- the raw 2to3 run

- went through examples/ and cleaned out excess list() calls

4 files changed, 101 insertions, 99 deletions

diff --git a/test/base/test_dependency.py b/test/base/test_dependency.py
index f4a0a4c8b..b16516f15 100644
--- a/test/base/test_dependency.py
+++ b/test/base/test_dependency.py
@@ -82,7 +82,7 @@ class DependencySortTest(fixtures.TestBase):
         try:
             list(topological.sort(tuples, allitems))
             assert False
-        except exc.CircularDependencyError, err:
+        except exc.CircularDependencyError as err:
             eq_(err.cycles, set(['node1', 'node3', 'node2', 'node5',
                 'node4']))
             eq_(err.edges, set([('node3', 'node1'), ('node4', 'node1'),
@@ -105,7 +105,7 @@ class DependencySortTest(fixtures.TestBase):
         try:
             list(topological.sort(tuples, allitems))
             assert False
-        except exc.CircularDependencyError, err:
+        except exc.CircularDependencyError as err:
             eq_(err.cycles, set(['node1', 'node3', 'node2']))
             eq_(err.edges, set([('node3', 'node1'), ('node2', 'node3'),
                 ('node3', 'node2'), ('node1', 'node2'),
@@ -271,7 +271,7 @@ class DependencySortTest(fixtures.TestBase):
               ('node4', 'node17'), ('node2', 'node20'), ('node19', 'node10'),
               ('node8', 'node4'), ('node11', 'node3'), ('node6', 'node1')
         ]
-        allnodes = ['node%d' % i for i in xrange(1, 21)]
+        allnodes = ['node%d' % i for i in range(1, 21)]
         eq_(
             topological.find_cycles(tuples, allnodes),
             set(['node11', 'node10', 'node13', 'node15', 'node14', 'node17',
diff --git a/test/base/test_events.py b/test/base/test_events.py
index 4efb30aba..7cfb5fa7d 100644
--- a/test/base/test_events.py
+++ b/test/base/test_events.py
@@ -190,7 +190,7 @@ class ClsLevelListenTest(fixtures.TestBase):
     def test_lis_subcalss_lis(self):
         @event.listens_for(self.TargetOne, "event_one")
         def handler1(x, y):
-            print 'handler1'
+            print('handler1')
 
         class SubTarget(self.TargetOne):
             pass
@@ -207,7 +207,7 @@ class ClsLevelListenTest(fixtures.TestBase):
     def test_lis_multisub_lis(self):
         @event.listens_for(self.TargetOne, "event_one")
         def handler1(x, y):
-            print 'handler1'
+            print('handler1')
 
         class SubTarget(self.TargetOne):
             pass
diff --git a/test/base/test_except.py b/test/base/test_except.py
index a8c7de201..f2428c22d 100644
--- a/test/base/test_except.py
+++ b/test/base/test_except.py
@@ -5,14 +5,15 @@ from sqlalchemy import exc as sa_exceptions
 from sqlalchemy.testing import fixtures
 from sqlalchemy.testing import eq_
 
-# Py3K
-#StandardError = BaseException
-# Py2K
-from exceptions import StandardError, KeyboardInterrupt, SystemExit
+# start Py3K
+Exception = BaseException
+# end Py3K
+# start Py2K
+#from exceptions import StandardError, KeyboardInterrupt, SystemExit
 # end Py2K
 
 
-class Error(StandardError):
+class Error(Exception):
     """This class will be old-style on <= 2.4 and new-style on >=
     2.5."""
 
@@ -47,7 +48,7 @@ class WrapTest(fixtures.TestBase):
         try:
             raise sa_exceptions.DBAPIError.instance('this is a message'
                     , None, OperationalError(), DatabaseError)
-        except sa_exceptions.DBAPIError, exc:
+        except sa_exceptions.DBAPIError as exc:
             assert str(exc) \
                 == "(OperationalError)  'this is a message' None"
 
@@ -58,7 +59,7 @@ class WrapTest(fixtures.TestBase):
                 {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6, 'g': 7, 'h':
                 8, 'i': 9, 'j': 10, 'k': 11,
                 }, OperationalError(), DatabaseError)
-        except sa_exceptions.DBAPIError, exc:
+        except sa_exceptions.DBAPIError as exc:
             assert str(exc).startswith("(OperationalError)  'this is a "
                     "message' {")
 
@@ -67,7 +68,7 @@ class WrapTest(fixtures.TestBase):
             raise sa_exceptions.DBAPIError.instance('this is a message',
                 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,],
                 OperationalError(), DatabaseError)
-        except sa_exceptions.DBAPIError, exc:
+        except sa_exceptions.DBAPIError as exc:
             assert str(exc).startswith("(OperationalError)  'this is a "
                     "message' [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]")
 
@@ -77,7 +78,7 @@ class WrapTest(fixtures.TestBase):
                 [{1: 1}, {1: 1}, {1: 1}, {1: 1}, {1: 1}, {1: 1},
                 {1: 1}, {1:1}, {1: 1}, {1: 1},],
                 OperationalError(), DatabaseError)
-        except sa_exceptions.DBAPIError, exc:
+        except sa_exceptions.DBAPIError as exc:
             eq_(str(exc) ,
                 "(OperationalError)  'this is a message' [{1: 1}, "\
                 "{1: 1}, {1: 1}, {1: 1}, {1: 1}, {1: 1}, {1: 1}, {1: "\
@@ -87,7 +88,7 @@ class WrapTest(fixtures.TestBase):
                 {1: 1}, {1: 1}, {1: 1}, {1: 1}, {1: 1}, {1: 1}, {1: 1},
                 {1:1}, {1: 1}, {1: 1}, {1: 1},
                 ], OperationalError(), DatabaseError)
-        except sa_exceptions.DBAPIError, exc:
+        except sa_exceptions.DBAPIError as exc:
             eq_(str(exc) ,
                 "(OperationalError)  'this is a message' [{1: 1}, "
                 "{1: 1}, {1: 1}, {1: 1}, {1: 1}, {1: 1}, "
@@ -100,7 +101,7 @@ class WrapTest(fixtures.TestBase):
                 (1, ), (1, ), (1, ), (1, ), (1, ), (1, ), (1, ), (1, ), (1, ),
                 (1, ),
                 ], OperationalError(), DatabaseError)
-        except sa_exceptions.DBAPIError, exc:
+        except sa_exceptions.DBAPIError as exc:
             eq_(str(exc),
                 "(OperationalError)  'this is a message' [(1,), "\
                 "(1,), (1,), (1,), (1,), (1,), (1,), (1,), (1,), (1,)]")
@@ -109,7 +110,7 @@ class WrapTest(fixtures.TestBase):
                 (1, ), (1, ), (1, ), (1, ), (1, ), (1, ), (1, ), (1, ), (1, ),
                 (1, ), (1, ),
                 ], OperationalError(), DatabaseError)
-        except sa_exceptions.DBAPIError, exc:
+        except sa_exceptions.DBAPIError as exc:
             eq_(str(exc),
                 "(OperationalError)  'this is a message' [(1,), "
                 "(1,), (1,), (1,), (1,), (1,), (1,), (1,)  "
@@ -121,7 +122,7 @@ class WrapTest(fixtures.TestBase):
         try:
             raise sa_exceptions.DBAPIError.instance('', [],
                     ProgrammingError(), DatabaseError)
-        except sa_exceptions.DBAPIError, e:
+        except sa_exceptions.DBAPIError as e:
             self.assert_(True)
             self.assert_('Error in str() of DB-API' in e.args[0])
 
@@ -129,7 +130,7 @@ class WrapTest(fixtures.TestBase):
         try:
             raise sa_exceptions.DBAPIError.instance('', [], OutOfSpec(),
                         DatabaseError)
-        except sa_exceptions.DBAPIError, e:
+        except sa_exceptions.DBAPIError as e:
             self.assert_(e.__class__ is sa_exceptions.DBAPIError)
         except OutOfSpec:
             self.assert_(False)
@@ -137,7 +138,7 @@ class WrapTest(fixtures.TestBase):
         try:
             raise sa_exceptions.DBAPIError.instance('', [],
                     sa_exceptions.ArgumentError(), DatabaseError)
-        except sa_exceptions.DBAPIError, e:
+        except sa_exceptions.DBAPIError as e:
             self.assert_(e.__class__ is sa_exceptions.DBAPIError)
         except sa_exceptions.ArgumentError:
             self.assert_(False)
diff --git a/test/base/test_utils.py b/test/base/test_utils.py
index af881af17..6dcfaf9d1 100644
--- a/test/base/test_utils.py
+++ b/test/base/test_utils.py
@@ -16,7 +16,7 @@ class KeyedTupleTest():
         eq_(len(keyed_tuple), 0)
 
         eq_(keyed_tuple.__dict__, {'_labels': []})
-        eq_(keyed_tuple.keys(), [])
+        eq_(list(keyed_tuple.keys()), [])
         eq_(keyed_tuple._fields, ())
         eq_(keyed_tuple._asdict(), {})
 
@@ -27,7 +27,7 @@ class KeyedTupleTest():
         eq_(len(keyed_tuple), 2)
 
         eq_(keyed_tuple.__dict__, {'_labels': []})
-        eq_(keyed_tuple.keys(), [])
+        eq_(list(keyed_tuple.keys()), [])
         eq_(keyed_tuple._fields, ())
         eq_(keyed_tuple._asdict(), {})
 
@@ -37,7 +37,7 @@ class KeyedTupleTest():
     def test_basic_creation(self):
         keyed_tuple = util.KeyedTuple([1, 2], ['a', 'b'])
         eq_(str(keyed_tuple), '(1, 2)')
-        eq_(keyed_tuple.keys(), ['a', 'b'])
+        eq_(list(keyed_tuple.keys()), ['a', 'b'])
         eq_(keyed_tuple._fields, ('a', 'b'))
         eq_(keyed_tuple._asdict(), {'a': 1, 'b': 2})
 
@@ -66,7 +66,7 @@ class KeyedTupleTest():
         # TODO: consider not allowing None labels
         expected = {'a': 1, None: 2, 'b': 3, '_labels': ['a', None, 'b']}
         eq_(keyed_tuple.__dict__, expected)
-        eq_(keyed_tuple.keys(), ['a', 'b'])
+        eq_(list(keyed_tuple.keys()), ['a', 'b'])
         eq_(keyed_tuple._fields, ('a', 'b'))
         eq_(keyed_tuple._asdict(), {'a': 1, 'b': 3})
 
@@ -86,7 +86,7 @@ class KeyedTupleTest():
         # TODO: consider not allowing duplicate labels
         expected = {'a': 1, 'b': 3, '_labels': ['a', 'b', 'b']}
         eq_(keyed_tuple.__dict__, expected)
-        eq_(keyed_tuple.keys(), ['a', 'b', 'b'])
+        eq_(list(keyed_tuple.keys()), ['a', 'b', 'b'])
         eq_(keyed_tuple._fields, ('a', 'b', 'b'))
         eq_(keyed_tuple._asdict(), {'a': 1, 'b': 3})
 
@@ -125,12 +125,12 @@ class OrderedDictTest(fixtures.TestBase):
         o['snack'] = 'attack'
         o['c'] = 3
 
-        eq_(o.keys(), ['a', 'b', 'snack', 'c'])
-        eq_(o.values(), [1, 2, 'attack', 3])
+        eq_(list(o.keys()), ['a', 'b', 'snack', 'c'])
+        eq_(list(o.values()), [1, 2, 'attack', 3])
 
         o.pop('snack')
-        eq_(o.keys(), ['a', 'b', 'c'])
-        eq_(o.values(), [1, 2, 3])
+        eq_(list(o.keys()), ['a', 'b', 'c'])
+        eq_(list(o.values()), [1, 2, 3])
 
         try:
             o.pop('eep')
@@ -146,40 +146,40 @@ class OrderedDictTest(fixtures.TestBase):
         except TypeError:
             pass
 
-        eq_(o.keys(), ['a', 'b', 'c'])
-        eq_(o.values(), [1, 2, 3])
+        eq_(list(o.keys()), ['a', 'b', 'c'])
+        eq_(list(o.values()), [1, 2, 3])
 
         o2 = util.OrderedDict(d=4)
         o2['e'] = 5
 
-        eq_(o2.keys(), ['d', 'e'])
-        eq_(o2.values(), [4, 5])
+        eq_(list(o2.keys()), ['d', 'e'])
+        eq_(list(o2.values()), [4, 5])
 
         o.update(o2)
-        eq_(o.keys(), ['a', 'b', 'c', 'd', 'e'])
-        eq_(o.values(), [1, 2, 3, 4, 5])
+        eq_(list(o.keys()), ['a', 'b', 'c', 'd', 'e'])
+        eq_(list(o.values()), [1, 2, 3, 4, 5])
 
         o.setdefault('c', 'zzz')
         o.setdefault('f', 6)
-        eq_(o.keys(), ['a', 'b', 'c', 'd', 'e', 'f'])
-        eq_(o.values(), [1, 2, 3, 4, 5, 6])
+        eq_(list(o.keys()), ['a', 'b', 'c', 'd', 'e', 'f'])
+        eq_(list(o.values()), [1, 2, 3, 4, 5, 6])
 
     def test_odict_constructor(self):
         o = util.OrderedDict([('name', 'jbe'), ('fullname', 'jonathan'
                              ), ('password', '')])
-        eq_(o.keys(), ['name', 'fullname', 'password'])
+        eq_(list(o.keys()), ['name', 'fullname', 'password'])
 
     def test_odict_copy(self):
         o = util.OrderedDict()
         o["zzz"] = 1
         o["aaa"] = 2
-        eq_(o.keys(), ['zzz', 'aaa'])
+        eq_(list(o.keys()), ['zzz', 'aaa'])
 
         o2 = o.copy()
-        eq_(o2.keys(), o.keys())
+        eq_(list(o2.keys()), list(o.keys()))
 
         o3 = copy.copy(o)
-        eq_(o3.keys(), o.keys())
+        eq_(list(o3.keys()), list(o.keys()))
 
 
 class OrderedSetTest(fixtures.TestBase):
@@ -198,7 +198,7 @@ class FrozenDictTest(fixtures.TestBase):
     def test_serialize(self):
         d = util.immutabledict({1: 2, 3: 4})
         for loads, dumps in picklers():
-            print loads(dumps(d))
+            print(loads(dumps(d)))
 
 
 class MemoizedAttrTest(fixtures.TestBase):
@@ -252,7 +252,7 @@ class ColumnCollectionTest(fixtures.TestBase):
         try:
             cc['col1'] in cc
             assert False
-        except exc.ArgumentError, e:
+        except exc.ArgumentError as e:
             eq_(str(e), "__contains__ requires a string argument")
 
     def test_compare(self):
@@ -414,14 +414,14 @@ class IdentitySetTest(fixtures.TestBase):
         for type_ in (object, ImmutableSubclass):
             data = [type_(), type_()]
             ids = util.IdentitySet()
-            for i in range(2) + range(2):
+            for i in list(range(2)) + list(range(2)):
                 ids.add(data[i])
             self.assert_eq(ids, data)
 
         for type_ in (EqOverride, HashOverride, HashEqOverride):
             data = [type_(1), type_(1), type_(2)]
             ids = util.IdentitySet()
-            for i in range(3) + range(3):
+            for i in list(range(3)) + list(range(3)):
                 ids.add(data[i])
             self.assert_eq(ids, data)
 
@@ -843,13 +843,14 @@ class IdentitySetTest(fixtures.TestBase):
         return super_, sub_, twin1, twin2, unique1, unique2
 
     def _assert_unorderable_types(self, callable_):
-        # Py3K
-        #assert_raises_message(
-        #    TypeError, 'unorderable types', callable_)
-        # Py2K
+# start Py3K
         assert_raises_message(
-            TypeError, 'cannot compare sets using cmp()', callable_)
-        # end Py2K
+            TypeError, 'unorderable types', callable_)
+# end Py3K
+# start Py2K
+#        assert_raises_message(
+#            TypeError, 'cannot compare sets using cmp()', callable_)
+# end Py2K
 
     def test_basic_sanity(self):
         IdentitySet = util.IdentitySet
@@ -969,23 +970,23 @@ class DictlikeIteritemsTest(fixtures.TestBase):
         d = subdict(a=1, b=2, c=3)
         self._ok(d)
 
-    # Py2K
-    def test_UserDict(self):
-        import UserDict
-        d = UserDict.UserDict(a=1, b=2, c=3)
-        self._ok(d)
-    # end Py2K
+# start Py2K
+#    def test_UserDict(self):
+#        import UserDict
+#        d = UserDict.UserDict(a=1, b=2, c=3)
+#        self._ok(d)
+# end Py2K
 
     def test_object(self):
         self._notok(object())
 
-    # Py2K
-    def test_duck_1(self):
-        class duck1(object):
-            def iteritems(duck):
-                return iter(self.baseline)
-        self._ok(duck1())
-    # end Py2K
+# start Py2K
+#    def test_duck_1(self):
+#        class duck1(object):
+#            def iteritems(duck):
+#                return iter(self.baseline)
+#        self._ok(duck1())
+# end Py2K
 
     def test_duck_2(self):
         class duck2(object):
@@ -993,16 +994,16 @@ class DictlikeIteritemsTest(fixtures.TestBase):
                 return list(self.baseline)
         self._ok(duck2())
 
-    # Py2K
-    def test_duck_3(self):
-        class duck3(object):
-            def iterkeys(duck):
-                return iter(['a', 'b', 'c'])
-
-            def __getitem__(duck, key):
-                return dict(a=1, b=2, c=3).get(key)
-        self._ok(duck3())
-    # end Py2K
+# start Py2K
+#    def test_duck_3(self):
+#        class duck3(object):
+#            def iterkeys(duck):
+#                return iter(['a', 'b', 'c'])
+#
+#            def __getitem__(duck, key):
+#                return dict(a=1, b=2, c=3).get(key)
+#        self._ok(duck3())
+# end Py2K
 
     def test_duck_4(self):
         class duck4(object):
@@ -1029,9 +1030,9 @@ class DictlikeIteritemsTest(fixtures.TestBase):
 class DuckTypeCollectionTest(fixtures.TestBase):
 
     def test_sets(self):
-        # Py2K
-        import sets
-        # end Py2K
+# start Py2K
+#        import sets
+# end Py2K
 
         class SetLike(object):
             def add(self):
@@ -1041,9 +1042,9 @@ class DuckTypeCollectionTest(fixtures.TestBase):
             __emulates__ = set
 
         for type_ in (set,
-                      # Py2K
-                      sets.Set,
-                      # end Py2K
+# start Py2K
+#                      sets.Set,
+# end Py2K
                       SetLike,
                       ForcedSet):
             eq_(util.duck_type_collection(type_), set)
@@ -1051,9 +1052,9 @@ class DuckTypeCollectionTest(fixtures.TestBase):
             eq_(util.duck_type_collection(instance), set)
 
         for type_ in (frozenset,
-                      # Py2K
-                      sets.ImmutableSet
-                      # end Py2K
+# start Py2K
+#                      sets.ImmutableSet
+# end Py2K
                       ):
             is_(util.duck_type_collection(type_), None)
             instance = type_()
@@ -1175,7 +1176,7 @@ class SymbolTest(fixtures.TestBase):
         sym3 = util.pickle.loads(s)
 
         for protocol in 0, 1, 2:
-            print protocol
+            print(protocol)
             serial = util.pickle.dumps(sym1)
             rt = util.pickle.loads(serial)
             assert rt is sym1
@@ -1550,21 +1551,21 @@ class TestClassHierarchy(fixtures.TestBase):
         eq_(set(util.class_hierarchy(A)), set((A, B, C, object)))
         eq_(set(util.class_hierarchy(B)), set((A, B, C, object)))
 
-    # Py2K
-    def test_oldstyle_mixin(self):
-        class A(object):
-            pass
-
-        class Mixin:
-            pass
-
-        class B(A, Mixin):
-            pass
-
-        eq_(set(util.class_hierarchy(B)), set((A, B, object)))
-        eq_(set(util.class_hierarchy(Mixin)), set())
-        eq_(set(util.class_hierarchy(A)), set((A, B, object)))
-    # end Py2K
+# start Py2K
+#    def test_oldstyle_mixin(self):
+#        class A(object):
+#            pass
+#
+#        class Mixin:
+#            pass
+#
+#        class B(A, Mixin):
+#            pass
+#
+#        eq_(set(util.class_hierarchy(B)), set((A, B, object)))
+#        eq_(set(util.class_hierarchy(Mixin)), set())
+#        eq_(set(util.class_hierarchy(A)), set((A, B, object)))
+# end Py2K
 
 
 class TestClassProperty(fixtures.TestBase):