Run 2to3 on this library.

7 files changed, 98 insertions, 98 deletions

diff --git a/Lib/lib2to3/tests/benchmark.py b/Lib/lib2to3/tests/benchmark.py
index 3723f69..1c4b8fc 100644
--- a/Lib/lib2to3/tests/benchmark.py
+++ b/Lib/lib2to3/tests/benchmark.py
@@ -23,7 +23,7 @@ from .. import refactor
 ###############################################################################
 class Options:
     def __init__(self, **kwargs):
-        for k, v in kwargs.items():
+        for k, v in list(kwargs.items()):
             setattr(self, k, v)
 
         self.verbose = False
@@ -34,7 +34,7 @@ def dummy_transform(*args, **kwargs):
 ### Collect list of modules to match against
 ###############################################################################
 files = []
-for mod in sys.modules.values():
+for mod in list(sys.modules.values()):
     if mod is None or not hasattr(mod, '__file__'):
         continue
     f = mod.__file__
@@ -53,6 +53,6 @@ for fixer in refactor.fixers:
 
 t = time()
 for f in files:
-    print "Matching", f
+    print("Matching", f)
     refactor.refactor_file(f)
-print "%d seconds to match %d files" % (time() - t, len(sys.modules))
+print("%d seconds to match %d files" % (time() - t, len(sys.modules)))
diff --git a/Lib/lib2to3/tests/data/py2_test_grammar.py b/Lib/lib2to3/tests/data/py2_test_grammar.py
index e5d8a0f..b2ff643 100644
--- a/Lib/lib2to3/tests/data/py2_test_grammar.py
+++ b/Lib/lib2to3/tests/data/py2_test_grammar.py
@@ -30,13 +30,13 @@ class TokenTests(unittest.TestCase):
 
     def testPlainIntegers(self):
         self.assertEquals(0xff, 255)
-        self.assertEquals(0377, 255)
-        self.assertEquals(2147483647, 017777777777)
-        from sys import maxint
+        self.assertEquals(0o377, 255)
+        self.assertEquals(2147483647, 0o17777777777)
+        from sys import maxsize
         if maxint == 2147483647:
-            self.assertEquals(-2147483647-1, -020000000000)
+            self.assertEquals(-2147483647-1, -0o20000000000)
             # XXX -2147483648
-            self.assert_(037777777777 > 0)
+            self.assert_(0o37777777777 > 0)
             self.assert_(0xffffffff > 0)
             for s in '2147483648', '040000000000', '0x100000000':
                 try:
@@ -44,8 +44,8 @@ class TokenTests(unittest.TestCase):
                 except OverflowError:
                     self.fail("OverflowError on huge integer literal %r" % s)
         elif maxint == 9223372036854775807:
-            self.assertEquals(-9223372036854775807-1, -01000000000000000000000)
-            self.assert_(01777777777777777777777 > 0)
+            self.assertEquals(-9223372036854775807-1, -0o1000000000000000000000)
+            self.assert_(0o1777777777777777777777 > 0)
             self.assert_(0xffffffffffffffff > 0)
             for s in '9223372036854775808', '02000000000000000000000', \
                      '0x10000000000000000':
@@ -57,14 +57,14 @@ class TokenTests(unittest.TestCase):
             self.fail('Weird maxint value %r' % maxint)
 
     def testLongIntegers(self):
-        x = 0L
-        x = 0l
-        x = 0xffffffffffffffffL
-        x = 0xffffffffffffffffl
-        x = 077777777777777777L
-        x = 077777777777777777l
-        x = 123456789012345678901234567890L
-        x = 123456789012345678901234567890l
+        x = 0
+        x = 0
+        x = 0xffffffffffffffff
+        x = 0xffffffffffffffff
+        x = 0o77777777777777777
+        x = 0o77777777777777777
+        x = 123456789012345678901234567890
+        x = 123456789012345678901234567890
 
     def testFloats(self):
         x = 3.14
@@ -152,27 +152,27 @@ class GrammarTests(unittest.TestCase):
         f1(*(), **{})
         def f2(one_argument): pass
         def f3(two, arguments): pass
-        def f4(two, (compound, (argument, list))): pass
-        def f5((compound, first), two): pass
-        self.assertEquals(f2.func_code.co_varnames, ('one_argument',))
-        self.assertEquals(f3.func_code.co_varnames, ('two', 'arguments'))
+        def f4(two, xxx_todo_changeme): (compound, (argument, list)) = xxx_todo_changeme; pass
+        def f5(xxx_todo_changeme1, two): (compound, first) = xxx_todo_changeme1; pass
+        self.assertEquals(f2.__code__.co_varnames, ('one_argument',))
+        self.assertEquals(f3.__code__.co_varnames, ('two', 'arguments'))
         if sys.platform.startswith('java'):
-            self.assertEquals(f4.func_code.co_varnames,
+            self.assertEquals(f4.__code__.co_varnames,
                    ('two', '(compound, (argument, list))', 'compound', 'argument',
                                 'list',))
-            self.assertEquals(f5.func_code.co_varnames,
+            self.assertEquals(f5.__code__.co_varnames,
                    ('(compound, first)', 'two', 'compound', 'first'))
         else:
-            self.assertEquals(f4.func_code.co_varnames,
+            self.assertEquals(f4.__code__.co_varnames,
                   ('two', '.1', 'compound', 'argument',  'list'))
-            self.assertEquals(f5.func_code.co_varnames,
+            self.assertEquals(f5.__code__.co_varnames,
                   ('.0', 'two', 'compound', 'first'))
         def a1(one_arg,): pass
         def a2(two, args,): pass
         def v0(*rest): pass
         def v1(a, *rest): pass
         def v2(a, b, *rest): pass
-        def v3(a, (b, c), *rest): return a, b, c, rest
+        def v3(a, xxx_todo_changeme2, *rest): (b, c) = xxx_todo_changeme2; return a, b, c, rest
 
         f1()
         f2(1)
@@ -201,9 +201,9 @@ class GrammarTests(unittest.TestCase):
         # ceval unpacks the formal arguments into the first argcount names;
         # thus, the names nested inside tuples must appear after these names.
         if sys.platform.startswith('java'):
-            self.assertEquals(v3.func_code.co_varnames, ('a', '(b, c)', 'rest', 'b', 'c'))
+            self.assertEquals(v3.__code__.co_varnames, ('a', '(b, c)', 'rest', 'b', 'c'))
         else:
-            self.assertEquals(v3.func_code.co_varnames, ('a', '.1', 'rest', 'b', 'c'))
+            self.assertEquals(v3.__code__.co_varnames, ('a', '.1', 'rest', 'b', 'c'))
         self.assertEquals(v3(1, (2, 3), 4), (1, 2, 3, (4,)))
         def d01(a=1): pass
         d01()
@@ -277,9 +277,9 @@ class GrammarTests(unittest.TestCase):
         d22v(*(1, 2, 3, 4))
         d22v(1, 2, *(3, 4, 5))
         d22v(1, *(2, 3), **{'d': 4})
-        def d31v((x)): pass
+        def d31v(xxx_todo_changeme3): (x) = xxx_todo_changeme3; pass
         d31v(1)
-        def d32v((x,)): pass
+        def d32v(xxx_todo_changeme4): (x,) = xxx_todo_changeme4; pass
         d32v((1,))
 
     def testLambdef(self):
@@ -287,7 +287,7 @@ class GrammarTests(unittest.TestCase):
         l1 = lambda : 0
         self.assertEquals(l1(), 0)
         l2 = lambda : a[d] # XXX just testing the expression
-        l3 = lambda : [2 < x for x in [-1, 3, 0L]]
+        l3 = lambda : [2 < x for x in [-1, 3, 0]]
         self.assertEquals(l3(), [0, 1, 0])
         l4 = lambda x = lambda y = lambda z=1 : z : y() : x()
         self.assertEquals(l4(), 1)
@@ -325,36 +325,36 @@ class GrammarTests(unittest.TestCase):
 
     def testPrintStmt(self):
         # 'print' (test ',')* [test]
-        import StringIO
+        import io
 
         # Can't test printing to real stdout without comparing output
         # which is not available in unittest.
         save_stdout = sys.stdout
-        sys.stdout = StringIO.StringIO()
+        sys.stdout = io.StringIO()
 
-        print 1, 2, 3
-        print 1, 2, 3,
-        print
-        print 0 or 1, 0 or 1,
-        print 0 or 1
+        print(1, 2, 3)
+        print(1, 2, 3, end=' ')
+        print()
+        print(0 or 1, 0 or 1, end=' ')
+        print(0 or 1)
 
         # 'print' '>>' test ','
-        print >> sys.stdout, 1, 2, 3
-        print >> sys.stdout, 1, 2, 3,
-        print >> sys.stdout
-        print >> sys.stdout, 0 or 1, 0 or 1,
-        print >> sys.stdout, 0 or 1
+        print(1, 2, 3, file=sys.stdout)
+        print(1, 2, 3, end=' ', file=sys.stdout)
+        print(file=sys.stdout)
+        print(0 or 1, 0 or 1, end=' ', file=sys.stdout)
+        print(0 or 1, file=sys.stdout)
 
         # test printing to an instance
         class Gulp:
             def write(self, msg): pass
 
         gulp = Gulp()
-        print >> gulp, 1, 2, 3
-        print >> gulp, 1, 2, 3,
-        print >> gulp
-        print >> gulp, 0 or 1, 0 or 1,
-        print >> gulp, 0 or 1
+        print(1, 2, 3, file=gulp)
+        print(1, 2, 3, end=' ', file=gulp)
+        print(file=gulp)
+        print(0 or 1, 0 or 1, end=' ', file=gulp)
+        print(0 or 1, file=gulp)
 
         # test print >> None
         def driver():
@@ -368,13 +368,13 @@ class GrammarTests(unittest.TestCase):
 
         # we should see this once
         def tellme(file=sys.stdout):
-            print >> file, 'hello world'
+            print('hello world', file=file)
 
         driver()
 
         # we should not see this at all
         def tellme(file=None):
-            print >> file, 'goodbye universe'
+            print('goodbye universe', file=file)
 
         driver()
 
@@ -461,7 +461,7 @@ hello world
                     continue
                 except:
                     raise
-            if count > 2 or big_hippo <> 1:
+            if count > 2 or big_hippo != 1:
                 self.fail("continue then break in try/except in loop broken!")
         test_inner()
 
@@ -478,7 +478,7 @@ hello world
 
     def testRaise(self):
         # 'raise' test [',' test]
-        try: raise RuntimeError, 'just testing'
+        try: raise RuntimeError('just testing')
         except RuntimeError: pass
         try: raise KeyboardInterrupt
         except KeyboardInterrupt: pass
@@ -506,33 +506,33 @@ hello world
         # 'exec' expr ['in' expr [',' expr]]
         z = None
         del z
-        exec 'z=1+1\n'
+        exec('z=1+1\n')
         if z != 2: self.fail('exec \'z=1+1\'\\n')
         del z
-        exec 'z=1+1'
+        exec('z=1+1')
         if z != 2: self.fail('exec \'z=1+1\'')
         z = None
         del z
         import types
         if hasattr(types, "UnicodeType"):
-            exec r"""if 1:
+            exec(r"""if 1:
             exec u'z=1+1\n'
             if z != 2: self.fail('exec u\'z=1+1\'\\n')
             del z
             exec u'z=1+1'
-            if z != 2: self.fail('exec u\'z=1+1\'')"""
+            if z != 2: self.fail('exec u\'z=1+1\'')""")
         g = {}
-        exec 'z = 1' in g
-        if g.has_key('__builtins__'): del g['__builtins__']
+        exec('z = 1', g)
+        if '__builtins__' in g: del g['__builtins__']
         if g != {'z': 1}: self.fail('exec \'z = 1\' in g')
         g = {}
         l = {}
 
         import warnings
         warnings.filterwarnings("ignore", "global statement", module="<string>")
-        exec 'global a; a = 1; b = 2' in g, l
-        if g.has_key('__builtins__'): del g['__builtins__']
-        if l.has_key('__builtins__'): del l['__builtins__']
+        exec('global a; a = 1; b = 2', g, l)
+        if '__builtins__' in g: del g['__builtins__']
+        if '__builtins__' in l: del l['__builtins__']
         if (g, l) != ({'a':1}, {'b':2}):
             self.fail('exec ... in g (%s), l (%s)' %(g,l))
 
@@ -544,7 +544,7 @@ hello world
         assert 1, lambda x:x+1
         try:
             assert 0, "msg"
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertEquals(e.args[0], "msg")
         else:
             if __debug__:
@@ -655,7 +655,7 @@ hello world
         x = (1 == 1)
         if 1 == 1: pass
         if 1 != 1: pass
-        if 1 <> 1: pass
+        if 1 != 1: pass
         if 1 < 1: pass
         if 1 > 1: pass
         if 1 <= 1: pass
@@ -664,7 +664,7 @@ hello world
         if 1 is not 1: pass
         if 1 in (): pass
         if 1 not in (): pass
-        if 1 < 1 > 1 == 1 >= 1 <= 1 <> 1 != 1 in 1 not in 1 is 1 is not 1: pass
+        if 1 < 1 > 1 == 1 >= 1 <= 1 != 1 != 1 in 1 not in 1 is 1 is not 1: pass
 
     def testBinaryMaskOps(self):
         x = 1 & 1
@@ -747,9 +747,9 @@ hello world
         x = {'one': 1, 'two': 2,}
         x = {'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5, 'six': 6}
 
-        x = `x`
-        x = `1 or 2 or 3`
-        self.assertEqual(`1,2`, '(1, 2)')
+        x = repr(x)
+        x = repr(1 or 2 or 3)
+        self.assertEqual(repr((1,2)), '(1, 2)')
 
         x = x
         x = 'x'
@@ -837,9 +837,9 @@ hello world
     def testGenexps(self):
         # generator expression tests
         g = ([x for x in range(10)] for x in range(1))
-        self.assertEqual(g.next(), [x for x in range(10)])
+        self.assertEqual(next(g), [x for x in range(10)])
         try:
-            g.next()
+            next(g)
             self.fail('should produce StopIteration exception')
         except StopIteration:
             pass
@@ -847,7 +847,7 @@ hello world
         a = 1
         try:
             g = (a for d in a)
-            g.next()
+            next(g)
             self.fail('should produce TypeError')
         except TypeError:
             pass
@@ -892,7 +892,7 @@ hello world
         # Test ifelse expressions in various cases
         def _checkeval(msg, ret):
             "helper to check that evaluation of expressions is done correctly"
-            print x
+            print(x)
             return ret
 
         self.assertEqual([ x() for x in lambda: True, lambda: False if x() ], [True])
diff --git a/Lib/lib2to3/tests/data/py3_test_grammar.py b/Lib/lib2to3/tests/data/py3_test_grammar.py
index bfc77fe..2fb3217 100644
--- a/Lib/lib2to3/tests/data/py3_test_grammar.py
+++ b/Lib/lib2to3/tests/data/py3_test_grammar.py
@@ -32,7 +32,7 @@ class TokenTests(unittest.TestCase):
         self.assertEquals(0o377, 255)
         self.assertEquals(2147483647, 0o17777777777)
         self.assertEquals(0b1001, 9)
-        from sys import maxint
+        from sys import maxsize
         if maxint == 2147483647:
             self.assertEquals(-2147483647-1, -0o20000000000)
             # XXX -2147483648
@@ -438,7 +438,7 @@ class GrammarTests(unittest.TestCase):
 
     def testRaise(self):
         # 'raise' test [',' test]
-        try: raise RuntimeError, 'just testing'
+        try: raise RuntimeError('just testing')
         except RuntimeError: pass
         try: raise KeyboardInterrupt
         except KeyboardInterrupt: pass
diff --git a/Lib/lib2to3/tests/pytree_idempotency.py b/Lib/lib2to3/tests/pytree_idempotency.py
index d83f5cc..ca5441a 100755
--- a/Lib/lib2to3/tests/pytree_idempotency.py
+++ b/Lib/lib2to3/tests/pytree_idempotency.py
@@ -28,7 +28,7 @@ def main():
     fn = "example.py"
     tree = dr.parse_file(fn, debug=True)
     if not diff(fn, tree):
-        print "No diffs."
+        print("No diffs.")
     if not sys.argv[1:]:
         return # Pass a dummy argument to run the complete test suite below
 
@@ -44,7 +44,7 @@ def main():
             fn = fn[:-1]
         if not fn.endswith(".py"):
             continue
-        print >>sys.stderr, "Parsing", fn
+        print("Parsing", fn, file=sys.stderr)
         tree = dr.parse_file(fn, debug=True)
         if diff(fn, tree):
             problems.append(fn)
@@ -55,27 +55,27 @@ def main():
             names = os.listdir(dir)
         except os.error:
             continue
-        print >>sys.stderr, "Scanning", dir, "..."
+        print("Scanning", dir, "...", file=sys.stderr)
         for name in names:
             if not name.endswith(".py"):
                 continue
-            print >>sys.stderr, "Parsing", name
+            print("Parsing", name, file=sys.stderr)
             fn = os.path.join(dir, name)
             try:
                 tree = dr.parse_file(fn, debug=True)
-            except pgen2.parse.ParseError, err:
-                print "ParseError:", err
+            except pgen2.parse.ParseError as err:
+                print("ParseError:", err)
             else:
                 if diff(fn, tree):
                     problems.append(fn)
 
     # Show summary of problem files
     if not problems:
-        print "No problems.  Congratulations!"
+        print("No problems.  Congratulations!")
     else:
-        print "Problems in following files:"
+        print("Problems in following files:")
         for fn in problems:
-            print "***", fn
+            print("***", fn)
 
 def diff(fn, tree):
     f = open("@", "w")
diff --git a/Lib/lib2to3/tests/test_all_fixers.py b/Lib/lib2to3/tests/test_all_fixers.py
index e8df320..19c1af6 100644
--- a/Lib/lib2to3/tests/test_all_fixers.py
+++ b/Lib/lib2to3/tests/test_all_fixers.py
@@ -21,7 +21,7 @@ from .. import refactor
 
 class Options:
     def __init__(self, **kwargs):
-        for k, v in kwargs.items():
+        for k, v in list(kwargs.items()):
             setattr(self, k, v)
         self.verbose = False
 
@@ -33,7 +33,7 @@ class Test_all(support.TestCase):
 
     def test_all_project_files(self):
         for filepath in support.all_project_files():
-            print "Fixing %s..." % filepath
+            print("Fixing %s..." % filepath)
             self.refactor.refactor_string(open(filepath).read(), filepath)
 
 
diff --git a/Lib/lib2to3/tests/test_fixers.py b/Lib/lib2to3/tests/test_fixers.py
index 0fb0984..eacb787 100755
--- a/Lib/lib2to3/tests/test_fixers.py
+++ b/Lib/lib2to3/tests/test_fixers.py
@@ -18,7 +18,7 @@ from .. import refactor
 
 class Options:
     def __init__(self, **kwargs):
-        for k, v in kwargs.items():
+        for k, v in list(kwargs.items()):
             setattr(self, k, v)
 
         self.verbose = False
@@ -1285,7 +1285,7 @@ class Test_imports(FixerTestCase):
               }
 
     def test_import_module(self):
-        for old, (new, members) in self.modules.items():
+        for old, (new, members) in list(self.modules.items()):
             b = "import %s" % old
             a = "import %s" % new
             self.check(b, a)
@@ -1295,7 +1295,7 @@ class Test_imports(FixerTestCase):
             self.check(b, a)
 
     def test_import_from(self):
-        for old, (new, members) in self.modules.items():
+        for old, (new, members) in list(self.modules.items()):
             for member in members:
                 b = "from %s import %s" % (old, member)
                 a = "from %s import %s" % (new, member)
@@ -1305,7 +1305,7 @@ class Test_imports(FixerTestCase):
                 self.unchanged(s)
 
     def test_import_module_as(self):
-        for old, (new, members) in self.modules.items():
+        for old, (new, members) in list(self.modules.items()):
             b = "import %s as foo_bar" % old
             a = "import %s as foo_bar" % new
             self.check(b, a)
@@ -1315,7 +1315,7 @@ class Test_imports(FixerTestCase):
             self.check(b, a)
 
     def test_import_from_as(self):
-        for old, (new, members) in self.modules.items():
+        for old, (new, members) in list(self.modules.items()):
             for member in members:
                 b = "from %s import %s as foo_bar" % (old, member)
                 a = "from %s import %s as foo_bar" % (new, member)
@@ -1327,7 +1327,7 @@ class Test_imports(FixerTestCase):
             self.warns_unchanged(s, "Cannot handle star imports")
 
     def test_import_module_usage(self):
-        for old, (new, members) in self.modules.items():
+        for old, (new, members) in list(self.modules.items()):
             for member in members:
                 b = """
                     import %s
@@ -1340,7 +1340,7 @@ class Test_imports(FixerTestCase):
                 self.check(b, a)
 
     def test_from_import_usage(self):
-        for old, (new, members) in self.modules.items():
+        for old, (new, members) in list(self.modules.items()):
             for member in members:
                 b = """
                     from %s import %s
@@ -2211,7 +2211,7 @@ class Test_renames(FixerTestCase):
               }
 
     def test_import_from(self):
-        for mod, (old, new) in self.modules.items():
+        for mod, (old, new) in list(self.modules.items()):
             b = "from %s import %s" % (mod, old)
             a = "from %s import %s" % (mod, new)
             self.check(b, a)
@@ -2220,13 +2220,13 @@ class Test_renames(FixerTestCase):
             self.unchanged(s)
 
     def test_import_from_as(self):
-        for mod, (old, new) in self.modules.items():
+        for mod, (old, new) in list(self.modules.items()):
             b = "from %s import %s as foo_bar" % (mod, old)
             a = "from %s import %s as foo_bar" % (mod, new)
             self.check(b, a)
 
     def test_import_module_usage(self):
-        for mod, (old, new) in self.modules.items():
+        for mod, (old, new) in list(self.modules.items()):
             b = """
                 import %s
                 foo(%s, %s.%s)
@@ -2239,7 +2239,7 @@ class Test_renames(FixerTestCase):
 
     def XXX_test_from_import_usage(self):
         # not implemented yet
-        for mod, (old, new) in self.modules.items():
+        for mod, (old, new) in list(self.modules.items()):
             b = """
                 from %s import %s
                 foo(%s, %s)
diff --git a/Lib/lib2to3/tests/test_parser.py b/Lib/lib2to3/tests/test_parser.py
index 56b8cfe..83aa812 100644
--- a/Lib/lib2to3/tests/test_parser.py
+++ b/Lib/lib2to3/tests/test_parser.py
@@ -149,7 +149,7 @@ class TestParserIdempotency(support.TestCase):
 
     def test_all_project_files(self):
         for filepath in support.all_project_files():
-            print "Parsing %s..." % filepath
+            print("Parsing %s..." % filepath)
             tree = driver.parse_file(filepath, debug=True)
             if diff(filepath, tree):
                 self.fail("Idempotency failed: %s" % filepath)