mirrors/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-11-12 07:02:33 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 8

Run 2to3 on this library.

Browse source
This commit is contained in:
Martin v. Löwis 2008-03-19 05:33:36 +00:00
parent f733c60d9a
commit 8a5f8ca33b
22 changed files with 196 additions and 194 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Lib/lib2to3/fixes/basefix.py
View file

@ -108,7 +108,7 @@ class BaseFix(object):
""" """
name = template name = template
while name in self.used_names: while name in self.used_names:
name = template + str(self.numbers.next()) name = template + str(next(self.numbers))
self.used_names.add(name) self.used_names.add(name)
return name return name

6
Lib/lib2to3/fixes/fix_imports.py
View file

@ -10,8 +10,8 @@ Fixes:
# Local imports # Local imports
from . import basefix from . import basefix
from .util import Name, attr_chain, any, set from .util import Name, attr_chain, any, set
import __builtin__ import builtins
builtin_names = [name for name in dir(__builtin__) builtin_names = [name for name in dir(builtins)
if name not in ("__name__", "__doc__")] if name not in ("__name__", "__doc__")]
MAPPING = {"StringIO": ("io", ["StringIO"]), MAPPING = {"StringIO": ("io", ["StringIO"]),
@ -26,7 +26,7 @@ def alternates(members):
def build_pattern(): def build_pattern():
bare = set() 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.add(old_module)
bare.update(members) bare.update(members)
members = alternates(members) members = alternates(members)

4
Lib/lib2to3/fixes/fix_renames.py
View file

@ -20,8 +20,8 @@ def alternates(members):
def build_pattern(): def build_pattern():
#bare = set() #bare = set()
for module, replace in MAPPING.items(): for module, replace in list(MAPPING.items()):
for old_attr, new_attr in replace.items(): for old_attr, new_attr in list(replace.items()):
LOOKUP[(module, old_attr)] = new_attr LOOKUP[(module, old_attr)] = new_attr
#bare.add(module) #bare.add(module)
#bare.add(old_attr) #bare.add(old_attr)

2
Lib/lib2to3/fixes/util.py
View file

@ -323,7 +323,7 @@ def _is_import_binding(node, name, package=None):
elif node.type == syms.import_from: elif node.type == syms.import_from:
# unicode(...) is used to make life easier here, because # unicode(...) is used to make life easier here, because
# from a.b import parses to ['import', ['a', '.', 'b'], ...] # 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 return None
n = node.children[3] n = node.children[3]
if package and _find('as', n): if package and _find('as', n):

2
Lib/lib2to3/patcomp.py
View file

@ -31,7 +31,7 @@ _PATTERN_GRAMMAR_FILE = os.path.join(os.path.dirname(__file__),
def tokenize_wrapper(input): def tokenize_wrapper(input):
"""Tokenizes a string suppressing significant whitespace.""" """Tokenizes a string suppressing significant whitespace."""
skip = (token.NEWLINE, token.INDENT, token.DEDENT) 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: for quintuple in tokens:
type, value, start, end, line_text = quintuple type, value, start, end, line_text = quintuple
if type not in skip: if type not in skip:

66
Lib/lib2to3/pgen2/conv.py
View file

@ -60,8 +60,8 @@ class Converter(grammar.Grammar):
""" """
try: try:
f = open(filename) f = open(filename)
except IOError, err: except IOError as err:
print "Can't open %s: %s" % (filename, err) print("Can't open %s: %s" % (filename, err))
return False return False
self.symbol2number = {} self.symbol2number = {}
self.number2symbol = {} self.number2symbol = {}
@ -70,8 +70,8 @@ class Converter(grammar.Grammar):
lineno += 1 lineno += 1
mo = re.match(r"^#define\s+(\w+)\s+(\d+)$", line) mo = re.match(r"^#define\s+(\w+)\s+(\d+)$", line)
if not mo and line.strip(): if not mo and line.strip():
print "%s(%s): can't parse %s" % (filename, lineno, print("%s(%s): can't parse %s" % (filename, lineno,
line.strip()) line.strip()))
else: else:
symbol, number = mo.groups() symbol, number = mo.groups()
number = int(number) number = int(number)
@ -111,20 +111,20 @@ class Converter(grammar.Grammar):
""" """
try: try:
f = open(filename) f = open(filename)
except IOError, err: except IOError as err:
print "Can't open %s: %s" % (filename, err) print("Can't open %s: %s" % (filename, err))
return False return False
# The code below essentially uses f's iterator-ness! # The code below essentially uses f's iterator-ness!
lineno = 0 lineno = 0
# Expect the two #include lines # 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) 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) assert line == '#include "grammar.h"\n', (lineno, line)
# Parse the state definitions # Parse the state definitions
lineno, line = lineno+1, f.next() lineno, line = lineno+1, next(f)
allarcs = {} allarcs = {}
states = [] states = []
while line.startswith("static arc "): while line.startswith("static arc "):
@ -132,35 +132,35 @@ class Converter(grammar.Grammar):
mo = re.match(r"static arc arcs_(\d+)_(\d+)\[(\d+)\] = {$", mo = re.match(r"static arc arcs_(\d+)_(\d+)\[(\d+)\] = {$",
line) line)
assert mo, (lineno, line) assert mo, (lineno, line)
n, m, k = map(int, mo.groups()) n, m, k = list(map(int, mo.groups()))
arcs = [] arcs = []
for _ in range(k): for _ in range(k):
lineno, line = lineno+1, f.next() lineno, line = lineno+1, next(f)
mo = re.match(r"\s+{(\d+), (\d+)},$", line) mo = re.match(r"\s+{(\d+), (\d+)},$", line)
assert mo, (lineno, line) assert mo, (lineno, line)
i, j = map(int, mo.groups()) i, j = list(map(int, mo.groups()))
arcs.append((i, j)) arcs.append((i, j))
lineno, line = lineno+1, f.next() lineno, line = lineno+1, next(f)
assert line == "};\n", (lineno, line) assert line == "};\n", (lineno, line)
allarcs[(n, m)] = arcs 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) mo = re.match(r"static state states_(\d+)\[(\d+)\] = {$", line)
assert mo, (lineno, line) assert mo, (lineno, line)
s, t = map(int, mo.groups()) s, t = list(map(int, mo.groups()))
assert s == len(states), (lineno, line) assert s == len(states), (lineno, line)
state = [] state = []
for _ in range(t): 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) mo = re.match(r"\s+{(\d+), arcs_(\d+)_(\d+)},$", line)
assert mo, (lineno, line) assert mo, (lineno, line)
k, n, m = map(int, mo.groups()) k, n, m = list(map(int, mo.groups()))
arcs = allarcs[n, m] arcs = allarcs[n, m]
assert k == len(arcs), (lineno, line) assert k == len(arcs), (lineno, line)
state.append(arcs) state.append(arcs)
states.append(state) states.append(state)
lineno, line = lineno+1, f.next() lineno, line = lineno+1, next(f)
assert line == "};\n", (lineno, line) assert line == "};\n", (lineno, line)
lineno, line = lineno+1, f.next() lineno, line = lineno+1, next(f)
self.states = states self.states = states
# Parse the dfas # Parse the dfas
@ -169,18 +169,18 @@ class Converter(grammar.Grammar):
assert mo, (lineno, line) assert mo, (lineno, line)
ndfas = int(mo.group(1)) ndfas = int(mo.group(1))
for i in range(ndfas): 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+),$', mo = re.match(r'\s+{(\d+), "(\w+)", (\d+), (\d+), states_(\d+),$',
line) line)
assert mo, (lineno, line) assert mo, (lineno, line)
symbol = mo.group(2) 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.symbol2number[symbol] == number, (lineno, line)
assert self.number2symbol[number] == symbol, (lineno, line) assert self.number2symbol[number] == symbol, (lineno, line)
assert x == 0, (lineno, line) assert x == 0, (lineno, line)
state = states[z] state = states[z]
assert y == len(state), (lineno, line) 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) mo = re.match(r'\s+("(?:\\\d\d\d)*")},$', line)
assert mo, (lineno, line) assert mo, (lineno, line)
first = {} first = {}
@ -191,18 +191,18 @@ class Converter(grammar.Grammar):
if byte & (1<<j): if byte & (1<<j):
first[i*8 + j] = 1 first[i*8 + j] = 1
dfas[number] = (state, first) dfas[number] = (state, first)
lineno, line = lineno+1, f.next() lineno, line = lineno+1, next(f)
assert line == "};\n", (lineno, line) assert line == "};\n", (lineno, line)
self.dfas = dfas self.dfas = dfas
# Parse the labels # Parse the labels
labels = [] labels = []
lineno, line = lineno+1, f.next() lineno, line = lineno+1, next(f)
mo = re.match(r"static label labels\[(\d+)\] = {$", line) mo = re.match(r"static label labels\[(\d+)\] = {$", line)
assert mo, (lineno, line) assert mo, (lineno, line)
nlabels = int(mo.group(1)) nlabels = int(mo.group(1))
for i in range(nlabels): for i in range(nlabels):
lineno, line = lineno+1, f.next() lineno, line = lineno+1, next(f)
mo = re.match(r'\s+{(\d+), (0|"\w+")},$', line) mo = re.match(r'\s+{(\d+), (0|"\w+")},$', line)
assert mo, (lineno, line) assert mo, (lineno, line)
x, y = mo.groups() x, y = mo.groups()
@ -212,35 +212,35 @@ class Converter(grammar.Grammar):
else: else:
y = eval(y) y = eval(y)
labels.append((x, y)) labels.append((x, y))
lineno, line = lineno+1, f.next() lineno, line = lineno+1, next(f)
assert line == "};\n", (lineno, line) assert line == "};\n", (lineno, line)
self.labels = labels self.labels = labels
# Parse the grammar struct # Parse the grammar struct
lineno, line = lineno+1, f.next() lineno, line = lineno+1, next(f)
assert line == "grammar _PyParser_Grammar = {\n", (lineno, line) assert line == "grammar _PyParser_Grammar = {\n", (lineno, line)
lineno, line = lineno+1, f.next() lineno, line = lineno+1, next(f)
mo = re.match(r"\s+(\d+),$", line) mo = re.match(r"\s+(\d+),$", line)
assert mo, (lineno, line) assert mo, (lineno, line)
ndfas = int(mo.group(1)) ndfas = int(mo.group(1))
assert ndfas == len(self.dfas) assert ndfas == len(self.dfas)
lineno, line = lineno+1, f.next() lineno, line = lineno+1, next(f)
assert line == "\tdfas,\n", (lineno, line) assert line == "\tdfas,\n", (lineno, line)
lineno, line = lineno+1, f.next() lineno, line = lineno+1, next(f)
mo = re.match(r"\s+{(\d+), labels},$", line) mo = re.match(r"\s+{(\d+), labels},$", line)
assert mo, (lineno, line) assert mo, (lineno, line)
nlabels = int(mo.group(1)) nlabels = int(mo.group(1))
assert nlabels == len(self.labels), (lineno, line) assert nlabels == len(self.labels), (lineno, line)
lineno, line = lineno+1, f.next() lineno, line = lineno+1, next(f)
mo = re.match(r"\s+(\d+)$", line) mo = re.match(r"\s+(\d+)$", line)
assert mo, (lineno, line) assert mo, (lineno, line)
start = int(mo.group(1)) start = int(mo.group(1))
assert start in self.number2symbol, (lineno, line) assert start in self.number2symbol, (lineno, line)
self.start = start self.start = start
lineno, line = lineno+1, f.next() lineno, line = lineno+1, next(f)
assert line == "};\n", (lineno, line) assert line == "};\n", (lineno, line)
try: try:
lineno, line = lineno+1, f.next() lineno, line = lineno+1, next(f)
except StopIteration: except StopIteration:
pass pass
else: else:

2
Lib/lib2to3/pgen2/driver.py
View file

@ -99,7 +99,7 @@ class Driver(object):
def parse_string(self, text, debug=False): def parse_string(self, text, debug=False):
"""Parse a string and return the syntax tree.""" """Parse a string and return the syntax tree."""
tokens = tokenize.generate_tokens(generate_lines(text).next) tokens = tokenize.generate_tokens(generate_lines(text).__next__)
return self.parse_tokens(tokens, debug) return self.parse_tokens(tokens, debug)

12
Lib/lib2to3/pgen2/grammar.py
View file

@ -100,17 +100,17 @@ class Grammar(object):
def report(self): def report(self):
"""Dump the grammar tables to standard output, for debugging.""" """Dump the grammar tables to standard output, for debugging."""
from pprint import pprint from pprint import pprint
print "s2n" print("s2n")
pprint(self.symbol2number) pprint(self.symbol2number)
print "n2s" print("n2s")
pprint(self.number2symbol) pprint(self.number2symbol)
print "states" print("states")
pprint(self.states) pprint(self.states)
print "dfas" print("dfas")
pprint(self.dfas) pprint(self.dfas)
print "labels" print("labels")
pprint(self.labels) pprint(self.labels)
print "start", self.start print("start", self.start)
# Map from operator to number (since tokenize doesn't do this) # Map from operator to number (since tokenize doesn't do this)

2
Lib/lib2to3/pgen2/literals.py
View file

@ -53,7 +53,7 @@ def test():
s = repr(c) s = repr(c)
e = evalString(s) e = evalString(s)
if e != c: if e != c:
print i, c, s, e print(i, c, s, e)
if __name__ == "__main__": if __name__ == "__main__":

40
Lib/lib2to3/pgen2/pgen.py
View file

@ -26,7 +26,7 @@ class ParserGenerator(object):
def make_grammar(self): def make_grammar(self):
c = PgenGrammar() c = PgenGrammar()
names = self.dfas.keys() names = list(self.dfas.keys())
names.sort() names.sort()
names.remove(self.startsymbol) names.remove(self.startsymbol)
names.insert(0, self.startsymbol) names.insert(0, self.startsymbol)
@ -39,7 +39,7 @@ class ParserGenerator(object):
states = [] states = []
for state in dfa: for state in dfa:
arcs = [] arcs = []
for label, next in state.arcs.iteritems(): for label, next in state.arcs.items():
arcs.append((self.make_label(c, label), dfa.index(next))) arcs.append((self.make_label(c, label), dfa.index(next)))
if state.isfinal: if state.isfinal:
arcs.append((0, dfa.index(state))) arcs.append((0, dfa.index(state)))
@ -105,7 +105,7 @@ class ParserGenerator(object):
return ilabel return ilabel
def addfirstsets(self): def addfirstsets(self):
names = self.dfas.keys() names = list(self.dfas.keys())
names.sort() names.sort()
for name in names: for name in names:
if name not in self.first: if name not in self.first:
@ -118,7 +118,7 @@ class ParserGenerator(object):
state = dfa[0] state = dfa[0]
totalset = {} totalset = {}
overlapcheck = {} overlapcheck = {}
for label, next in state.arcs.iteritems(): for label, next in state.arcs.items():
if label in self.dfas: if label in self.dfas:
if label in self.first: if label in self.first:
fset = self.first[label] fset = self.first[label]
@ -133,7 +133,7 @@ class ParserGenerator(object):
totalset[label] = 1 totalset[label] = 1
overlapcheck[label] = {label: 1} overlapcheck[label] = {label: 1}
inverse = {} inverse = {}
for label, itsfirst in overlapcheck.iteritems(): for label, itsfirst in overlapcheck.items():
for symbol in itsfirst: for symbol in itsfirst:
if symbol in inverse: if symbol in inverse:
raise ValueError("rule %s is ambiguous; %s is in the" raise ValueError("rule %s is ambiguous; %s is in the"
@ -192,7 +192,7 @@ class ParserGenerator(object):
for label, next in nfastate.arcs: for label, next in nfastate.arcs:
if label is not None: if label is not None:
addclosure(next, arcs.setdefault(label, {})) addclosure(next, arcs.setdefault(label, {}))
for label, nfaset in arcs.iteritems(): for label, nfaset in arcs.items():
for st in states: for st in states:
if st.nfaset == nfaset: if st.nfaset == nfaset:
break break
@ -203,10 +203,10 @@ class ParserGenerator(object):
return states # List of DFAState instances; first one is start return states # List of DFAState instances; first one is start
def dump_nfa(self, name, start, finish): def dump_nfa(self, name, start, finish):
print "Dump of NFA for", name print("Dump of NFA for", name)
todo = [start] todo = [start]
for i, state in enumerate(todo): for i, state in enumerate(todo):
print " State", i, state is finish and "(final)" or "" print(" State", i, state is finish and "(final)" or "")
for label, next in state.arcs: for label, next in state.arcs:
if next in todo: if next in todo:
j = todo.index(next) j = todo.index(next)
@ -214,16 +214,16 @@ class ParserGenerator(object):
j = len(todo) j = len(todo)
todo.append(next) todo.append(next)
if label is None: if label is None:
print " -> %d" % j print(" -> %d" % j)
else: else:
print " %s -> %d" % (label, j) print(" %s -> %d" % (label, j))
def dump_dfa(self, name, dfa): def dump_dfa(self, name, dfa):
print "Dump of DFA for", name print("Dump of DFA for", name)
for i, state in enumerate(dfa): for i, state in enumerate(dfa):
print " State", i, state.isfinal and "(final)" or "" print(" State", i, state.isfinal and "(final)" or "")
for label, next in state.arcs.iteritems(): for label, next in state.arcs.items():
print " %s -> %d" % (label, dfa.index(next)) print(" %s -> %d" % (label, dfa.index(next)))
def simplify_dfa(self, dfa): def simplify_dfa(self, dfa):
# This is not theoretically optimal, but works well enough. # This is not theoretically optimal, but works well enough.
@ -319,9 +319,9 @@ class ParserGenerator(object):
return value return value
def gettoken(self): def gettoken(self):
tup = self.generator.next() tup = next(self.generator)
while tup[0] in (tokenize.COMMENT, tokenize.NL): 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 self.type, self.value, self.begin, self.end, self.line = tup
#print token.tok_name[self.type], repr(self.value) #print token.tok_name[self.type], repr(self.value)
@ -330,7 +330,7 @@ class ParserGenerator(object):
try: try:
msg = msg % args msg = msg % args
except: except:
msg = " ".join([msg] + map(str, args)) msg = " ".join([msg] + list(map(str, args)))
raise SyntaxError(msg, (self.filename, self.end[0], raise SyntaxError(msg, (self.filename, self.end[0],
self.end[1], self.line)) self.end[1], self.line))
@ -348,7 +348,7 @@ class DFAState(object):
def __init__(self, nfaset, final): def __init__(self, nfaset, final):
assert isinstance(nfaset, dict) assert isinstance(nfaset, dict)
assert isinstance(iter(nfaset).next(), NFAState) assert isinstance(next(iter(nfaset)), NFAState)
assert isinstance(final, NFAState) assert isinstance(final, NFAState)
self.nfaset = nfaset self.nfaset = nfaset
self.isfinal = final in nfaset self.isfinal = final in nfaset
@ -361,7 +361,7 @@ class DFAState(object):
self.arcs[label] = next self.arcs[label] = next
def unifystate(self, old, new): def unifystate(self, old, new):
for label, next in self.arcs.iteritems(): for label, next in self.arcs.items():
if next is old: if next is old:
self.arcs[label] = new self.arcs[label] = new
@ -374,7 +374,7 @@ class DFAState(object):
# would invoke this method recursively, with cycles... # would invoke this method recursively, with cycles...
if len(self.arcs) != len(other.arcs): if len(self.arcs) != len(other.arcs):
return False return False
for label, next in self.arcs.iteritems(): for label, next in self.arcs.items():
if next is not other.arcs.get(label): if next is not other.arcs.get(label):
return False return False
return True return True

2
Lib/lib2to3/pgen2/token.py
View file

@ -67,7 +67,7 @@ NT_OFFSET = 256
#--end constants-- #--end constants--
tok_name = {} tok_name = {}
for _name, _value in globals().items(): for _name, _value in list(globals().items()):
if type(_value) is type(0): if type(_value) is type(0):
tok_name[_value] = _name tok_name[_value] = _name

16
Lib/lib2to3/pgen2/tokenize.py
View file

@ -94,8 +94,8 @@ ContStr = group(r"[uUbB]?[rR]?'[^\n'\\]*(?:\\.[^\n'\\]*)*" +
PseudoExtras = group(r'\\\r?\n', Comment, Triple) PseudoExtras = group(r'\\\r?\n', Comment, Triple)
PseudoToken = Whitespace + group(PseudoExtras, Number, Funny, ContStr, Name) PseudoToken = Whitespace + group(PseudoExtras, Number, Funny, ContStr, Name)
tokenprog, pseudoprog, single3prog, double3prog = map( tokenprog, pseudoprog, single3prog, double3prog = list(map(
re.compile, (Token, PseudoToken, Single3, Double3)) re.compile, (Token, PseudoToken, Single3, Double3)))
endprogs = {"'": re.compile(Single), '"': re.compile(Double), endprogs = {"'": re.compile(Single), '"': re.compile(Double),
"'''": single3prog, '"""': double3prog, "'''": single3prog, '"""': double3prog,
"r'''": single3prog, 'r"""': double3prog, "r'''": single3prog, 'r"""': double3prog,
@ -143,9 +143,11 @@ class TokenError(Exception): pass
class StopTokenizing(Exception): pass class StopTokenizing(Exception): pass
def printtoken(type, token, (srow, scol), (erow, ecol), line): # for testing def printtoken(type, token, xxx_todo_changeme, xxx_todo_changeme1, line): # for testing
print "%d,%d-%d,%d:\t%s\t%s" % \ (srow, scol) = xxx_todo_changeme
(srow, scol, erow, ecol, tok_name[type], repr(token)) (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): def tokenize(readline, tokeneater=printtoken):
""" """
@ -279,7 +281,7 @@ def generate_tokens(readline):
if contstr: # continued string if contstr: # continued string
if not line: if not line:
raise TokenError, ("EOF in multi-line string", strstart) raise TokenError("EOF in multi-line string", strstart)
endmatch = endprog.match(line) endmatch = endprog.match(line)
if endmatch: if endmatch:
pos = end = endmatch.end(0) pos = end = endmatch.end(0)
@ -335,7 +337,7 @@ def generate_tokens(readline):
else: # continued statement else: # continued statement
if not line: if not line:
raise TokenError, ("EOF in multi-line statement", (lnum, 0)) raise TokenError("EOF in multi-line statement", (lnum, 0))
continued = 0 continued = 0
while pos < max: while pos < max:

2
Lib/lib2to3/pygram.py
View file

@ -23,7 +23,7 @@ class Symbols(object):
Creates an attribute for each grammar symbol (nonterminal), Creates an attribute for each grammar symbol (nonterminal),
whose value is the symbol's type (an int >= 256). 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) setattr(self, name, symbol)

6
Lib/lib2to3/pytree.py
View file

@ -443,7 +443,7 @@ class LeafPattern(BasePattern):
if type is not None: if type is not None:
assert 0 <= type < 256, type assert 0 <= type < 256, type
if content is not None: if content is not None:
assert isinstance(content, basestring), repr(content) assert isinstance(content, str), repr(content)
self.type = type self.type = type
self.content = content self.content = content
self.name = name self.name = name
@ -491,7 +491,7 @@ class NodePattern(BasePattern):
if type is not None: if type is not None:
assert type >= 256, type assert type >= 256, type
if content is not None: if content is not None:
assert not isinstance(content, basestring), repr(content) assert not isinstance(content, str), repr(content)
content = list(content) content = list(content)
for i, item in enumerate(content): for i, item in enumerate(content):
assert isinstance(item, BasePattern), (i, item) assert isinstance(item, BasePattern), (i, item)
@ -622,7 +622,7 @@ class WildcardPattern(BasePattern):
""" """
if self.content is None: if self.content is None:
# Shortcut for special case (see __init__.__doc__) # 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 = {} r = {}
if self.name: if self.name:
r[self.name] = nodes[:count] r[self.name] = nodes[:count]

30
Lib/lib2to3/refactor.py
View file

@ -63,14 +63,14 @@ def main(args=None):
# Parse command line arguments # Parse command line arguments
options, args = parser.parse_args(args) options, args = parser.parse_args(args)
if options.list_fixes: 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(): for fixname in get_all_fix_names():
print fixname print(fixname)
if not args: if not args:
return 0 return 0
if not args: if not args:
print >>sys.stderr, "At least one file or directory argument required." print("At least one file or directory argument required.", file=sys.stderr)
print >>sys.stderr, "Use --help to show usage." print("Use --help to show usage.", file=sys.stderr)
return 2 return 2
# Initialize the refactoring tool # Initialize the refactoring tool
@ -145,7 +145,7 @@ class RefactoringTool(object):
continue continue
try: try:
fixer = fix_class(self.options, self.fixer_log) 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()", self.log_error("Can't instantiate fixes.fix_%s.%s()",
fix_name, class_name, exc_info=True) fix_name, class_name, exc_info=True)
continue continue
@ -207,7 +207,7 @@ class RefactoringTool(object):
"""Refactors a file.""" """Refactors a file."""
try: try:
f = open(filename) f = open(filename)
except IOError, err: except IOError as err:
self.log_error("Can't open %s: %s", filename, err) self.log_error("Can't open %s: %s", filename, err)
return return
try: try:
@ -243,7 +243,7 @@ class RefactoringTool(object):
""" """
try: try:
tree = self.driver.parse_string(data,1) tree = self.driver.parse_string(data,1)
except Exception, err: except Exception as err:
self.log_error("Can't parse %s: %s: %s", self.log_error("Can't parse %s: %s: %s",
name, err.__class__.__name__, err) name, err.__class__.__name__, err)
return return
@ -331,7 +331,7 @@ class RefactoringTool(object):
if old_text is None: if old_text is None:
try: try:
f = open(filename, "r") f = open(filename, "r")
except IOError, err: except IOError as err:
self.log_error("Can't read %s: %s", filename, err) self.log_error("Can't read %s: %s", filename, err)
return return
try: try:
@ -351,21 +351,21 @@ class RefactoringTool(object):
if os.path.lexists(backup): if os.path.lexists(backup):
try: try:
os.remove(backup) os.remove(backup)
except os.error, err: except os.error as err:
self.log_message("Can't remove backup %s", backup) self.log_message("Can't remove backup %s", backup)
try: try:
os.rename(filename, backup) os.rename(filename, backup)
except os.error, err: except os.error as err:
self.log_message("Can't rename %s to %s", filename, backup) self.log_message("Can't rename %s to %s", filename, backup)
try: try:
f = open(filename, "w") f = open(filename, "w")
except os.error, err: except os.error as err:
self.log_error("Can't create %s: %s", filename, err) self.log_error("Can't create %s: %s", filename, err)
return return
try: try:
try: try:
f.write(new_text) f.write(new_text)
except os.error, err: except os.error as err:
self.log_error("Can't write %s: %s", filename, err) self.log_error("Can't write %s: %s", filename, err)
finally: finally:
f.close() f.close()
@ -428,7 +428,7 @@ class RefactoringTool(object):
""" """
try: try:
tree = self.parse_block(block, lineno, indent) tree = self.parse_block(block, lineno, indent)
except Exception, err: except Exception as err:
if self.options.verbose: if self.options.verbose:
for line in block: for line in block:
self.log_message("Source: %s", line.rstrip("\n")) self.log_message("Source: %s", line.rstrip("\n"))
@ -480,7 +480,7 @@ class RefactoringTool(object):
def wrap_toks(self, block, lineno, indent): def wrap_toks(self, block, lineno, indent):
"""Wraps a tokenize stream to systematically modify start/end.""" """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: for type, value, (line0, col0), (line1, col1), line_text in tokens:
line0 += lineno - 1 line0 += lineno - 1
line1 += 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, for line in difflib.unified_diff(a, b, filename, filename,
"(original)", "(refactored)", "(original)", "(refactored)",
lineterm=""): lineterm=""):
print line print(line)
if __name__ == "__main__": if __name__ == "__main__":

8
Lib/lib2to3/tests/benchmark.py
View file

@ -23,7 +23,7 @@ from .. import refactor
############################################################################### ###############################################################################
class Options: class Options:
def __init__(self, **kwargs): def __init__(self, **kwargs):
for k, v in kwargs.items(): for k, v in list(kwargs.items()):
setattr(self, k, v) setattr(self, k, v)
self.verbose = False self.verbose = False
@ -34,7 +34,7 @@ def dummy_transform(*args, **kwargs):
### Collect list of modules to match against ### Collect list of modules to match against
############################################################################### ###############################################################################
files = [] files = []
for mod in sys.modules.values(): for mod in list(sys.modules.values()):
if mod is None or not hasattr(mod, '__file__'): if mod is None or not hasattr(mod, '__file__'):
continue continue
f = mod.__file__ f = mod.__file__
@ -53,6 +53,6 @@ for fixer in refactor.fixers:
t = time() t = time()
for f in files: for f in files:
print "Matching", f print("Matching", f)
refactor.refactor_file(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)))

138
Lib/lib2to3/tests/data/py2_test_grammar.py
View file

@ -30,13 +30,13 @@ class TokenTests(unittest.TestCase):
def testPlainIntegers(self): def testPlainIntegers(self):
self.assertEquals(0xff, 255) self.assertEquals(0xff, 255)
self.assertEquals(0377, 255) self.assertEquals(0o377, 255)
self.assertEquals(2147483647, 017777777777) self.assertEquals(2147483647, 0o17777777777)
from sys import maxint from sys import maxsize
if maxint == 2147483647: if maxint == 2147483647:
self.assertEquals(-2147483647-1, -020000000000) self.assertEquals(-2147483647-1, -0o20000000000)
# XXX -2147483648 # XXX -2147483648
self.assert_(037777777777 > 0) self.assert_(0o37777777777 > 0)
self.assert_(0xffffffff > 0) self.assert_(0xffffffff > 0)
for s in '2147483648', '040000000000', '0x100000000': for s in '2147483648', '040000000000', '0x100000000':
try: try:
@ -44,8 +44,8 @@ class TokenTests(unittest.TestCase):
except OverflowError: except OverflowError:
self.fail("OverflowError on huge integer literal %r" % s) self.fail("OverflowError on huge integer literal %r" % s)
elif maxint == 9223372036854775807: elif maxint == 9223372036854775807:
self.assertEquals(-9223372036854775807-1, -01000000000000000000000) self.assertEquals(-9223372036854775807-1, -0o1000000000000000000000)
self.assert_(01777777777777777777777 > 0) self.assert_(0o1777777777777777777777 > 0)
self.assert_(0xffffffffffffffff > 0) self.assert_(0xffffffffffffffff > 0)
for s in '9223372036854775808', '02000000000000000000000', \ for s in '9223372036854775808', '02000000000000000000000', \
'0x10000000000000000': '0x10000000000000000':
@ -57,14 +57,14 @@ class TokenTests(unittest.TestCase):
self.fail('Weird maxint value %r' % maxint) self.fail('Weird maxint value %r' % maxint)
def testLongIntegers(self): def testLongIntegers(self):
x = 0L x = 0
x = 0l x = 0
x = 0xffffffffffffffffL x = 0xffffffffffffffff
x = 0xffffffffffffffffl x = 0xffffffffffffffff
x = 077777777777777777L x = 0o77777777777777777
x = 077777777777777777l x = 0o77777777777777777
x = 123456789012345678901234567890L x = 123456789012345678901234567890
x = 123456789012345678901234567890l x = 123456789012345678901234567890
def testFloats(self): def testFloats(self):
x = 3.14 x = 3.14
@ -152,27 +152,27 @@ class GrammarTests(unittest.TestCase):
f1(*(), **{}) f1(*(), **{})
def f2(one_argument): pass def f2(one_argument): pass
def f3(two, arguments): pass def f3(two, arguments): pass
def f4(two, (compound, (argument, list))): pass def f4(two, xxx_todo_changeme): (compound, (argument, list)) = xxx_todo_changeme; pass
def f5((compound, first), two): pass def f5(xxx_todo_changeme1, two): (compound, first) = xxx_todo_changeme1; pass
self.assertEquals(f2.func_code.co_varnames, ('one_argument',)) self.assertEquals(f2.__code__.co_varnames, ('one_argument',))
self.assertEquals(f3.func_code.co_varnames, ('two', 'arguments')) self.assertEquals(f3.__code__.co_varnames, ('two', 'arguments'))
if sys.platform.startswith('java'): if sys.platform.startswith('java'):
self.assertEquals(f4.func_code.co_varnames, self.assertEquals(f4.__code__.co_varnames,
('two', '(compound, (argument, list))', 'compound', 'argument', ('two', '(compound, (argument, list))', 'compound', 'argument',
'list',)) 'list',))
self.assertEquals(f5.func_code.co_varnames, self.assertEquals(f5.__code__.co_varnames,
('(compound, first)', 'two', 'compound', 'first')) ('(compound, first)', 'two', 'compound', 'first'))
else: else:
self.assertEquals(f4.func_code.co_varnames, self.assertEquals(f4.__code__.co_varnames,
('two', '.1', 'compound', 'argument', 'list')) ('two', '.1', 'compound', 'argument', 'list'))
self.assertEquals(f5.func_code.co_varnames, self.assertEquals(f5.__code__.co_varnames,
('.0', 'two', 'compound', 'first')) ('.0', 'two', 'compound', 'first'))
def a1(one_arg,): pass def a1(one_arg,): pass
def a2(two, args,): pass def a2(two, args,): pass
def v0(*rest): pass def v0(*rest): pass
def v1(a, *rest): pass def v1(a, *rest): pass
def v2(a, b, *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() f1()
f2(1) f2(1)
@ -201,9 +201,9 @@ class GrammarTests(unittest.TestCase):
# ceval unpacks the formal arguments into the first argcount names; # ceval unpacks the formal arguments into the first argcount names;
# thus, the names nested inside tuples must appear after these names. # thus, the names nested inside tuples must appear after these names.
if sys.platform.startswith('java'): 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: 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,))) self.assertEquals(v3(1, (2, 3), 4), (1, 2, 3, (4,)))
def d01(a=1): pass def d01(a=1): pass
d01() d01()
@ -277,9 +277,9 @@ class GrammarTests(unittest.TestCase):
d22v(*(1, 2, 3, 4)) d22v(*(1, 2, 3, 4))
d22v(1, 2, *(3, 4, 5)) d22v(1, 2, *(3, 4, 5))
d22v(1, *(2, 3), **{'d': 4}) d22v(1, *(2, 3), **{'d': 4})
def d31v((x)): pass def d31v(xxx_todo_changeme3): (x) = xxx_todo_changeme3; pass
d31v(1) d31v(1)
def d32v((x,)): pass def d32v(xxx_todo_changeme4): (x,) = xxx_todo_changeme4; pass
d32v((1,)) d32v((1,))
def testLambdef(self): def testLambdef(self):
@ -287,7 +287,7 @@ class GrammarTests(unittest.TestCase):
l1 = lambda : 0 l1 = lambda : 0
self.assertEquals(l1(), 0) self.assertEquals(l1(), 0)
l2 = lambda : a[d] # XXX just testing the expression 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]) self.assertEquals(l3(), [0, 1, 0])
l4 = lambda x = lambda y = lambda z=1 : z : y() : x() l4 = lambda x = lambda y = lambda z=1 : z : y() : x()
self.assertEquals(l4(), 1) self.assertEquals(l4(), 1)
@ -325,36 +325,36 @@ class GrammarTests(unittest.TestCase):
def testPrintStmt(self): def testPrintStmt(self):
# 'print' (test ',')* [test] # 'print' (test ',')* [test]
import StringIO import io
# Can't test printing to real stdout without comparing output # Can't test printing to real stdout without comparing output
# which is not available in unittest. # which is not available in unittest.
save_stdout = sys.stdout save_stdout = sys.stdout
sys.stdout = StringIO.StringIO() sys.stdout = io.StringIO()
print 1, 2, 3 print(1, 2, 3)
print 1, 2, 3, print(1, 2, 3, end=' ')
print print()
print 0 or 1, 0 or 1, print(0 or 1, 0 or 1, end=' ')
print 0 or 1 print(0 or 1)
# 'print' '>>' test ',' # 'print' '>>' test ','
print >> sys.stdout, 1, 2, 3 print(1, 2, 3, file=sys.stdout)
print >> sys.stdout, 1, 2, 3, print(1, 2, 3, end=' ', file=sys.stdout)
print >> sys.stdout print(file=sys.stdout)
print >> sys.stdout, 0 or 1, 0 or 1, print(0 or 1, 0 or 1, end=' ', file=sys.stdout)
print >> sys.stdout, 0 or 1 print(0 or 1, file=sys.stdout)
# test printing to an instance # test printing to an instance
class Gulp: class Gulp:
def write(self, msg): pass def write(self, msg): pass
gulp = Gulp() gulp = Gulp()
print >> gulp, 1, 2, 3 print(1, 2, 3, file=gulp)
print >> gulp, 1, 2, 3, print(1, 2, 3, end=' ', file=gulp)
print >> gulp print(file=gulp)
print >> gulp, 0 or 1, 0 or 1, print(0 or 1, 0 or 1, end=' ', file=gulp)
print >> gulp, 0 or 1 print(0 or 1, file=gulp)
# test print >> None # test print >> None
def driver(): def driver():
@ -368,13 +368,13 @@ class GrammarTests(unittest.TestCase):
# we should see this once # we should see this once
def tellme(file=sys.stdout): def tellme(file=sys.stdout):
print >> file, 'hello world' print('hello world', file=file)
driver() driver()
# we should not see this at all # we should not see this at all
def tellme(file=None): def tellme(file=None):
print >> file, 'goodbye universe' print('goodbye universe', file=file)
driver() driver()
@ -461,7 +461,7 @@ hello world
continue continue
except: except:
raise 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!") self.fail("continue then break in try/except in loop broken!")
test_inner() test_inner()
@ -478,7 +478,7 @@ hello world
def testRaise(self): def testRaise(self):
# 'raise' test [',' test] # 'raise' test [',' test]
try: raise RuntimeError, 'just testing' try: raise RuntimeError('just testing')
except RuntimeError: pass except RuntimeError: pass
try: raise KeyboardInterrupt try: raise KeyboardInterrupt
except KeyboardInterrupt: pass except KeyboardInterrupt: pass
@ -506,33 +506,33 @@ hello world
# 'exec' expr ['in' expr [',' expr]] # 'exec' expr ['in' expr [',' expr]]
z = None z = None
del z del z
exec 'z=1+1\n' exec('z=1+1\n')
if z != 2: self.fail('exec \'z=1+1\'\\n') if z != 2: self.fail('exec \'z=1+1\'\\n')
del z del z
exec 'z=1+1' exec('z=1+1')
if z != 2: self.fail('exec \'z=1+1\'') if z != 2: self.fail('exec \'z=1+1\'')
z = None z = None
del z del z
import types import types
if hasattr(types, "UnicodeType"): if hasattr(types, "UnicodeType"):
exec r"""if 1: exec(r"""if 1:
exec u'z=1+1\n' exec u'z=1+1\n'
if z != 2: self.fail('exec u\'z=1+1\'\\n') if z != 2: self.fail('exec u\'z=1+1\'\\n')
del z del z
exec u'z=1+1' 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 = {} g = {}
exec 'z = 1' in g exec('z = 1', g)
if g.has_key('__builtins__'): del g['__builtins__'] if '__builtins__' in g: del g['__builtins__']
if g != {'z': 1}: self.fail('exec \'z = 1\' in g') if g != {'z': 1}: self.fail('exec \'z = 1\' in g')
g = {} g = {}
l = {} l = {}
import warnings import warnings
warnings.filterwarnings("ignore", "global statement", module="<string>") warnings.filterwarnings("ignore", "global statement", module="<string>")
exec 'global a; a = 1; b = 2' in g, l exec('global a; a = 1; b = 2', g, l)
if g.has_key('__builtins__'): del g['__builtins__'] if '__builtins__' in g: del g['__builtins__']
if l.has_key('__builtins__'): del l['__builtins__'] if '__builtins__' in l: del l['__builtins__']
if (g, l) != ({'a':1}, {'b':2}): if (g, l) != ({'a':1}, {'b':2}):
self.fail('exec ... in g (%s), l (%s)' %(g,l)) self.fail('exec ... in g (%s), l (%s)' %(g,l))
@ -544,7 +544,7 @@ hello world
assert 1, lambda x:x+1 assert 1, lambda x:x+1
try: try:
assert 0, "msg" assert 0, "msg"
except AssertionError, e: except AssertionError as e:
self.assertEquals(e.args[0], "msg") self.assertEquals(e.args[0], "msg")
else: else:
if __debug__: if __debug__:
@ -655,7 +655,7 @@ hello world
x = (1 == 1) 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 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 is not 1: pass
if 1 in (): pass if 1 in (): pass
if 1 not 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): def testBinaryMaskOps(self):
x = 1 & 1 x = 1 & 1
@ -747,9 +747,9 @@ hello world
x = {'one': 1, 'two': 2,} x = {'one': 1, 'two': 2,}
x = {'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5, 'six': 6} x = {'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5, 'six': 6}
x = `x` x = repr(x)
x = `1 or 2 or 3` x = repr(1 or 2 or 3)
self.assertEqual(`1,2`, '(1, 2)') self.assertEqual(repr((1,2)), '(1, 2)')
x = x x = x
x = 'x' x = 'x'
@ -837,9 +837,9 @@ hello world
def testGenexps(self): def testGenexps(self):
# generator expression tests # generator expression tests
g = ([x for x in range(10)] for x in range(1)) 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: try:
g.next() next(g)
self.fail('should produce StopIteration exception') self.fail('should produce StopIteration exception')
except StopIteration: except StopIteration:
pass pass
@ -847,7 +847,7 @@ hello world
a = 1 a = 1
try: try:
g = (a for d in a) g = (a for d in a)
g.next() next(g)
self.fail('should produce TypeError') self.fail('should produce TypeError')
except TypeError: except TypeError:
pass pass
@ -892,7 +892,7 @@ hello world
# Test ifelse expressions in various cases # Test ifelse expressions in various cases
def _checkeval(msg, ret): def _checkeval(msg, ret):
"helper to check that evaluation of expressions is done correctly" "helper to check that evaluation of expressions is done correctly"
print x print(x)
return ret return ret
self.assertEqual([ x() for x in lambda: True, lambda: False if x() ], [True]) self.assertEqual([ x() for x in lambda: True, lambda: False if x() ], [True])

4
Lib/lib2to3/tests/data/py3_test_grammar.py
View file

@ -32,7 +32,7 @@ class TokenTests(unittest.TestCase):
self.assertEquals(0o377, 255) self.assertEquals(0o377, 255)
self.assertEquals(2147483647, 0o17777777777) self.assertEquals(2147483647, 0o17777777777)
self.assertEquals(0b1001, 9) self.assertEquals(0b1001, 9)
from sys import maxint from sys import maxsize
if maxint == 2147483647: if maxint == 2147483647:
self.assertEquals(-2147483647-1, -0o20000000000) self.assertEquals(-2147483647-1, -0o20000000000)
# XXX -2147483648 # XXX -2147483648
@ -438,7 +438,7 @@ class GrammarTests(unittest.TestCase):
def testRaise(self): def testRaise(self):
# 'raise' test [',' test] # 'raise' test [',' test]
try: raise RuntimeError, 'just testing' try: raise RuntimeError('just testing')
except RuntimeError: pass except RuntimeError: pass
try: raise KeyboardInterrupt try: raise KeyboardInterrupt
except KeyboardInterrupt: pass except KeyboardInterrupt: pass

18
Lib/lib2to3/tests/pytree_idempotency.py
View file

@ -28,7 +28,7 @@ def main():
fn = "example.py" fn = "example.py"
tree = dr.parse_file(fn, debug=True) tree = dr.parse_file(fn, debug=True)
if not diff(fn, tree): if not diff(fn, tree):
print "No diffs." print("No diffs.")
if not sys.argv[1:]: if not sys.argv[1:]:
return # Pass a dummy argument to run the complete test suite below return # Pass a dummy argument to run the complete test suite below
@ -44,7 +44,7 @@ def main():
fn = fn[:-1] fn = fn[:-1]
if not fn.endswith(".py"): if not fn.endswith(".py"):
continue continue
print >>sys.stderr, "Parsing", fn print("Parsing", fn, file=sys.stderr)
tree = dr.parse_file(fn, debug=True) tree = dr.parse_file(fn, debug=True)
if diff(fn, tree): if diff(fn, tree):
problems.append(fn) problems.append(fn)
@ -55,27 +55,27 @@ def main():
names = os.listdir(dir) names = os.listdir(dir)
except os.error: except os.error:
continue continue
print >>sys.stderr, "Scanning", dir, "..." print("Scanning", dir, "...", file=sys.stderr)
for name in names: for name in names:
if not name.endswith(".py"): if not name.endswith(".py"):
continue continue
print >>sys.stderr, "Parsing", name print("Parsing", name, file=sys.stderr)
fn = os.path.join(dir, name) fn = os.path.join(dir, name)
try: try:
tree = dr.parse_file(fn, debug=True) tree = dr.parse_file(fn, debug=True)
except pgen2.parse.ParseError, err: except pgen2.parse.ParseError as err:
print "ParseError:", err print("ParseError:", err)
else: else:
if diff(fn, tree): if diff(fn, tree):
problems.append(fn) problems.append(fn)
# Show summary of problem files # Show summary of problem files
if not problems: if not problems:
print "No problems. Congratulations!" print("No problems. Congratulations!")
else: else:
print "Problems in following files:" print("Problems in following files:")
for fn in problems: for fn in problems:
print "***", fn print("***", fn)
def diff(fn, tree): def diff(fn, tree):
f = open("@", "w") f = open("@", "w")

4
Lib/lib2to3/tests/test_all_fixers.py
View file

@ -21,7 +21,7 @@ from .. import refactor
class Options: class Options:
def __init__(self, **kwargs): def __init__(self, **kwargs):
for k, v in kwargs.items(): for k, v in list(kwargs.items()):
setattr(self, k, v) setattr(self, k, v)
self.verbose = False self.verbose = False
@ -33,7 +33,7 @@ class Test_all(support.TestCase):
def test_all_project_files(self): def test_all_project_files(self):
for filepath in support.all_project_files(): for filepath in support.all_project_files():
print "Fixing %s..." % filepath print("Fixing %s..." % filepath)
self.refactor.refactor_string(open(filepath).read(), filepath) self.refactor.refactor_string(open(filepath).read(), filepath)

22
Lib/lib2to3/tests/test_fixers.py
View file

@ -18,7 +18,7 @@ from .. import refactor
class Options: class Options:
def __init__(self, **kwargs): def __init__(self, **kwargs):
for k, v in kwargs.items(): for k, v in list(kwargs.items()):
setattr(self, k, v) setattr(self, k, v)
self.verbose = False self.verbose = False
@ -1285,7 +1285,7 @@ class Test_imports(FixerTestCase):
} }
def test_import_module(self): 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 b = "import %s" % old
a = "import %s" % new a = "import %s" % new
self.check(b, a) self.check(b, a)
@ -1295,7 +1295,7 @@ class Test_imports(FixerTestCase):
self.check(b, a) self.check(b, a)
def test_import_from(self): 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: for member in members:
b = "from %s import %s" % (old, member) b = "from %s import %s" % (old, member)
a = "from %s import %s" % (new, member) a = "from %s import %s" % (new, member)
@ -1305,7 +1305,7 @@ class Test_imports(FixerTestCase):
self.unchanged(s) self.unchanged(s)
def test_import_module_as(self): 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 b = "import %s as foo_bar" % old
a = "import %s as foo_bar" % new a = "import %s as foo_bar" % new
self.check(b, a) self.check(b, a)
@ -1315,7 +1315,7 @@ class Test_imports(FixerTestCase):
self.check(b, a) self.check(b, a)
def test_import_from_as(self): 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: for member in members:
b = "from %s import %s as foo_bar" % (old, member) b = "from %s import %s as foo_bar" % (old, member)
a = "from %s import %s as foo_bar" % (new, 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") self.warns_unchanged(s, "Cannot handle star imports")
def test_import_module_usage(self): 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: for member in members:
b = """ b = """
import %s import %s
@ -1340,7 +1340,7 @@ class Test_imports(FixerTestCase):
self.check(b, a) self.check(b, a)
def test_from_import_usage(self): 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: for member in members:
b = """ b = """
from %s import %s from %s import %s
@ -2211,7 +2211,7 @@ class Test_renames(FixerTestCase):
} }
def test_import_from(self): 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) b = "from %s import %s" % (mod, old)
a = "from %s import %s" % (mod, new) a = "from %s import %s" % (mod, new)
self.check(b, a) self.check(b, a)
@ -2220,13 +2220,13 @@ class Test_renames(FixerTestCase):
self.unchanged(s) self.unchanged(s)
def test_import_from_as(self): 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) b = "from %s import %s as foo_bar" % (mod, old)
a = "from %s import %s as foo_bar" % (mod, new) a = "from %s import %s as foo_bar" % (mod, new)
self.check(b, a) self.check(b, a)
def test_import_module_usage(self): def test_import_module_usage(self):
for mod, (old, new) in self.modules.items(): for mod, (old, new) in list(self.modules.items()):
b = """ b = """
import %s import %s
foo(%s, %s.%s) foo(%s, %s.%s)
@ -2239,7 +2239,7 @@ class Test_renames(FixerTestCase):
def XXX_test_from_import_usage(self): def XXX_test_from_import_usage(self):
# not implemented yet # not implemented yet
for mod, (old, new) in self.modules.items(): for mod, (old, new) in list(self.modules.items()):
b = """ b = """
from %s import %s from %s import %s
foo(%s, %s) foo(%s, %s)

2
Lib/lib2to3/tests/test_parser.py
View file

@ -149,7 +149,7 @@ class TestParserIdempotency(support.TestCase):
def test_all_project_files(self): def test_all_project_files(self):
for filepath in support.all_project_files(): for filepath in support.all_project_files():
print "Parsing %s..." % filepath print("Parsing %s..." % filepath)
tree = driver.parse_file(filepath, debug=True) tree = driver.parse_file(filepath, debug=True)
if diff(filepath, tree): if diff(filepath, tree):
self.fail("Idempotency failed: %s" % filepath) self.fail("Idempotency failed: %s" % filepath)