diff --git a/Lib/lib2to3/fixes/basefix.py b/Lib/lib2to3/fixes/basefix.py index 66c448eeb9c..38666c15bda 100644 --- a/Lib/lib2to3/fixes/basefix.py +++ b/Lib/lib2to3/fixes/basefix.py @@ -108,7 +108,7 @@ def new_name(self, template="xxx_todo_changeme"): """ name = template while name in self.used_names: - name = template + str(self.numbers.next()) + name = template + str(next(self.numbers)) self.used_names.add(name) return name diff --git a/Lib/lib2to3/fixes/fix_imports.py b/Lib/lib2to3/fixes/fix_imports.py index fbdf7e4ec9e..9aba984628d 100644 --- a/Lib/lib2to3/fixes/fix_imports.py +++ b/Lib/lib2to3/fixes/fix_imports.py @@ -10,8 +10,8 @@ # Local imports from . import basefix from .util import Name, attr_chain, any, set -import __builtin__ -builtin_names = [name for name in dir(__builtin__) +import builtins +builtin_names = [name for name in dir(builtins) if name not in ("__name__", "__doc__")] MAPPING = {"StringIO": ("io", ["StringIO"]), @@ -26,7 +26,7 @@ def alternates(members): def build_pattern(): bare = set() - for old_module, (new_module, members) in MAPPING.items(): + for old_module, (new_module, members) in list(MAPPING.items()): bare.add(old_module) bare.update(members) members = alternates(members) diff --git a/Lib/lib2to3/fixes/fix_renames.py b/Lib/lib2to3/fixes/fix_renames.py index 58ad6cef53d..0b2bbf5770f 100644 --- a/Lib/lib2to3/fixes/fix_renames.py +++ b/Lib/lib2to3/fixes/fix_renames.py @@ -20,8 +20,8 @@ def alternates(members): def build_pattern(): #bare = set() - for module, replace in MAPPING.items(): - for old_attr, new_attr in replace.items(): + for module, replace in list(MAPPING.items()): + for old_attr, new_attr in list(replace.items()): LOOKUP[(module, old_attr)] = new_attr #bare.add(module) #bare.add(old_attr) diff --git a/Lib/lib2to3/fixes/util.py b/Lib/lib2to3/fixes/util.py index ef809afe00d..806bf287e31 100644 --- a/Lib/lib2to3/fixes/util.py +++ b/Lib/lib2to3/fixes/util.py @@ -323,7 +323,7 @@ def _is_import_binding(node, name, package=None): elif node.type == syms.import_from: # unicode(...) is used to make life easier here, because # from a.b import parses to ['import', ['a', '.', 'b'], ...] - if package and unicode(node.children[1]).strip() != package: + if package and str(node.children[1]).strip() != package: return None n = node.children[3] if package and _find('as', n): diff --git a/Lib/lib2to3/patcomp.py b/Lib/lib2to3/patcomp.py index 353b960dbfe..f9031258960 100644 --- a/Lib/lib2to3/patcomp.py +++ b/Lib/lib2to3/patcomp.py @@ -31,7 +31,7 @@ def tokenize_wrapper(input): """Tokenizes a string suppressing significant whitespace.""" skip = (token.NEWLINE, token.INDENT, token.DEDENT) - tokens = tokenize.generate_tokens(driver.generate_lines(input).next) + tokens = tokenize.generate_tokens(driver.generate_lines(input).__next__) for quintuple in tokens: type, value, start, end, line_text = quintuple if type not in skip: diff --git a/Lib/lib2to3/pgen2/conv.py b/Lib/lib2to3/pgen2/conv.py index 5d788a1d2b0..1d648d6a2e5 100644 --- a/Lib/lib2to3/pgen2/conv.py +++ b/Lib/lib2to3/pgen2/conv.py @@ -60,8 +60,8 @@ def parse_graminit_h(self, filename): """ try: f = open(filename) - except IOError, err: - print "Can't open %s: %s" % (filename, err) + except IOError as err: + print("Can't open %s: %s" % (filename, err)) return False self.symbol2number = {} self.number2symbol = {} @@ -70,8 +70,8 @@ def parse_graminit_h(self, filename): lineno += 1 mo = re.match(r"^#define\s+(\w+)\s+(\d+)$", line) if not mo and line.strip(): - print "%s(%s): can't parse %s" % (filename, lineno, - line.strip()) + print("%s(%s): can't parse %s" % (filename, lineno, + line.strip())) else: symbol, number = mo.groups() number = int(number) @@ -111,20 +111,20 @@ def parse_graminit_c(self, filename): """ try: f = open(filename) - except IOError, err: - print "Can't open %s: %s" % (filename, err) + except IOError as err: + print("Can't open %s: %s" % (filename, err)) return False # The code below essentially uses f's iterator-ness! lineno = 0 # Expect the two #include lines - lineno, line = lineno+1, f.next() + lineno, line = lineno+1, next(f) assert line == '#include "pgenheaders.h"\n', (lineno, line) - lineno, line = lineno+1, f.next() + lineno, line = lineno+1, next(f) assert line == '#include "grammar.h"\n', (lineno, line) # Parse the state definitions - lineno, line = lineno+1, f.next() + lineno, line = lineno+1, next(f) allarcs = {} states = [] while line.startswith("static arc "): @@ -132,35 +132,35 @@ def parse_graminit_c(self, filename): mo = re.match(r"static arc arcs_(\d+)_(\d+)\[(\d+)\] = {$", line) assert mo, (lineno, line) - n, m, k = map(int, mo.groups()) + n, m, k = list(map(int, mo.groups())) arcs = [] for _ in range(k): - lineno, line = lineno+1, f.next() + lineno, line = lineno+1, next(f) mo = re.match(r"\s+{(\d+), (\d+)},$", line) assert mo, (lineno, line) - i, j = map(int, mo.groups()) + i, j = list(map(int, mo.groups())) arcs.append((i, j)) - lineno, line = lineno+1, f.next() + lineno, line = lineno+1, next(f) assert line == "};\n", (lineno, line) allarcs[(n, m)] = arcs - lineno, line = lineno+1, f.next() + lineno, line = lineno+1, next(f) mo = re.match(r"static state states_(\d+)\[(\d+)\] = {$", line) assert mo, (lineno, line) - s, t = map(int, mo.groups()) + s, t = list(map(int, mo.groups())) assert s == len(states), (lineno, line) state = [] for _ in range(t): - lineno, line = lineno+1, f.next() + lineno, line = lineno+1, next(f) mo = re.match(r"\s+{(\d+), arcs_(\d+)_(\d+)},$", line) assert mo, (lineno, line) - k, n, m = map(int, mo.groups()) + k, n, m = list(map(int, mo.groups())) arcs = allarcs[n, m] assert k == len(arcs), (lineno, line) state.append(arcs) states.append(state) - lineno, line = lineno+1, f.next() + lineno, line = lineno+1, next(f) assert line == "};\n", (lineno, line) - lineno, line = lineno+1, f.next() + lineno, line = lineno+1, next(f) self.states = states # Parse the dfas @@ -169,18 +169,18 @@ def parse_graminit_c(self, filename): assert mo, (lineno, line) ndfas = int(mo.group(1)) for i in range(ndfas): - lineno, line = lineno+1, f.next() + lineno, line = lineno+1, next(f) mo = re.match(r'\s+{(\d+), "(\w+)", (\d+), (\d+), states_(\d+),$', line) assert mo, (lineno, line) symbol = mo.group(2) - number, x, y, z = map(int, mo.group(1, 3, 4, 5)) + number, x, y, z = list(map(int, mo.group(1, 3, 4, 5))) assert self.symbol2number[symbol] == number, (lineno, line) assert self.number2symbol[number] == symbol, (lineno, line) assert x == 0, (lineno, line) state = states[z] assert y == len(state), (lineno, line) - lineno, line = lineno+1, f.next() + lineno, line = lineno+1, next(f) mo = re.match(r'\s+("(?:\\\d\d\d)*")},$', line) assert mo, (lineno, line) first = {} @@ -191,18 +191,18 @@ def parse_graminit_c(self, filename): if byte & (1< %d" % j + print(" -> %d" % j) else: - print " %s -> %d" % (label, j) + print(" %s -> %d" % (label, j)) def dump_dfa(self, name, dfa): - print "Dump of DFA for", name + print("Dump of DFA for", name) for i, state in enumerate(dfa): - print " State", i, state.isfinal and "(final)" or "" - for label, next in state.arcs.iteritems(): - print " %s -> %d" % (label, dfa.index(next)) + print(" State", i, state.isfinal and "(final)" or "") + for label, next in state.arcs.items(): + print(" %s -> %d" % (label, dfa.index(next))) def simplify_dfa(self, dfa): # This is not theoretically optimal, but works well enough. @@ -319,9 +319,9 @@ def expect(self, type, value=None): return value def gettoken(self): - tup = self.generator.next() + tup = next(self.generator) while tup[0] in (tokenize.COMMENT, tokenize.NL): - tup = self.generator.next() + tup = next(self.generator) self.type, self.value, self.begin, self.end, self.line = tup #print token.tok_name[self.type], repr(self.value) @@ -330,7 +330,7 @@ def raise_error(self, msg, *args): try: msg = msg % args except: - msg = " ".join([msg] + map(str, args)) + msg = " ".join([msg] + list(map(str, args))) raise SyntaxError(msg, (self.filename, self.end[0], self.end[1], self.line)) @@ -348,7 +348,7 @@ class DFAState(object): def __init__(self, nfaset, final): assert isinstance(nfaset, dict) - assert isinstance(iter(nfaset).next(), NFAState) + assert isinstance(next(iter(nfaset)), NFAState) assert isinstance(final, NFAState) self.nfaset = nfaset self.isfinal = final in nfaset @@ -361,7 +361,7 @@ def addarc(self, next, label): self.arcs[label] = next def unifystate(self, old, new): - for label, next in self.arcs.iteritems(): + for label, next in self.arcs.items(): if next is old: self.arcs[label] = new @@ -374,7 +374,7 @@ def __eq__(self, other): # would invoke this method recursively, with cycles... if len(self.arcs) != len(other.arcs): return False - for label, next in self.arcs.iteritems(): + for label, next in self.arcs.items(): if next is not other.arcs.get(label): return False return True diff --git a/Lib/lib2to3/pgen2/token.py b/Lib/lib2to3/pgen2/token.py index 61468b313e7..1c810651eb3 100755 --- a/Lib/lib2to3/pgen2/token.py +++ b/Lib/lib2to3/pgen2/token.py @@ -67,7 +67,7 @@ #--end constants-- tok_name = {} -for _name, _value in globals().items(): +for _name, _value in list(globals().items()): if type(_value) is type(0): tok_name[_value] = _name diff --git a/Lib/lib2to3/pgen2/tokenize.py b/Lib/lib2to3/pgen2/tokenize.py index c31d5492104..33cfc33b705 100644 --- a/Lib/lib2to3/pgen2/tokenize.py +++ b/Lib/lib2to3/pgen2/tokenize.py @@ -94,8 +94,8 @@ def maybe(*choices): return group(*choices) + '?' PseudoExtras = group(r'\\\r?\n', Comment, Triple) PseudoToken = Whitespace + group(PseudoExtras, Number, Funny, ContStr, Name) -tokenprog, pseudoprog, single3prog, double3prog = map( - re.compile, (Token, PseudoToken, Single3, Double3)) +tokenprog, pseudoprog, single3prog, double3prog = list(map( + re.compile, (Token, PseudoToken, Single3, Double3))) endprogs = {"'": re.compile(Single), '"': re.compile(Double), "'''": single3prog, '"""': double3prog, "r'''": single3prog, 'r"""': double3prog, @@ -143,9 +143,11 @@ class TokenError(Exception): pass class StopTokenizing(Exception): pass -def printtoken(type, token, (srow, scol), (erow, ecol), line): # for testing - print "%d,%d-%d,%d:\t%s\t%s" % \ - (srow, scol, erow, ecol, tok_name[type], repr(token)) +def printtoken(type, token, xxx_todo_changeme, xxx_todo_changeme1, line): # for testing + (srow, scol) = xxx_todo_changeme + (erow, ecol) = xxx_todo_changeme1 + print("%d,%d-%d,%d:\t%s\t%s" % \ + (srow, scol, erow, ecol, tok_name[type], repr(token))) def tokenize(readline, tokeneater=printtoken): """ @@ -279,7 +281,7 @@ def generate_tokens(readline): if contstr: # continued string if not line: - raise TokenError, ("EOF in multi-line string", strstart) + raise TokenError("EOF in multi-line string", strstart) endmatch = endprog.match(line) if endmatch: pos = end = endmatch.end(0) @@ -335,7 +337,7 @@ def generate_tokens(readline): else: # continued statement if not line: - raise TokenError, ("EOF in multi-line statement", (lnum, 0)) + raise TokenError("EOF in multi-line statement", (lnum, 0)) continued = 0 while pos < max: diff --git a/Lib/lib2to3/pygram.py b/Lib/lib2to3/pygram.py index 24f1bcf33fd..f948ee61579 100644 --- a/Lib/lib2to3/pygram.py +++ b/Lib/lib2to3/pygram.py @@ -23,7 +23,7 @@ def __init__(self, grammar): Creates an attribute for each grammar symbol (nonterminal), whose value is the symbol's type (an int >= 256). """ - for name, symbol in grammar.symbol2number.iteritems(): + for name, symbol in grammar.symbol2number.items(): setattr(self, name, symbol) diff --git a/Lib/lib2to3/pytree.py b/Lib/lib2to3/pytree.py index 7584f71bde5..665714449e0 100644 --- a/Lib/lib2to3/pytree.py +++ b/Lib/lib2to3/pytree.py @@ -443,7 +443,7 @@ def __init__(self, type=None, content=None, name=None): if type is not None: assert 0 <= type < 256, type if content is not None: - assert isinstance(content, basestring), repr(content) + assert isinstance(content, str), repr(content) self.type = type self.content = content self.name = name @@ -491,7 +491,7 @@ def __init__(self, type=None, content=None, name=None): if type is not None: assert type >= 256, type if content is not None: - assert not isinstance(content, basestring), repr(content) + assert not isinstance(content, str), repr(content) content = list(content) for i, item in enumerate(content): assert isinstance(item, BasePattern), (i, item) @@ -622,7 +622,7 @@ def generate_matches(self, nodes): """ if self.content is None: # Shortcut for special case (see __init__.__doc__) - for count in xrange(self.min, 1 + min(len(nodes), self.max)): + for count in range(self.min, 1 + min(len(nodes), self.max)): r = {} if self.name: r[self.name] = nodes[:count] diff --git a/Lib/lib2to3/refactor.py b/Lib/lib2to3/refactor.py index 0961e906bcd..9172e8f4bcf 100755 --- a/Lib/lib2to3/refactor.py +++ b/Lib/lib2to3/refactor.py @@ -63,14 +63,14 @@ def main(args=None): # Parse command line arguments options, args = parser.parse_args(args) if options.list_fixes: - print "Available transformations for the -f/--fix option:" + print("Available transformations for the -f/--fix option:") for fixname in get_all_fix_names(): - print fixname + print(fixname) if not args: return 0 if not args: - print >>sys.stderr, "At least one file or directory argument required." - print >>sys.stderr, "Use --help to show usage." + print("At least one file or directory argument required.", file=sys.stderr) + print("Use --help to show usage.", file=sys.stderr) return 2 # Initialize the refactoring tool @@ -145,7 +145,7 @@ def get_fixers(self): continue try: fixer = fix_class(self.options, self.fixer_log) - except Exception, err: + except Exception as err: self.log_error("Can't instantiate fixes.fix_%s.%s()", fix_name, class_name, exc_info=True) continue @@ -207,7 +207,7 @@ def refactor_file(self, filename): """Refactors a file.""" try: f = open(filename) - except IOError, err: + except IOError as err: self.log_error("Can't open %s: %s", filename, err) return try: @@ -243,7 +243,7 @@ def refactor_string(self, data, name): """ try: tree = self.driver.parse_string(data,1) - except Exception, err: + except Exception as err: self.log_error("Can't parse %s: %s: %s", name, err.__class__.__name__, err) return @@ -331,7 +331,7 @@ def write_file(self, new_text, filename, old_text=None): if old_text is None: try: f = open(filename, "r") - except IOError, err: + except IOError as err: self.log_error("Can't read %s: %s", filename, err) return try: @@ -351,21 +351,21 @@ def write_file(self, new_text, filename, old_text=None): if os.path.lexists(backup): try: os.remove(backup) - except os.error, err: + except os.error as err: self.log_message("Can't remove backup %s", backup) try: os.rename(filename, backup) - except os.error, err: + except os.error as err: self.log_message("Can't rename %s to %s", filename, backup) try: f = open(filename, "w") - except os.error, err: + except os.error as err: self.log_error("Can't create %s: %s", filename, err) return try: try: f.write(new_text) - except os.error, err: + except os.error as err: self.log_error("Can't write %s: %s", filename, err) finally: f.close() @@ -428,7 +428,7 @@ def refactor_doctest(self, block, lineno, indent, filename): """ try: tree = self.parse_block(block, lineno, indent) - except Exception, err: + except Exception as err: if self.options.verbose: for line in block: self.log_message("Source: %s", line.rstrip("\n")) @@ -480,7 +480,7 @@ def parse_block(self, block, lineno, indent): def wrap_toks(self, block, lineno, indent): """Wraps a tokenize stream to systematically modify start/end.""" - tokens = tokenize.generate_tokens(self.gen_lines(block, indent).next) + tokens = tokenize.generate_tokens(self.gen_lines(block, indent).__next__) for type, value, (line0, col0), (line1, col1), line_text in tokens: line0 += lineno - 1 line1 += lineno - 1 @@ -519,7 +519,7 @@ def diff_texts(a, b, filename): for line in difflib.unified_diff(a, b, filename, filename, "(original)", "(refactored)", lineterm=""): - print line + print(line) if __name__ == "__main__": diff --git a/Lib/lib2to3/tests/benchmark.py b/Lib/lib2to3/tests/benchmark.py index 3723f69645f..1c4b8fcfca5 100644 --- a/Lib/lib2to3/tests/benchmark.py +++ b/Lib/lib2to3/tests/benchmark.py @@ -23,7 +23,7 @@ ############################################################################### 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 @@ def dummy_transform(*args, **kwargs): 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 e5d8a0ff219..b2ff643ef9f 100644 --- a/Lib/lib2to3/tests/data/py2_test_grammar.py +++ b/Lib/lib2to3/tests/data/py2_test_grammar.py @@ -30,13 +30,13 @@ def testBackslash(self): 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 @@ def testPlainIntegers(self): 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 @@ def testPlainIntegers(self): 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 @@ def f1(): pass 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 @@ def v3(a, (b, c), *rest): return a, b, c, rest # 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 @@ def d22v(a, b, c=1, d=2, *rest): pass 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 @@ def testLambdef(self): 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 @@ def testExprStmt(self): 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 @@ def driver(): # 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 @@ def test_inner(extra_burning_oil = 1, count=0): 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 @@ def testYield(self): 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 @@ def testExec(self): # '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="") - 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 @@ def testAssert(self): 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 @@ def testComparison(self): 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 @@ def testComparison(self): 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 @@ def testAtoms(self): 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 @@ def test_nested_front(): 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 @@ def testGenexps(self): 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 @@ def testIfElseExpr(self): # 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 bfc77feccfc..2fb321717c5 100644 --- a/Lib/lib2to3/tests/data/py3_test_grammar.py +++ b/Lib/lib2to3/tests/data/py3_test_grammar.py @@ -32,7 +32,7 @@ def testPlainIntegers(self): 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 @@ def testYield(self): 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 d83f5cc77d4..ca5441a0704 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 e8df320c431..19c1af6b3bf 100644 --- a/Lib/lib2to3/tests/test_all_fixers.py +++ b/Lib/lib2to3/tests/test_all_fixers.py @@ -21,7 +21,7 @@ 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 @@ def setUp(self): 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 0fb098473ed..eacb78737c1 100755 --- a/Lib/lib2to3/tests/test_fixers.py +++ b/Lib/lib2to3/tests/test_fixers.py @@ -18,7 +18,7 @@ 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 @@ def test_import_module(self): 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 @@ def test_import_from(self): 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 @@ def test_import_module_as(self): 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 @@ def test_star(self): 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 @@ def test_import_module_usage(self): 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 @@ def test_import_from(self): 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 @@ def test_import_module_usage(self): 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 56b8cfefc0e..83aa812c7de 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)