[pypy-commit] pypy set-strategies: merged default into set-strategies

l.diekmann noreply at buildbot.pypy.org
Thu Nov 10 13:50:54 CET 2011


Author: Lukas Diekmann <lukas.diekmann at uni-duesseldorf.de>
Branch: set-strategies
Changeset: r49187:7291b68c48ce
Date: 2011-07-19 12:13 +0200
http://bitbucket.org/pypy/pypy/changeset/7291b68c48ce/

Log:	merged default into set-strategies

diff too long, truncating to 10000 out of 130446 lines

diff --git a/.hgignore b/.hgignore
--- a/.hgignore
+++ b/.hgignore
@@ -1,6 +1,7 @@
 syntax: glob
 *.py[co]
 *~
+.*.swp
 
 syntax: regexp
 ^testresult$
@@ -17,12 +18,15 @@
 ^pypy/module/cpyext/test/.+\.manifest$
 ^pypy/module/test_lib_pypy/ctypes_tests/.+\.o$
 ^pypy/doc/.+\.html$
+^pypy/doc/config/.+\.rst$
 ^pypy/doc/basicblock\.asc$
 ^pypy/doc/.+\.svninfo$
 ^pypy/translator/c/src/libffi_msvc/.+\.obj$
 ^pypy/translator/c/src/libffi_msvc/.+\.dll$
 ^pypy/translator/c/src/libffi_msvc/.+\.lib$
 ^pypy/translator/c/src/libffi_msvc/.+\.exp$
+^pypy/translator/c/src/cjkcodecs/.+\.o$
+^pypy/translator/c/src/cjkcodecs/.+\.obj$
 ^pypy/translator/jvm/\.project$
 ^pypy/translator/jvm/\.classpath$
 ^pypy/translator/jvm/eclipse-bin$
@@ -35,6 +39,8 @@
 ^pypy/translator/benchmark/shootout_benchmarks$
 ^pypy/translator/goal/pypy-translation-snapshot$
 ^pypy/translator/goal/pypy-c
+^pypy/translator/goal/pypy-jvm
+^pypy/translator/goal/pypy-jvm.jar
 ^pypy/translator/goal/.+\.exe$
 ^pypy/translator/goal/.+\.dll$
 ^pypy/translator/goal/target.+-c$
@@ -61,6 +67,7 @@
 ^pypy/doc/image/lattice3\.png$
 ^pypy/doc/image/stackless_informal\.png$
 ^pypy/doc/image/parsing_example.+\.png$
+^pypy/module/test_lib_pypy/ctypes_tests/_ctypes_test\.o$
 ^compiled
 ^.git/
 ^release/
diff --git a/.hgtags b/.hgtags
new file mode 100644
--- /dev/null
+++ b/.hgtags
@@ -0,0 +1,1 @@
+b590cf6de4190623aad9aa698694c22e614d67b9 release-1.5
diff --git a/LICENSE b/LICENSE
--- a/LICENSE
+++ b/LICENSE
@@ -37,78 +37,155 @@
     Armin Rigo
     Maciej Fijalkowski
     Carl Friedrich Bolz
+    Amaury Forgeot d'Arc
+    Antonio Cuni
     Samuele Pedroni
-    Antonio Cuni
     Michael Hudson
+    Holger Krekel
     Christian Tismer
-    Holger Krekel
+    Benjamin Peterson
     Eric van Riet Paap
+    Anders Chrigstr&#246;m
+    H&#229;kan Ard&#246;
     Richard Emslie
-    Anders Chrigstrom
-    Amaury Forgeot d Arc
-    Aurelien Campeas
+    Dan Villiom Podlaski Christiansen
+    Alexander Schremmer
+    Alex Gaynor
+    David Schneider
+    Aureli&#233;n Campeas
     Anders Lehmann
+    Camillo Bruni
     Niklaus Haldimann
+    Leonardo Santagada
+    Toon Verwaest
     Seo Sanghyeon
-    Leonardo Santagada
     Lawrence Oluyede
+    Bartosz Skowron
     Jakub Gustak
     Guido Wesdorp
-    Benjamin Peterson
-    Alexander Schremmer
+    Adrien Di Mascio
+    Laura Creighton
+    Ludovic Aubry
     Niko Matsakis
-    Ludovic Aubry
+    Daniel Roberts
+    Jason Creighton
+    Jacob Hall&#233;n
     Alex Martelli
-    Toon Verwaest
+    Anders Hammarquist
+    Jan de Mooij
     Stephan Diehl
-    Adrien Di Mascio
+    Michael Foord
     Stefan Schwarzer
     Tomek Meka
     Patrick Maupin
-    Jacob Hallen
-    Laura Creighton
     Bob Ippolito
-    Camillo Bruni
-    Simon Burton
     Bruno Gola
     Alexandre Fayolle
     Marius Gedminas
+    Simon Burton
+    Jean-Paul Calderone
+    John Witulski
+    Wim Lavrijsen
+    Andreas St&#252;hrk
+    Jean-Philippe St. Pierre
     Guido van Rossum
+    Pavel Vinogradov
     Valentino Volonghi
+    Paul deGrandis
     Adrian Kuhn
-    Paul deGrandis
+    tav
+    Georg Brandl
     Gerald Klix
     Wanja Saatkamp
-    Anders Hammarquist
+    Boris Feigin
     Oscar Nierstrasz
+    Dario Bertini
+    David Malcolm
     Eugene Oden
+    Henry Mason
     Lukas Renggli
     Guenter Jantzen
+    Ronny Pfannschmidt
+    Bert Freudenberg
+    Amit Regmi
+    Ben Young
+    Nicolas Chauvat
+    Andrew Durdin
+    Michael Schneider
+    Nicholas Riley
+    Rocco Moretti
+    Gintautas Miliauskas
+    Michael Twomey
+    Igor Trindade Oliveira
+    Lucian Branescu Mihaila
+    Olivier Dormond
+    Jared Grubb
+    Karl Bartel
+    Gabriel Lavoie
+    Brian Dorsey
+    Victor Stinner
+    Stuart Williams
+    Toby Watson
+    Antoine Pitrou
+    Justas Sadzevicius
+    Neil Shepperd
+    Mikael Sch&#246;nenberg
+    Gasper Zejn
+    Jonathan David Riehl
+    Elmo M&#228;ntynen
+    Anders Qvist
+    Beatrice D&#252;ring
+    Alexander Sedov
+    Vincent Legoll
+    Alan McIntyre
+    Romain Guillebert
+    Alex Perry
+    Jens-Uwe Mager
+    Dan Stromberg
+    Lukas Diekmann
+    Carl Meyer
+    Pieter Zieschang
+    Alejandro J. Cura
+    Sylvain Thenault
+    Travis Francis Athougies
+    Henrik Vendelbo
+    Lutz Paelike
+    Jacob Oscarson
+    Martin Blais
+    Lucio Torre
+    Lene Wagner
+    Miguel de Val Borro
+    Ignas Mikalajunas
+    Artur Lisiecki
+    Joshua Gilbert
+    Godefroid Chappelle
+    Yusei Tahara
+    Christopher Armstrong
+    Stephan Busemann
+    Gustavo Niemeyer
+    William Leslie
+    Akira Li
+    Kristj&#225;n Valur J&#243;nsson
+    Bobby Impollonia
+    Andrew Thompson
+    Anders Sigfridsson
+    Jacek Generowicz
+    Dan Colish
+    Sven Hager
+    Zooko Wilcox-O Hearn
+    Anders Hammarquist
     Dinu Gherman
-    Bartosz Skowron
-    Georg Brandl
-    Ben Young
-    Jean-Paul Calderone
-    Nicolas Chauvat
-    Rocco Moretti
-    Michael Twomey
-    boria
-    Jared Grubb
-    Olivier Dormond
-    Stuart Williams
-    Jens-Uwe Mager
-    Justas Sadzevicius
-    Mikael Sch&#246;nenberg
-    Brian Dorsey
-    Jonathan David Riehl
-    Beatrice During
-    Elmo M&#228;ntynen
-    Andreas Friedge
-    Alex Gaynor
-    Anders Qvist
-    Alan McIntyre
-    Bert Freudenberg
-    Tav
+    Dan Colish
+    Daniel Neuh&#228;user
+    Michael Chermside
+    Konrad Delong
+    Anna Ravencroft
+    Greg Price
+    Armin Ronacher
+    Jim Baker
+    Philip Jenvey
+    Rodrigo Ara&#250;jo
+    Brett Cannon
 
     Heinrich-Heine University, Germany 
     Open End AB (formerly AB Strakt), Sweden
diff --git a/README b/README
--- a/README
+++ b/README
@@ -15,10 +15,10 @@
 
 The getting-started document will help guide you:
 
-    http://codespeak.net/pypy/dist/pypy/doc/getting-started.html
+    http://doc.pypy.org/en/latest/getting-started.html
 
 It will also point you to the rest of the documentation which is generated
 from files in the pypy/doc directory within the source repositories. Enjoy
 and send us feedback!
 
-    the pypy-dev team <pypy-dev at codespeak.net>
+    the pypy-dev team <pypy-dev at python.org>
diff --git a/_pytest/__init__.py b/_pytest/__init__.py
--- a/_pytest/__init__.py
+++ b/_pytest/__init__.py
@@ -1,2 +1,2 @@
 #
-__version__ = '2.0.3.dev3'
+__version__ = '2.1.0.dev4'
diff --git a/_pytest/assertion.py b/_pytest/assertion.py
deleted file mode 100644
--- a/_pytest/assertion.py
+++ /dev/null
@@ -1,179 +0,0 @@
-"""
-support for presented detailed information in failing assertions.
-"""
-import py
-import sys
-from _pytest.monkeypatch import monkeypatch
-
-def pytest_addoption(parser):
-    group = parser.getgroup("debugconfig")
-    group._addoption('--no-assert', action="store_true", default=False,
-        dest="noassert",
-        help="disable python assert expression reinterpretation."),
-
-def pytest_configure(config):
-    # The _reprcompare attribute on the py.code module is used by
-    # py._code._assertionnew to detect this plugin was loaded and in
-    # turn call the hooks defined here as part of the
-    # DebugInterpreter.
-    config._monkeypatch = m = monkeypatch()
-    warn_about_missing_assertion()
-    if not config.getvalue("noassert") and not config.getvalue("nomagic"):
-        def callbinrepr(op, left, right):
-            hook_result = config.hook.pytest_assertrepr_compare(
-                config=config, op=op, left=left, right=right)
-            for new_expl in hook_result:
-                if new_expl:
-                    return '\n~'.join(new_expl)
-        m.setattr(py.builtin.builtins,
-                  'AssertionError', py.code._AssertionError)
-        m.setattr(py.code, '_reprcompare', callbinrepr)
-
-def pytest_unconfigure(config):
-    config._monkeypatch.undo()
-
-def warn_about_missing_assertion():
-    try:
-        assert False
-    except AssertionError:
-        pass
-    else:
-        sys.stderr.write("WARNING: failing tests may report as passing because "
-        "assertions are turned off!  (are you using python -O?)\n")
-
-# Provide basestring in python3
-try:
-    basestring = basestring
-except NameError:
-    basestring = str
-
-
-def pytest_assertrepr_compare(op, left, right):
-    """return specialised explanations for some operators/operands"""
-    width = 80 - 15 - len(op) - 2 # 15 chars indentation, 1 space around op
-    left_repr = py.io.saferepr(left, maxsize=int(width/2))
-    right_repr = py.io.saferepr(right, maxsize=width-len(left_repr))
-    summary = '%s %s %s' % (left_repr, op, right_repr)
-
-    issequence = lambda x: isinstance(x, (list, tuple))
-    istext = lambda x: isinstance(x, basestring)
-    isdict = lambda x: isinstance(x, dict)
-    isset = lambda x: isinstance(x, set)
-
-    explanation = None
-    try:
-        if op == '==':
-            if istext(left) and istext(right):
-                explanation = _diff_text(left, right)
-            elif issequence(left) and issequence(right):
-                explanation = _compare_eq_sequence(left, right)
-            elif isset(left) and isset(right):
-                explanation = _compare_eq_set(left, right)
-            elif isdict(left) and isdict(right):
-                explanation = _diff_text(py.std.pprint.pformat(left),
-                                         py.std.pprint.pformat(right))
-        elif op == 'not in':
-            if istext(left) and istext(right):
-                explanation = _notin_text(left, right)
-    except py.builtin._sysex:
-        raise
-    except:
-        excinfo = py.code.ExceptionInfo()
-        explanation = ['(pytest_assertion plugin: representation of '
-            'details failed. Probably an object has a faulty __repr__.)',
-            str(excinfo)
-            ]
-
-
-    if not explanation:
-        return None
-
-    # Don't include pageloads of data, should be configurable
-    if len(''.join(explanation)) > 80*8:
-        explanation = ['Detailed information too verbose, truncated']
-
-    return [summary] + explanation
-
-
-def _diff_text(left, right):
-    """Return the explanation for the diff between text
-
-    This will skip leading and trailing characters which are
-    identical to keep the diff minimal.
-    """
-    explanation = []
-    i = 0 # just in case left or right has zero length
-    for i in range(min(len(left), len(right))):
-        if left[i] != right[i]:
-            break
-    if i > 42:
-        i -= 10                 # Provide some context
-        explanation = ['Skipping %s identical '
-                       'leading characters in diff' % i]
-        left = left[i:]
-        right = right[i:]
-    if len(left) == len(right):
-        for i in range(len(left)):
-            if left[-i] != right[-i]:
-                break
-        if i > 42:
-            i -= 10     # Provide some context
-            explanation += ['Skipping %s identical '
-                            'trailing characters in diff' % i]
-            left = left[:-i]
-            right = right[:-i]
-    explanation += [line.strip('\n')
-                    for line in py.std.difflib.ndiff(left.splitlines(),
-                                                     right.splitlines())]
-    return explanation
-
-
-def _compare_eq_sequence(left, right):
-    explanation = []
-    for i in range(min(len(left), len(right))):
-        if left[i] != right[i]:
-            explanation += ['At index %s diff: %r != %r' %
-                            (i, left[i], right[i])]
-            break
-    if len(left) > len(right):
-        explanation += ['Left contains more items, '
-            'first extra item: %s' % py.io.saferepr(left[len(right)],)]
-    elif len(left) < len(right):
-        explanation += ['Right contains more items, '
-            'first extra item: %s' % py.io.saferepr(right[len(left)],)]
-    return explanation # + _diff_text(py.std.pprint.pformat(left),
-                       #             py.std.pprint.pformat(right))
-
-
-def _compare_eq_set(left, right):
-    explanation = []
-    diff_left = left - right
-    diff_right = right - left
-    if diff_left:
-        explanation.append('Extra items in the left set:')
-        for item in diff_left:
-            explanation.append(py.io.saferepr(item))
-    if diff_right:
-        explanation.append('Extra items in the right set:')
-        for item in diff_right:
-            explanation.append(py.io.saferepr(item))
-    return explanation
-
-
-def _notin_text(term, text):
-    index = text.find(term)
-    head = text[:index]
-    tail = text[index+len(term):]
-    correct_text = head + tail
-    diff = _diff_text(correct_text, text)
-    newdiff = ['%s is contained here:' % py.io.saferepr(term, maxsize=42)]
-    for line in diff:
-        if line.startswith('Skipping'):
-            continue
-        if line.startswith('- '):
-            continue
-        if line.startswith('+ '):
-            newdiff.append('  ' + line[2:])
-        else:
-            newdiff.append(line)
-    return newdiff
diff --git a/_pytest/assertion/__init__.py b/_pytest/assertion/__init__.py
new file mode 100644
--- /dev/null
+++ b/_pytest/assertion/__init__.py
@@ -0,0 +1,128 @@
+"""
+support for presenting detailed information in failing assertions.
+"""
+import py
+import imp
+import marshal
+import struct
+import sys
+import pytest
+from _pytest.monkeypatch import monkeypatch
+from _pytest.assertion import reinterpret, util
+
+try:
+    from _pytest.assertion.rewrite import rewrite_asserts
+except ImportError:
+    rewrite_asserts = None
+else:
+    import ast
+
+def pytest_addoption(parser):
+    group = parser.getgroup("debugconfig")
+    group.addoption('--assertmode', action="store", dest="assertmode",
+                    choices=("on", "old", "off", "default"), default="default",
+                    metavar="on|old|off",
+                    help="""control assertion debugging tools.
+'off' performs no assertion debugging.
+'old' reinterprets the expressions in asserts to glean information.
+'on' (the default) rewrites the assert statements in test modules to provide
+sub-expression results.""")
+    group.addoption('--no-assert', action="store_true", default=False,
+        dest="noassert", help="DEPRECATED equivalent to --assertmode=off")
+    group.addoption('--nomagic', action="store_true", default=False,
+        dest="nomagic", help="DEPRECATED equivalent to --assertmode=off")
+
+class AssertionState:
+    """State for the assertion plugin."""
+
+    def __init__(self, config, mode):
+        self.mode = mode
+        self.trace = config.trace.root.get("assertion")
+
+def pytest_configure(config):
+    warn_about_missing_assertion()
+    mode = config.getvalue("assertmode")
+    if config.getvalue("noassert") or config.getvalue("nomagic"):
+        if mode not in ("off", "default"):
+            raise pytest.UsageError("assertion options conflict")
+        mode = "off"
+    elif mode == "default":
+        mode = "on"
+    if mode != "off":
+        def callbinrepr(op, left, right):
+            hook_result = config.hook.pytest_assertrepr_compare(
+                config=config, op=op, left=left, right=right)
+            for new_expl in hook_result:
+                if new_expl:
+                    return '\n~'.join(new_expl)
+        m = monkeypatch()
+        config._cleanup.append(m.undo)
+        m.setattr(py.builtin.builtins, 'AssertionError',
+                  reinterpret.AssertionError)
+        m.setattr(util, '_reprcompare', callbinrepr)
+    if mode == "on" and rewrite_asserts is None:
+        mode = "old"
+    config._assertstate = AssertionState(config, mode)
+    config._assertstate.trace("configured with mode set to %r" % (mode,))
+
+def _write_pyc(co, source_path):
+    if hasattr(imp, "cache_from_source"):
+        # Handle PEP 3147 pycs.
+        pyc = py.path.local(imp.cache_from_source(str(source_path)))
+        pyc.ensure()
+    else:
+        pyc = source_path + "c"
+    mtime = int(source_path.mtime())
+    fp = pyc.open("wb")
+    try:
+        fp.write(imp.get_magic())
+        fp.write(struct.pack("<l", mtime))
+        marshal.dump(co, fp)
+    finally:
+        fp.close()
+    return pyc
+
+def before_module_import(mod):
+    if mod.config._assertstate.mode != "on":
+        return
+    # Some deep magic: load the source, rewrite the asserts, and write a
+    # fake pyc, so that it'll be loaded when the module is imported.
+    source = mod.fspath.read()
+    try:
+        tree = ast.parse(source)
+    except SyntaxError:
+        # Let this pop up again in the real import.
+        mod.config._assertstate.trace("failed to parse: %r" % (mod.fspath,))
+        return
+    rewrite_asserts(tree)
+    try:
+        co = compile(tree, str(mod.fspath), "exec")
+    except SyntaxError:
+        # It's possible that this error is from some bug in the assertion
+        # rewriting, but I don't know of a fast way to tell.
+        mod.config._assertstate.trace("failed to compile: %r" % (mod.fspath,))
+        return
+    mod._pyc = _write_pyc(co, mod.fspath)
+    mod.config._assertstate.trace("wrote pyc: %r" % (mod._pyc,))
+
+def after_module_import(mod):
+    if not hasattr(mod, "_pyc"):
+        return
+    state = mod.config._assertstate
+    try:
+        mod._pyc.remove()
+    except py.error.ENOENT:
+        state.trace("couldn't find pyc: %r" % (mod._pyc,))
+    else:
+        state.trace("removed pyc: %r" % (mod._pyc,))
+
+def warn_about_missing_assertion():
+    try:
+        assert False
+    except AssertionError:
+        pass
+    else:
+        sys.stderr.write("WARNING: failing tests may report as passing because "
+        "assertions are turned off!  (are you using python -O?)\n")
+
+pytest_assertrepr_compare = util.assertrepr_compare
diff --git a/_pytest/assertion/newinterpret.py b/_pytest/assertion/newinterpret.py
new file mode 100644
--- /dev/null
+++ b/_pytest/assertion/newinterpret.py
@@ -0,0 +1,333 @@
+"""
+Find intermediate evalutation results in assert statements through builtin AST.
+This should replace oldinterpret.py eventually.
+"""
+
+import sys
+import ast
+
+import py
+from _pytest.assertion import util
+from _pytest.assertion.reinterpret import BuiltinAssertionError
+
+
+if sys.platform.startswith("java") and sys.version_info < (2, 5, 2):
+    # See http://bugs.jython.org/issue1497
+    _exprs = ("BoolOp", "BinOp", "UnaryOp", "Lambda", "IfExp", "Dict",
+              "ListComp", "GeneratorExp", "Yield", "Compare", "Call",
+              "Repr", "Num", "Str", "Attribute", "Subscript", "Name",
+              "List", "Tuple")
+    _stmts = ("FunctionDef", "ClassDef", "Return", "Delete", "Assign",
+              "AugAssign", "Print", "For", "While", "If", "With", "Raise",
+              "TryExcept", "TryFinally", "Assert", "Import", "ImportFrom",
+              "Exec", "Global", "Expr", "Pass", "Break", "Continue")
+    _expr_nodes = set(getattr(ast, name) for name in _exprs)
+    _stmt_nodes = set(getattr(ast, name) for name in _stmts)
+    def _is_ast_expr(node):
+        return node.__class__ in _expr_nodes
+    def _is_ast_stmt(node):
+        return node.__class__ in _stmt_nodes
+else:
+    def _is_ast_expr(node):
+        return isinstance(node, ast.expr)
+    def _is_ast_stmt(node):
+        return isinstance(node, ast.stmt)
+
+
+class Failure(Exception):
+    """Error found while interpreting AST."""
+
+    def __init__(self, explanation=""):
+        self.cause = sys.exc_info()
+        self.explanation = explanation
+
+
+def interpret(source, frame, should_fail=False):
+    mod = ast.parse(source)
+    visitor = DebugInterpreter(frame)
+    try:
+        visitor.visit(mod)
+    except Failure:
+        failure = sys.exc_info()[1]
+        return getfailure(failure)
+    if should_fail:
+        return ("(assertion failed, but when it was re-run for "
+                "printing intermediate values, it did not fail.  Suggestions: "
+                "compute assert expression before the assert or use --no-assert)")
+
+def run(offending_line, frame=None):
+    if frame is None:
+        frame = py.code.Frame(sys._getframe(1))
+    return interpret(offending_line, frame)
+
+def getfailure(e):
+    explanation = util.format_explanation(e.explanation)
+    value = e.cause[1]
+    if str(value):
+        lines = explanation.split('\n')
+        lines[0] += "  << %s" % (value,)
+        explanation = '\n'.join(lines)
+    text = "%s: %s" % (e.cause[0].__name__, explanation)
+    if text.startswith('AssertionError: assert '):
+        text = text[16:]
+    return text
+
+operator_map = {
+    ast.BitOr : "|",
+    ast.BitXor : "^",
+    ast.BitAnd : "&",
+    ast.LShift : "<<",
+    ast.RShift : ">>",
+    ast.Add : "+",
+    ast.Sub : "-",
+    ast.Mult : "*",
+    ast.Div : "/",
+    ast.FloorDiv : "//",
+    ast.Mod : "%",
+    ast.Eq : "==",
+    ast.NotEq : "!=",
+    ast.Lt : "<",
+    ast.LtE : "<=",
+    ast.Gt : ">",
+    ast.GtE : ">=",
+    ast.Pow : "**",
+    ast.Is : "is",
+    ast.IsNot : "is not",
+    ast.In : "in",
+    ast.NotIn : "not in"
+}
+
+unary_map = {
+    ast.Not : "not %s",
+    ast.Invert : "~%s",
+    ast.USub : "-%s",
+    ast.UAdd : "+%s"
+}
+
+
+class DebugInterpreter(ast.NodeVisitor):
+    """Interpret AST nodes to gleam useful debugging information. """
+
+    def __init__(self, frame):
+        self.frame = frame
+
+    def generic_visit(self, node):
+        # Fallback when we don't have a special implementation.
+        if _is_ast_expr(node):
+            mod = ast.Expression(node)
+            co = self._compile(mod)
+            try:
+                result = self.frame.eval(co)
+            except Exception:
+                raise Failure()
+            explanation = self.frame.repr(result)
+            return explanation, result
+        elif _is_ast_stmt(node):
+            mod = ast.Module([node])
+            co = self._compile(mod, "exec")
+            try:
+                self.frame.exec_(co)
+            except Exception:
+                raise Failure()
+            return None, None
+        else:
+            raise AssertionError("can't handle %s" %(node,))
+
+    def _compile(self, source, mode="eval"):
+        return compile(source, "<assertion interpretation>", mode)
+
+    def visit_Expr(self, expr):
+        return self.visit(expr.value)
+
+    def visit_Module(self, mod):
+        for stmt in mod.body:
+            self.visit(stmt)
+
+    def visit_Name(self, name):
+        explanation, result = self.generic_visit(name)
+        # See if the name is local.
+        source = "%r in locals() is not globals()" % (name.id,)
+        co = self._compile(source)
+        try:
+            local = self.frame.eval(co)
+        except Exception:
+            # have to assume it isn't
+            local = None
+        if local is None or not self.frame.is_true(local):
+            return name.id, result
+        return explanation, result
+
+    def visit_Compare(self, comp):
+        left = comp.left
+        left_explanation, left_result = self.visit(left)
+        for op, next_op in zip(comp.ops, comp.comparators):
+            next_explanation, next_result = self.visit(next_op)
+            op_symbol = operator_map[op.__class__]
+            explanation = "%s %s %s" % (left_explanation, op_symbol,
+                                        next_explanation)
+            source = "__exprinfo_left %s __exprinfo_right" % (op_symbol,)
+            co = self._compile(source)
+            try:
+                result = self.frame.eval(co, __exprinfo_left=left_result,
+                                         __exprinfo_right=next_result)
+            except Exception:
+                raise Failure(explanation)
+            try:
+                if not self.frame.is_true(result):
+                    break
+            except KeyboardInterrupt:
+                raise
+            except:
+                break
+            left_explanation, left_result = next_explanation, next_result
+
+        if util._reprcompare is not None:
+            res = util._reprcompare(op_symbol, left_result, next_result)
+            if res:
+                explanation = res
+        return explanation, result
+
+    def visit_BoolOp(self, boolop):
+        is_or = isinstance(boolop.op, ast.Or)
+        explanations = []
+        for operand in boolop.values:
+            explanation, result = self.visit(operand)
+            explanations.append(explanation)
+            if result == is_or:
+                break
+        name = is_or and " or " or " and "
+        explanation = "(" + name.join(explanations) + ")"
+        return explanation, result
+
+    def visit_UnaryOp(self, unary):
+        pattern = unary_map[unary.op.__class__]
+        operand_explanation, operand_result = self.visit(unary.operand)
+        explanation = pattern % (operand_explanation,)
+        co = self._compile(pattern % ("__exprinfo_expr",))
+        try:
+            result = self.frame.eval(co, __exprinfo_expr=operand_result)
+        except Exception:
+            raise Failure(explanation)
+        return explanation, result
+
+    def visit_BinOp(self, binop):
+        left_explanation, left_result = self.visit(binop.left)
+        right_explanation, right_result = self.visit(binop.right)
+        symbol = operator_map[binop.op.__class__]
+        explanation = "(%s %s %s)" % (left_explanation, symbol,
+                                      right_explanation)
+        source = "__exprinfo_left %s __exprinfo_right" % (symbol,)
+        co = self._compile(source)
+        try:
+            result = self.frame.eval(co, __exprinfo_left=left_result,
+                                     __exprinfo_right=right_result)
+        except Exception:
+            raise Failure(explanation)
+        return explanation, result
+
+    def visit_Call(self, call):
+        func_explanation, func = self.visit(call.func)
+        arg_explanations = []
+        ns = {"__exprinfo_func" : func}
+        arguments = []
+        for arg in call.args:
+            arg_explanation, arg_result = self.visit(arg)
+            arg_name = "__exprinfo_%s" % (len(ns),)
+            ns[arg_name] = arg_result
+            arguments.append(arg_name)
+            arg_explanations.append(arg_explanation)
+        for keyword in call.keywords:
+            arg_explanation, arg_result = self.visit(keyword.value)
+            arg_name = "__exprinfo_%s" % (len(ns),)
+            ns[arg_name] = arg_result
+            keyword_source = "%s=%%s" % (keyword.arg)
+            arguments.append(keyword_source % (arg_name,))
+            arg_explanations.append(keyword_source % (arg_explanation,))
+        if call.starargs:
+            arg_explanation, arg_result = self.visit(call.starargs)
+            arg_name = "__exprinfo_star"
+            ns[arg_name] = arg_result
+            arguments.append("*%s" % (arg_name,))
+            arg_explanations.append("*%s" % (arg_explanation,))
+        if call.kwargs:
+            arg_explanation, arg_result = self.visit(call.kwargs)
+            arg_name = "__exprinfo_kwds"
+            ns[arg_name] = arg_result
+            arguments.append("**%s" % (arg_name,))
+            arg_explanations.append("**%s" % (arg_explanation,))
+        args_explained = ", ".join(arg_explanations)
+        explanation = "%s(%s)" % (func_explanation, args_explained)
+        args = ", ".join(arguments)
+        source = "__exprinfo_func(%s)" % (args,)
+        co = self._compile(source)
+        try:
+            result = self.frame.eval(co, **ns)
+        except Exception:
+            raise Failure(explanation)
+        pattern = "%s\n{%s = %s\n}"
+        rep = self.frame.repr(result)
+        explanation = pattern % (rep, rep, explanation)
+        return explanation, result
+
+    def _is_builtin_name(self, name):
+        pattern = "%r not in globals() and %r not in locals()"
+        source = pattern % (name.id, name.id)
+        co = self._compile(source)
+        try:
+            return self.frame.eval(co)
+        except Exception:
+            return False
+
+    def visit_Attribute(self, attr):
+        if not isinstance(attr.ctx, ast.Load):
+            return self.generic_visit(attr)
+        source_explanation, source_result = self.visit(attr.value)
+        explanation = "%s.%s" % (source_explanation, attr.attr)
+        source = "__exprinfo_expr.%s" % (attr.attr,)
+        co = self._compile(source)
+        try:
+            result = self.frame.eval(co, __exprinfo_expr=source_result)
+        except Exception:
+            raise Failure(explanation)
+        explanation = "%s\n{%s = %s.%s\n}" % (self.frame.repr(result),
+                                              self.frame.repr(result),
+                                              source_explanation, attr.attr)
+        # Check if the attr is from an instance.
+        source = "%r in getattr(__exprinfo_expr, '__dict__', {})"
+        source = source % (attr.attr,)
+        co = self._compile(source)
+        try:
+            from_instance = self.frame.eval(co, __exprinfo_expr=source_result)
+        except Exception:
+            from_instance = None
+        if from_instance is None or self.frame.is_true(from_instance):
+            rep = self.frame.repr(result)
+            pattern = "%s\n{%s = %s\n}"
+            explanation = pattern % (rep, rep, explanation)
+        return explanation, result
+
+    def visit_Assert(self, assrt):
+        test_explanation, test_result = self.visit(assrt.test)
+        explanation = "assert %s" % (test_explanation,)
+        if not self.frame.is_true(test_result):
+            try:
+                raise BuiltinAssertionError
+            except Exception:
+                raise Failure(explanation)
+        return explanation, test_result
+
+    def visit_Assign(self, assign):
+        value_explanation, value_result = self.visit(assign.value)
+        explanation = "... = %s" % (value_explanation,)
+        name = ast.Name("__exprinfo_expr", ast.Load(),
+                        lineno=assign.value.lineno,
+                        col_offset=assign.value.col_offset)
+        new_assign = ast.Assign(assign.targets, name, lineno=assign.lineno,
+                                col_offset=assign.col_offset)
+        mod = ast.Module([new_assign])
+        co = self._compile(mod, "exec")
+        try:
+            self.frame.exec_(co, __exprinfo_expr=value_result)
+        except Exception:
+            raise Failure(explanation)
+        return explanation, value_result
diff --git a/_pytest/assertion/oldinterpret.py b/_pytest/assertion/oldinterpret.py
new file mode 100644
--- /dev/null
+++ b/_pytest/assertion/oldinterpret.py
@@ -0,0 +1,552 @@
+import py
+import sys, inspect
+from compiler import parse, ast, pycodegen
+from _pytest.assertion.util import format_explanation
+from _pytest.assertion.reinterpret import BuiltinAssertionError
+
+passthroughex = py.builtin._sysex
+
+class Failure:
+    def __init__(self, node):
+        self.exc, self.value, self.tb = sys.exc_info()
+        self.node = node
+
+class View(object):
+    """View base class.
+
+    If C is a subclass of View, then C(x) creates a proxy object around
+    the object x.  The actual class of the proxy is not C in general,
+    but a *subclass* of C determined by the rules below.  To avoid confusion
+    we call view class the class of the proxy (a subclass of C, so of View)
+    and object class the class of x.
+
+    Attributes and methods not found in the proxy are automatically read on x.
+    Other operations like setting attributes are performed on the proxy, as
+    determined by its view class.  The object x is available from the proxy
+    as its __obj__ attribute.
+
+    The view class selection is determined by the __view__ tuples and the
+    optional __viewkey__ method.  By default, the selected view class is the
+    most specific subclass of C whose __view__ mentions the class of x.
+    If no such subclass is found, the search proceeds with the parent
+    object classes.  For example, C(True) will first look for a subclass
+    of C with __view__ = (..., bool, ...) and only if it doesn't find any
+    look for one with __view__ = (..., int, ...), and then ..., object,...
+    If everything fails the class C itself is considered to be the default.
+
+    Alternatively, the view class selection can be driven by another aspect
+    of the object x, instead of the class of x, by overriding __viewkey__.
+    See last example at the end of this module.
+    """
+
+    _viewcache = {}
+    __view__ = ()
+
+    def __new__(rootclass, obj, *args, **kwds):
+        self = object.__new__(rootclass)
+        self.__obj__ = obj
+        self.__rootclass__ = rootclass
+        key = self.__viewkey__()
+        try:
+            self.__class__ = self._viewcache[key]
+        except KeyError:
+            self.__class__ = self._selectsubclass(key)
+        return self
+
+    def __getattr__(self, attr):
+        # attributes not found in the normal hierarchy rooted on View
+        # are looked up in the object's real class
+        return getattr(self.__obj__, attr)
+
+    def __viewkey__(self):
+        return self.__obj__.__class__
+
+    def __matchkey__(self, key, subclasses):
+        if inspect.isclass(key):
+            keys = inspect.getmro(key)
+        else:
+            keys = [key]
+        for key in keys:
+            result = [C for C in subclasses if key in C.__view__]
+            if result:
+                return result
+        return []
+
+    def _selectsubclass(self, key):
+        subclasses = list(enumsubclasses(self.__rootclass__))
+        for C in subclasses:
+            if not isinstance(C.__view__, tuple):
+                C.__view__ = (C.__view__,)
+        choices = self.__matchkey__(key, subclasses)
+        if not choices:
+            return self.__rootclass__
+        elif len(choices) == 1:
+            return choices[0]
+        else:
+            # combine the multiple choices
+            return type('?', tuple(choices), {})
+
+    def __repr__(self):
+        return '%s(%r)' % (self.__rootclass__.__name__, self.__obj__)
+
+
+def enumsubclasses(cls):
+    for subcls in cls.__subclasses__():
+        for subsubclass in enumsubclasses(subcls):
+            yield subsubclass
+    yield cls
+
+
+class Interpretable(View):
+    """A parse tree node with a few extra methods."""
+    explanation = None
+
+    def is_builtin(self, frame):
+        return False
+
+    def eval(self, frame):
+        # fall-back for unknown expression nodes
+        try:
+            expr = ast.Expression(self.__obj__)
+            expr.filename = '<eval>'
+            self.__obj__.filename = '<eval>'
+            co = pycodegen.ExpressionCodeGenerator(expr).getCode()
+            result = frame.eval(co)
+        except passthroughex:
+            raise
+        except:
+            raise Failure(self)
+        self.result = result
+        self.explanation = self.explanation or frame.repr(self.result)
+
+    def run(self, frame):
+        # fall-back for unknown statement nodes
+        try:
+            expr = ast.Module(None, ast.Stmt([self.__obj__]))
+            expr.filename = '<run>'
+            co = pycodegen.ModuleCodeGenerator(expr).getCode()
+            frame.exec_(co)
+        except passthroughex:
+            raise
+        except:
+            raise Failure(self)
+
+    def nice_explanation(self):
+        return format_explanation(self.explanation)
+
+
+class Name(Interpretable):
+    __view__ = ast.Name
+
+    def is_local(self, frame):
+        source = '%r in locals() is not globals()' % self.name
+        try:
+            return frame.is_true(frame.eval(source))
+        except passthroughex:
+            raise
+        except:
+            return False
+
+    def is_global(self, frame):
+        source = '%r in globals()' % self.name
+        try:
+            return frame.is_true(frame.eval(source))
+        except passthroughex:
+            raise
+        except:
+            return False
+
+    def is_builtin(self, frame):
+        source = '%r not in locals() and %r not in globals()' % (
+            self.name, self.name)
+        try:
+            return frame.is_true(frame.eval(source))
+        except passthroughex:
+            raise
+        except:
+            return False
+
+    def eval(self, frame):
+        super(Name, self).eval(frame)
+        if not self.is_local(frame):
+            self.explanation = self.name
+
+class Compare(Interpretable):
+    __view__ = ast.Compare
+
+    def eval(self, frame):
+        expr = Interpretable(self.expr)
+        expr.eval(frame)
+        for operation, expr2 in self.ops:
+            if hasattr(self, 'result'):
+                # shortcutting in chained expressions
+                if not frame.is_true(self.result):
+                    break
+            expr2 = Interpretable(expr2)
+            expr2.eval(frame)
+            self.explanation = "%s %s %s" % (
+                expr.explanation, operation, expr2.explanation)
+            source = "__exprinfo_left %s __exprinfo_right" % operation
+            try:
+                self.result = frame.eval(source,
+                                         __exprinfo_left=expr.result,
+                                         __exprinfo_right=expr2.result)
+            except passthroughex:
+                raise
+            except:
+                raise Failure(self)
+            expr = expr2
+
+class And(Interpretable):
+    __view__ = ast.And
+
+    def eval(self, frame):
+        explanations = []
+        for expr in self.nodes:
+            expr = Interpretable(expr)
+            expr.eval(frame)
+            explanations.append(expr.explanation)
+            self.result = expr.result
+            if not frame.is_true(expr.result):
+                break
+        self.explanation = '(' + ' and '.join(explanations) + ')'
+
+class Or(Interpretable):
+    __view__ = ast.Or
+
+    def eval(self, frame):
+        explanations = []
+        for expr in self.nodes:
+            expr = Interpretable(expr)
+            expr.eval(frame)
+            explanations.append(expr.explanation)
+            self.result = expr.result
+            if frame.is_true(expr.result):
+                break
+        self.explanation = '(' + ' or '.join(explanations) + ')'
+
+
+# == Unary operations ==
+keepalive = []
+for astclass, astpattern in {
+    ast.Not    : 'not __exprinfo_expr',
+    ast.Invert : '(~__exprinfo_expr)',
+    }.items():
+
+    class UnaryArith(Interpretable):
+        __view__ = astclass
+
+        def eval(self, frame, astpattern=astpattern):
+            expr = Interpretable(self.expr)
+            expr.eval(frame)
+            self.explanation = astpattern.replace('__exprinfo_expr',
+                                                  expr.explanation)
+            try:
+                self.result = frame.eval(astpattern,
+                                         __exprinfo_expr=expr.result)
+            except passthroughex:
+                raise
+            except:
+                raise Failure(self)
+
+    keepalive.append(UnaryArith)
+
+# == Binary operations ==
+for astclass, astpattern in {
+    ast.Add    : '(__exprinfo_left + __exprinfo_right)',
+    ast.Sub    : '(__exprinfo_left - __exprinfo_right)',
+    ast.Mul    : '(__exprinfo_left * __exprinfo_right)',
+    ast.Div    : '(__exprinfo_left / __exprinfo_right)',
+    ast.Mod    : '(__exprinfo_left % __exprinfo_right)',
+    ast.Power  : '(__exprinfo_left ** __exprinfo_right)',
+    }.items():
+
+    class BinaryArith(Interpretable):
+        __view__ = astclass
+
+        def eval(self, frame, astpattern=astpattern):
+            left = Interpretable(self.left)
+            left.eval(frame)
+            right = Interpretable(self.right)
+            right.eval(frame)
+            self.explanation = (astpattern
+                                .replace('__exprinfo_left',  left .explanation)
+                                .replace('__exprinfo_right', right.explanation))
+            try:
+                self.result = frame.eval(astpattern,
+                                         __exprinfo_left=left.result,
+                                         __exprinfo_right=right.result)
+            except passthroughex:
+                raise
+            except:
+                raise Failure(self)
+
+    keepalive.append(BinaryArith)
+
+
+class CallFunc(Interpretable):
+    __view__ = ast.CallFunc
+
+    def is_bool(self, frame):
+        source = 'isinstance(__exprinfo_value, bool)'
+        try:
+            return frame.is_true(frame.eval(source,
+                                            __exprinfo_value=self.result))
+        except passthroughex:
+            raise
+        except:
+            return False
+
+    def eval(self, frame):
+        node = Interpretable(self.node)
+        node.eval(frame)
+        explanations = []
+        vars = {'__exprinfo_fn': node.result}
+        source = '__exprinfo_fn('
+        for a in self.args:
+            if isinstance(a, ast.Keyword):
+                keyword = a.name
+                a = a.expr
+            else:
+                keyword = None
+            a = Interpretable(a)
+            a.eval(frame)
+            argname = '__exprinfo_%d' % len(vars)
+            vars[argname] = a.result
+            if keyword is None:
+                source += argname + ','
+                explanations.append(a.explanation)
+            else:
+                source += '%s=%s,' % (keyword, argname)
+                explanations.append('%s=%s' % (keyword, a.explanation))
+        if self.star_args:
+            star_args = Interpretable(self.star_args)
+            star_args.eval(frame)
+            argname = '__exprinfo_star'
+            vars[argname] = star_args.result
+            source += '*' + argname + ','
+            explanations.append('*' + star_args.explanation)
+        if self.dstar_args:
+            dstar_args = Interpretable(self.dstar_args)
+            dstar_args.eval(frame)
+            argname = '__exprinfo_kwds'
+            vars[argname] = dstar_args.result
+            source += '**' + argname + ','
+            explanations.append('**' + dstar_args.explanation)
+        self.explanation = "%s(%s)" % (
+            node.explanation, ', '.join(explanations))
+        if source.endswith(','):
+            source = source[:-1]
+        source += ')'
+        try:
+            self.result = frame.eval(source, **vars)
+        except passthroughex:
+            raise
+        except:
+            raise Failure(self)
+        if not node.is_builtin(frame) or not self.is_bool(frame):
+            r = frame.repr(self.result)
+            self.explanation = '%s\n{%s = %s\n}' % (r, r, self.explanation)
+
+class Getattr(Interpretable):
+    __view__ = ast.Getattr
+
+    def eval(self, frame):
+        expr = Interpretable(self.expr)
+        expr.eval(frame)
+        source = '__exprinfo_expr.%s' % self.attrname
+        try:
+            self.result = frame.eval(source, __exprinfo_expr=expr.result)
+        except passthroughex:
+            raise
+        except:
+            raise Failure(self)
+        self.explanation = '%s.%s' % (expr.explanation, self.attrname)
+        # if the attribute comes from the instance, its value is interesting
+        source = ('hasattr(__exprinfo_expr, "__dict__") and '
+                  '%r in __exprinfo_expr.__dict__' % self.attrname)
+        try:
+            from_instance = frame.is_true(
+                frame.eval(source, __exprinfo_expr=expr.result))
+        except passthroughex:
+            raise
+        except:
+            from_instance = True
+        if from_instance:
+            r = frame.repr(self.result)
+            self.explanation = '%s\n{%s = %s\n}' % (r, r, self.explanation)
+
+# == Re-interpretation of full statements ==
+
+class Assert(Interpretable):
+    __view__ = ast.Assert
+
+    def run(self, frame):
+        test = Interpretable(self.test)
+        test.eval(frame)
+        # print the result as  'assert <explanation>'
+        self.result = test.result
+        self.explanation = 'assert ' + test.explanation
+        if not frame.is_true(test.result):
+            try:
+                raise BuiltinAssertionError
+            except passthroughex:
+                raise
+            except:
+                raise Failure(self)
+
+class Assign(Interpretable):
+    __view__ = ast.Assign
+
+    def run(self, frame):
+        expr = Interpretable(self.expr)
+        expr.eval(frame)
+        self.result = expr.result
+        self.explanation = '... = ' + expr.explanation
+        # fall-back-run the rest of the assignment
+        ass = ast.Assign(self.nodes, ast.Name('__exprinfo_expr'))
+        mod = ast.Module(None, ast.Stmt([ass]))
+        mod.filename = '<run>'
+        co = pycodegen.ModuleCodeGenerator(mod).getCode()
+        try:
+            frame.exec_(co, __exprinfo_expr=expr.result)
+        except passthroughex:
+            raise
+        except:
+            raise Failure(self)
+
+class Discard(Interpretable):
+    __view__ = ast.Discard
+
+    def run(self, frame):
+        expr = Interpretable(self.expr)
+        expr.eval(frame)
+        self.result = expr.result
+        self.explanation = expr.explanation
+
+class Stmt(Interpretable):
+    __view__ = ast.Stmt
+
+    def run(self, frame):
+        for stmt in self.nodes:
+            stmt = Interpretable(stmt)
+            stmt.run(frame)
+
+
+def report_failure(e):
+    explanation = e.node.nice_explanation()
+    if explanation:
+        explanation = ", in: " + explanation
+    else:
+        explanation = ""
+    sys.stdout.write("%s: %s%s\n" % (e.exc.__name__, e.value, explanation))
+
+def check(s, frame=None):
+    if frame is None:
+        frame = sys._getframe(1)
+        frame = py.code.Frame(frame)
+    expr = parse(s, 'eval')
+    assert isinstance(expr, ast.Expression)
+    node = Interpretable(expr.node)
+    try:
+        node.eval(frame)
+    except passthroughex:
+        raise
+    except Failure:
+        e = sys.exc_info()[1]
+        report_failure(e)
+    else:
+        if not frame.is_true(node.result):
+            sys.stderr.write("assertion failed: %s\n" % node.nice_explanation())
+
+
+###########################################################
+# API / Entry points
+# #########################################################
+
+def interpret(source, frame, should_fail=False):
+    module = Interpretable(parse(source, 'exec').node)
+    #print "got module", module
+    if isinstance(frame, py.std.types.FrameType):
+        frame = py.code.Frame(frame)
+    try:
+        module.run(frame)
+    except Failure:
+        e = sys.exc_info()[1]
+        return getfailure(e)
+    except passthroughex:
+        raise
+    except:
+        import traceback
+        traceback.print_exc()
+    if should_fail:
+        return ("(assertion failed, but when it was re-run for "
+                "printing intermediate values, it did not fail.  Suggestions: "
+                "compute assert expression before the assert or use --nomagic)")
+    else:
+        return None
+
+def getmsg(excinfo):
+    if isinstance(excinfo, tuple):
+        excinfo = py.code.ExceptionInfo(excinfo)
+    #frame, line = gettbline(tb)
+    #frame = py.code.Frame(frame)
+    #return interpret(line, frame)
+
+    tb = excinfo.traceback[-1]
+    source = str(tb.statement).strip()
+    x = interpret(source, tb.frame, should_fail=True)
+    if not isinstance(x, str):
+        raise TypeError("interpret returned non-string %r" % (x,))
+    return x
+
+def getfailure(e):
+    explanation = e.node.nice_explanation()
+    if str(e.value):
+        lines = explanation.split('\n')
+        lines[0] += "  << %s" % (e.value,)
+        explanation = '\n'.join(lines)
+    text = "%s: %s" % (e.exc.__name__, explanation)
+    if text.startswith('AssertionError: assert '):
+        text = text[16:]
+    return text
+
+def run(s, frame=None):
+    if frame is None:
+        frame = sys._getframe(1)
+        frame = py.code.Frame(frame)
+    module = Interpretable(parse(s, 'exec').node)
+    try:
+        module.run(frame)
+    except Failure:
+        e = sys.exc_info()[1]
+        report_failure(e)
+
+
+if __name__ == '__main__':
+    # example:
+    def f():
+        return 5
+    def g():
+        return 3
+    def h(x):
+        return 'never'
+    check("f() * g() == 5")
+    check("not f()")
+    check("not (f() and g() or 0)")
+    check("f() == g()")
+    i = 4
+    check("i == f()")
+    check("len(f()) == 0")
+    check("isinstance(2+3+4, float)")
+
+    run("x = i")
+    check("x == 5")
+
+    run("assert not f(), 'oops'")
+    run("a, b, c = 1, 2")
+    run("a, b, c = f()")
+
+    check("max([f(),g()]) == 4")
+    check("'hello'[g()] == 'h'")
+    run("'guk%d' % h(f())")
diff --git a/_pytest/assertion/reinterpret.py b/_pytest/assertion/reinterpret.py
new file mode 100644
--- /dev/null
+++ b/_pytest/assertion/reinterpret.py
@@ -0,0 +1,48 @@
+import sys
+import py
+
+BuiltinAssertionError = py.builtin.builtins.AssertionError
+
+class AssertionError(BuiltinAssertionError):
+    def __init__(self, *args):
+        BuiltinAssertionError.__init__(self, *args)
+        if args:
+            try:
+                self.msg = str(args[0])
+            except py.builtin._sysex:
+                raise
+            except:
+                self.msg = "<[broken __repr__] %s at %0xd>" %(
+                    args[0].__class__, id(args[0]))
+        else:
+            f = py.code.Frame(sys._getframe(1))
+            try:
+                source = f.code.fullsource
+                if source is not None:
+                    try:
+                        source = source.getstatement(f.lineno, assertion=True)
+                    except IndexError:
+                        source = None
+                    else:
+                        source = str(source.deindent()).strip()
+            except py.error.ENOENT:
+                source = None
+                # this can also occur during reinterpretation, when the
+                # co_filename is set to "<run>".
+            if source:
+                self.msg = reinterpret(source, f, should_fail=True)
+            else:
+                self.msg = "<could not determine information>"
+            if not self.args:
+                self.args = (self.msg,)
+
+if sys.version_info > (3, 0):
+    AssertionError.__module__ = "builtins"
+    reinterpret_old = "old reinterpretation not available for py3"
+else:
+    from _pytest.assertion.oldinterpret import interpret as reinterpret_old
+if sys.version_info >= (2, 6) or (sys.platform.startswith("java")):
+    from _pytest.assertion.newinterpret import interpret as reinterpret
+else:
+    reinterpret = reinterpret_old
+
diff --git a/_pytest/assertion/rewrite.py b/_pytest/assertion/rewrite.py
new file mode 100644
--- /dev/null
+++ b/_pytest/assertion/rewrite.py
@@ -0,0 +1,340 @@
+"""Rewrite assertion AST to produce nice error messages"""
+
+import ast
+import collections
+import itertools
+import sys
+
+import py
+from _pytest.assertion import util
+
+
+def rewrite_asserts(mod):
+    """Rewrite the assert statements in mod."""
+    AssertionRewriter().run(mod)
+
+
+_saferepr = py.io.saferepr
+from _pytest.assertion.util import format_explanation as _format_explanation
+
+def _format_boolop(operands, explanations, is_or):
+    show_explanations = []
+    for operand, expl in zip(operands, explanations):
+        show_explanations.append(expl)
+        if operand == is_or:
+            break
+    return "(" + (is_or and " or " or " and ").join(show_explanations) + ")"
+
+def _call_reprcompare(ops, results, expls, each_obj):
+    for i, res, expl in zip(range(len(ops)), results, expls):
+        try:
+            done = not res
+        except Exception:
+            done = True
+        if done:
+            break
+    if util._reprcompare is not None:
+        custom = util._reprcompare(ops[i], each_obj[i], each_obj[i + 1])
+        if custom is not None:
+            return custom
+    return expl
+
+
+unary_map = {
+    ast.Not : "not %s",
+    ast.Invert : "~%s",
+    ast.USub : "-%s",
+    ast.UAdd : "+%s"
+}
+
+binop_map = {
+    ast.BitOr : "|",
+    ast.BitXor : "^",
+    ast.BitAnd : "&",
+    ast.LShift : "<<",
+    ast.RShift : ">>",
+    ast.Add : "+",
+    ast.Sub : "-",
+    ast.Mult : "*",
+    ast.Div : "/",
+    ast.FloorDiv : "//",
+    ast.Mod : "%",
+    ast.Eq : "==",
+    ast.NotEq : "!=",
+    ast.Lt : "<",
+    ast.LtE : "<=",
+    ast.Gt : ">",
+    ast.GtE : ">=",
+    ast.Pow : "**",
+    ast.Is : "is",
+    ast.IsNot : "is not",
+    ast.In : "in",
+    ast.NotIn : "not in"
+}
+
+
+def set_location(node, lineno, col_offset):
+    """Set node location information recursively."""
+    def _fix(node, lineno, col_offset):
+        if "lineno" in node._attributes:
+            node.lineno = lineno
+        if "col_offset" in node._attributes:
+            node.col_offset = col_offset
+        for child in ast.iter_child_nodes(node):
+            _fix(child, lineno, col_offset)
+    _fix(node, lineno, col_offset)
+    return node
+
+
+class AssertionRewriter(ast.NodeVisitor):
+
+    def run(self, mod):
+        """Find all assert statements in *mod* and rewrite them."""
+        if not mod.body:
+            # Nothing to do.
+            return
+        # Insert some special imports at the top of the module but after any
+        # docstrings and __future__ imports.
+        aliases = [ast.alias(py.builtin.builtins.__name__, "@py_builtins"),
+                   ast.alias("_pytest.assertion.rewrite", "@pytest_ar")]
+        expect_docstring = True
+        pos = 0
+        lineno = 0
+        for item in mod.body:
+            if (expect_docstring and isinstance(item, ast.Expr) and
+                isinstance(item.value, ast.Str)):
+                doc = item.value.s
+                if "PYTEST_DONT_REWRITE" in doc:
+                    # The module has disabled assertion rewriting.
+                    return
+                lineno += len(doc) - 1
+                expect_docstring = False
+            elif (not isinstance(item, ast.ImportFrom) or item.level > 0 and
+                  item.identifier != "__future__"):
+                lineno = item.lineno
+                break
+            pos += 1
+        imports = [ast.Import([alias], lineno=lineno, col_offset=0)
+                   for alias in aliases]
+        mod.body[pos:pos] = imports
+        # Collect asserts.
+        nodes = collections.deque([mod])
+        while nodes:
+            node = nodes.popleft()
+            for name, field in ast.iter_fields(node):
+                if isinstance(field, list):
+                    new = []
+                    for i, child in enumerate(field):
+                        if isinstance(child, ast.Assert):
+                            # Transform assert.
+                            new.extend(self.visit(child))
+                        else:
+                            new.append(child)
+                            if isinstance(child, ast.AST):
+                                nodes.append(child)
+                    setattr(node, name, new)
+                elif (isinstance(field, ast.AST) and
+                      # Don't recurse into expressions as they can't contain
+                      # asserts.
+                      not isinstance(field, ast.expr)):
+                    nodes.append(field)
+
+    def variable(self):
+        """Get a new variable."""
+        # Use a character invalid in python identifiers to avoid clashing.
+        name = "@py_assert" + str(next(self.variable_counter))
+        self.variables.add(name)
+        return name
+
+    def assign(self, expr):
+        """Give *expr* a name."""
+        name = self.variable()
+        self.statements.append(ast.Assign([ast.Name(name, ast.Store())], expr))
+        return ast.Name(name, ast.Load())
+
+    def display(self, expr):
+        """Call py.io.saferepr on the expression."""
+        return self.helper("saferepr", expr)
+
+    def helper(self, name, *args):
+        """Call a helper in this module."""
+        py_name = ast.Name("@pytest_ar", ast.Load())
+        attr = ast.Attribute(py_name, "_" + name, ast.Load())
+        return ast.Call(attr, list(args), [], None, None)
+
+    def builtin(self, name):
+        """Return the builtin called *name*."""
+        builtin_name = ast.Name("@py_builtins", ast.Load())
+        return ast.Attribute(builtin_name, name, ast.Load())
+
+    def explanation_param(self, expr):
+        specifier = "py" + str(next(self.variable_counter))
+        self.explanation_specifiers[specifier] = expr
+        return "%(" + specifier + ")s"
+
+    def push_format_context(self):
+        self.explanation_specifiers = {}
+        self.stack.append(self.explanation_specifiers)
+
+    def pop_format_context(self, expl_expr):
+        current = self.stack.pop()
+        if self.stack:
+            self.explanation_specifiers = self.stack[-1]
+        keys = [ast.Str(key) for key in current.keys()]
+        format_dict = ast.Dict(keys, list(current.values()))
+        form = ast.BinOp(expl_expr, ast.Mod(), format_dict)
+        name = "@py_format" + str(next(self.variable_counter))
+        self.on_failure.append(ast.Assign([ast.Name(name, ast.Store())], form))
+        return ast.Name(name, ast.Load())
+
+    def generic_visit(self, node):
+        """Handle expressions we don't have custom code for."""
+        assert isinstance(node, ast.expr)
+        res = self.assign(node)
+        return res, self.explanation_param(self.display(res))
+
+    def visit_Assert(self, assert_):
+        if assert_.msg:
+            # There's already a message. Don't mess with it.
+            return [assert_]
+        self.statements = []
+        self.variables = set()
+        self.variable_counter = itertools.count()
+        self.stack = []
+        self.on_failure = []
+        self.push_format_context()
+        # Rewrite assert into a bunch of statements.
+        top_condition, explanation = self.visit(assert_.test)
+        # Create failure message.
+        body = self.on_failure
+        negation = ast.UnaryOp(ast.Not(), top_condition)
+        self.statements.append(ast.If(negation, body, []))
+        explanation = "assert " + explanation
+        template = ast.Str(explanation)
+        msg = self.pop_format_context(template)
+        fmt = self.helper("format_explanation", msg)
+        err_name = ast.Name("AssertionError", ast.Load())
+        exc = ast.Call(err_name, [fmt], [], None, None)
+        if sys.version_info[0] >= 3:
+            raise_ = ast.Raise(exc, None)
+        else:
+            raise_ = ast.Raise(exc, None, None)
+        body.append(raise_)
+        # Delete temporary variables.
+        names = [ast.Name(name, ast.Del()) for name in self.variables]
+        if names:
+            delete = ast.Delete(names)
+            self.statements.append(delete)
+        # Fix line numbers.
+        for stmt in self.statements:
+            set_location(stmt, assert_.lineno, assert_.col_offset)
+        return self.statements
+
+    def visit_Name(self, name):
+        # Check if the name is local or not.
+        locs = ast.Call(self.builtin("locals"), [], [], None, None)
+        globs = ast.Call(self.builtin("globals"), [], [], None, None)
+        ops = [ast.In(), ast.IsNot()]
+        test = ast.Compare(ast.Str(name.id), ops, [locs, globs])
+        expr = ast.IfExp(test, self.display(name), ast.Str(name.id))
+        return name, self.explanation_param(expr)
+
+    def visit_BoolOp(self, boolop):
+        operands = []
+        explanations = []
+        self.push_format_context()
+        for operand in boolop.values:
+            res, explanation = self.visit(operand)
+            operands.append(res)
+            explanations.append(explanation)
+        expls = ast.Tuple([ast.Str(expl) for expl in explanations], ast.Load())
+        is_or = ast.Num(isinstance(boolop.op, ast.Or))
+        expl_template = self.helper("format_boolop",
+                                    ast.Tuple(operands, ast.Load()), expls,
+                                    is_or)
+        expl = self.pop_format_context(expl_template)
+        res = self.assign(ast.BoolOp(boolop.op, operands))
+        return res, self.explanation_param(expl)
+
+    def visit_UnaryOp(self, unary):
+        pattern = unary_map[unary.op.__class__]
+        operand_res, operand_expl = self.visit(unary.operand)
+        res = self.assign(ast.UnaryOp(unary.op, operand_res))
+        return res, pattern % (operand_expl,)
+
+    def visit_BinOp(self, binop):
+        symbol = binop_map[binop.op.__class__]
+        left_expr, left_expl = self.visit(binop.left)
+        right_expr, right_expl = self.visit(binop.right)
+        explanation = "(%s %s %s)" % (left_expl, symbol, right_expl)
+        res = self.assign(ast.BinOp(left_expr, binop.op, right_expr))
+        return res, explanation
+
+    def visit_Call(self, call):
+        new_func, func_expl = self.visit(call.func)
+        arg_expls = []
+        new_args = []
+        new_kwargs = []
+        new_star = new_kwarg = None
+        for arg in call.args:
+            res, expl = self.visit(arg)
+            new_args.append(res)
+            arg_expls.append(expl)
+        for keyword in call.keywords:
+            res, expl = self.visit(keyword.value)
+            new_kwargs.append(ast.keyword(keyword.arg, res))
+            arg_expls.append(keyword.arg + "=" + expl)
+        if call.starargs:
+            new_star, expl = self.visit(call.starargs)
+            arg_expls.append("*" + expl)
+        if call.kwargs:
+            new_kwarg, expl = self.visit(call.kwarg)
+            arg_expls.append("**" + expl)
+        expl = "%s(%s)" % (func_expl, ', '.join(arg_expls))
+        new_call = ast.Call(new_func, new_args, new_kwargs, new_star, new_kwarg)
+        res = self.assign(new_call)
+        res_expl = self.explanation_param(self.display(res))
+        outer_expl = "%s\n{%s = %s\n}" % (res_expl, res_expl, expl)
+        return res, outer_expl
+
+    def visit_Attribute(self, attr):
+        if not isinstance(attr.ctx, ast.Load):
+            return self.generic_visit(attr)
+        value, value_expl = self.visit(attr.value)
+        res = self.assign(ast.Attribute(value, attr.attr, ast.Load()))
+        res_expl = self.explanation_param(self.display(res))
+        pat = "%s\n{%s = %s.%s\n}"
+        expl = pat % (res_expl, res_expl, value_expl, attr.attr)
+        return res, expl
+
+    def visit_Compare(self, comp):
+        self.push_format_context()
+        left_res, left_expl = self.visit(comp.left)
+        res_variables = [self.variable() for i in range(len(comp.ops))]
+        load_names = [ast.Name(v, ast.Load()) for v in res_variables]
+        store_names = [ast.Name(v, ast.Store()) for v in res_variables]
+        it = zip(range(len(comp.ops)), comp.ops, comp.comparators)
+        expls = []
+        syms = []
+        results = [left_res]
+        for i, op, next_operand in it:
+            next_res, next_expl = self.visit(next_operand)
+            results.append(next_res)
+            sym = binop_map[op.__class__]
+            syms.append(ast.Str(sym))
+            expl = "%s %s %s" % (left_expl, sym, next_expl)
+            expls.append(ast.Str(expl))
+            res_expr = ast.Compare(left_res, [op], [next_res])
+            self.statements.append(ast.Assign([store_names[i]], res_expr))
+            left_res, left_expl = next_res, next_expl
+        # Use py.code._reprcompare if that's available.
+        expl_call = self.helper("call_reprcompare",
+                                ast.Tuple(syms, ast.Load()),
+                                ast.Tuple(load_names, ast.Load()),
+                                ast.Tuple(expls, ast.Load()),
+                                ast.Tuple(results, ast.Load()))
+        if len(comp.ops) > 1:
+            res = ast.BoolOp(ast.And(), load_names)
+        else:
+            res = load_names[0]
+        return res, self.explanation_param(self.pop_format_context(expl_call))
diff --git a/_pytest/assertion/util.py b/_pytest/assertion/util.py
new file mode 100644
--- /dev/null
+++ b/_pytest/assertion/util.py
@@ -0,0 +1,213 @@
+"""Utilities for assertion debugging"""
+
+import py
+
+
+# The _reprcompare attribute on the util module is used by the new assertion
+# interpretation code and assertion rewriter to detect this plugin was
+# loaded and in turn call the hooks defined here as part of the
+# DebugInterpreter.
+_reprcompare = None
+
+def format_explanation(explanation):
+    """This formats an explanation
+
+    Normally all embedded newlines are escaped, however there are
+    three exceptions: \n{, \n} and \n~.  The first two are intended
+    cover nested explanations, see function and attribute explanations
+    for examples (.visit_Call(), visit_Attribute()).  The last one is
+    for when one explanation needs to span multiple lines, e.g. when
+    displaying diffs.
+    """
+    # simplify 'assert False where False = ...'
+    where = 0
+    while True:
+        start = where = explanation.find("False\n{False = ", where)
+        if where == -1:
+            break
+        level = 0
+        for i, c in enumerate(explanation[start:]):
+            if c == "{":
+                level += 1
+            elif c == "}":
+                level -= 1
+                if not level:
+                    break
+        else:
+            raise AssertionError("unbalanced braces: %r" % (explanation,))
+        end = start + i
+        where = end
+        if explanation[end - 1] == '\n':
+            explanation = (explanation[:start] + explanation[start+15:end-1] +
+                           explanation[end+1:])
+            where -= 17
+    raw_lines = (explanation or '').split('\n')
+    # escape newlines not followed by {, } and ~
+    lines = [raw_lines[0]]
+    for l in raw_lines[1:]:
+        if l.startswith('{') or l.startswith('}') or l.startswith('~'):
+            lines.append(l)
+        else:
+            lines[-1] += '\\n' + l
+
+    result = lines[:1]
+    stack = [0]
+    stackcnt = [0]
+    for line in lines[1:]:
+        if line.startswith('{'):
+            if stackcnt[-1]:
+                s = 'and   '
+            else:
+                s = 'where '
+            stack.append(len(result))
+            stackcnt[-1] += 1
+            stackcnt.append(0)
+            result.append(' +' + '  '*(len(stack)-1) + s + line[1:])
+        elif line.startswith('}'):
+            assert line.startswith('}')
+            stack.pop()
+            stackcnt.pop()
+            result[stack[-1]] += line[1:]
+        else:
+            assert line.startswith('~')
+            result.append('  '*len(stack) + line[1:])
+    assert len(stack) == 1
+    return '\n'.join(result)
+
+
+# Provide basestring in python3
+try:
+    basestring = basestring
+except NameError:
+    basestring = str
+
+
+def assertrepr_compare(op, left, right):
+    """return specialised explanations for some operators/operands"""
+    width = 80 - 15 - len(op) - 2 # 15 chars indentation, 1 space around op
+    left_repr = py.io.saferepr(left, maxsize=int(width/2))
+    right_repr = py.io.saferepr(right, maxsize=width-len(left_repr))
+    summary = '%s %s %s' % (left_repr, op, right_repr)
+
+    issequence = lambda x: isinstance(x, (list, tuple))
+    istext = lambda x: isinstance(x, basestring)
+    isdict = lambda x: isinstance(x, dict)
+    isset = lambda x: isinstance(x, set)
+
+    explanation = None
+    try:
+        if op == '==':
+            if istext(left) and istext(right):
+                explanation = _diff_text(left, right)
+            elif issequence(left) and issequence(right):
+                explanation = _compare_eq_sequence(left, right)
+            elif isset(left) and isset(right):
+                explanation = _compare_eq_set(left, right)
+            elif isdict(left) and isdict(right):
+                explanation = _diff_text(py.std.pprint.pformat(left),
+                                         py.std.pprint.pformat(right))
+        elif op == 'not in':
+            if istext(left) and istext(right):
+                explanation = _notin_text(left, right)
+    except py.builtin._sysex:
+        raise
+    except:
+        excinfo = py.code.ExceptionInfo()
+        explanation = ['(pytest_assertion plugin: representation of '
+            'details failed. Probably an object has a faulty __repr__.)',
+            str(excinfo)
+            ]
+
+
+    if not explanation:
+        return None
+
+    # Don't include pageloads of data, should be configurable
+    if len(''.join(explanation)) > 80*8:
+        explanation = ['Detailed information too verbose, truncated']
+
+    return [summary] + explanation
+
+
+def _diff_text(left, right):
+    """Return the explanation for the diff between text
+
+    This will skip leading and trailing characters which are
+    identical to keep the diff minimal.
+    """
+    explanation = []
+    i = 0 # just in case left or right has zero length
+    for i in range(min(len(left), len(right))):
+        if left[i] != right[i]:
+            break
+    if i > 42:
+        i -= 10                 # Provide some context
+        explanation = ['Skipping %s identical '
+                       'leading characters in diff' % i]
+        left = left[i:]
+        right = right[i:]
+    if len(left) == len(right):
+        for i in range(len(left)):
+            if left[-i] != right[-i]:
+                break
+        if i > 42:
+            i -= 10     # Provide some context
+            explanation += ['Skipping %s identical '
+                            'trailing characters in diff' % i]
+            left = left[:-i]
+            right = right[:-i]
+    explanation += [line.strip('\n')
+                    for line in py.std.difflib.ndiff(left.splitlines(),
+                                                     right.splitlines())]
+    return explanation
+
+
+def _compare_eq_sequence(left, right):
+    explanation = []
+    for i in range(min(len(left), len(right))):
+        if left[i] != right[i]:
+            explanation += ['At index %s diff: %r != %r' %
+                            (i, left[i], right[i])]
+            break
+    if len(left) > len(right):
+        explanation += ['Left contains more items, '
+            'first extra item: %s' % py.io.saferepr(left[len(right)],)]
+    elif len(left) < len(right):
+        explanation += ['Right contains more items, '
+            'first extra item: %s' % py.io.saferepr(right[len(left)],)]
+    return explanation # + _diff_text(py.std.pprint.pformat(left),
+                       #             py.std.pprint.pformat(right))
+
+
+def _compare_eq_set(left, right):
+    explanation = []
+    diff_left = left - right
+    diff_right = right - left
+    if diff_left:
+        explanation.append('Extra items in the left set:')
+        for item in diff_left:
+            explanation.append(py.io.saferepr(item))
+    if diff_right:
+        explanation.append('Extra items in the right set:')
+        for item in diff_right:
+            explanation.append(py.io.saferepr(item))
+    return explanation
+
+
+def _notin_text(term, text):
+    index = text.find(term)
+    head = text[:index]
+    tail = text[index+len(term):]
+    correct_text = head + tail
+    diff = _diff_text(correct_text, text)
+    newdiff = ['%s is contained here:' % py.io.saferepr(term, maxsize=42)]
+    for line in diff:
+        if line.startswith('Skipping'):
+            continue
+        if line.startswith('- '):
+            continue
+        if line.startswith('+ '):
+            newdiff.append('  ' + line[2:])
+        else:
+            newdiff.append(line)
+    return newdiff
diff --git a/_pytest/config.py b/_pytest/config.py
--- a/_pytest/config.py
+++ b/_pytest/config.py
@@ -12,6 +12,10 @@
         config.trace.root.setwriter(sys.stderr.write)
     return config
 
+def pytest_unconfigure(config):
+    for func in config._cleanup:
+        func()
+
 class Parser:
     """ Parser for command line arguments. """
 
@@ -251,7 +255,8 @@
         self._conftest = Conftest(onimport=self._onimportconftest)
         self.hook = self.pluginmanager.hook
         self._inicache = {}
-
+        self._cleanup = []
+    
     @classmethod
     def fromdictargs(cls, option_dict, args):
         """ constructor useable for subprocesses. """
diff --git a/_pytest/core.py b/_pytest/core.py
--- a/_pytest/core.py
+++ b/_pytest/core.py
@@ -265,8 +265,15 @@
         config.hook.pytest_unconfigure(config=config)
         config.pluginmanager.unregister(self)
 
-    def notify_exception(self, excinfo):
-        excrepr = excinfo.getrepr(funcargs=True, showlocals=True)
+    def notify_exception(self, excinfo, option=None):
+        if option and option.fulltrace:
+            style = "long"
+        else:
+            style = "native"
+        excrepr = excinfo.getrepr(funcargs=True,
+            showlocals=getattr(option, 'showlocals', False),
+            style=style,
+        )
         res = self.hook.pytest_internalerror(excrepr=excrepr)
         if not py.builtin.any(res):
             for line in str(excrepr).split("\n"):
diff --git a/_pytest/doctest.py b/_pytest/doctest.py
--- a/_pytest/doctest.py
+++ b/_pytest/doctest.py
@@ -59,7 +59,7 @@
                 inner_excinfo = py.code.ExceptionInfo(excinfo.value.exc_info)
                 lines += ["UNEXPECTED EXCEPTION: %s" %
                             repr(inner_excinfo.value)]
-
+                lines += py.std.traceback.format_exception(*excinfo.value.exc_info)
             return ReprFailDoctest(reprlocation, lines)
         else:
             return super(DoctestItem, self).repr_failure(excinfo)
diff --git a/_pytest/helpconfig.py b/_pytest/helpconfig.py
--- a/_pytest/helpconfig.py
+++ b/_pytest/helpconfig.py
@@ -16,9 +16,6 @@
     group.addoption('--traceconfig',
                action="store_true", dest="traceconfig", default=False,
                help="trace considerations of conftest.py files."),
-    group._addoption('--nomagic',
-               action="store_true", dest="nomagic", default=False,
-               help="don't reinterpret asserts, no traceback cutting. ")
     group.addoption('--debug',
                action="store_true", dest="debug", default=False,
                help="generate and show internal debugging information.")
diff --git a/_pytest/junitxml.py b/_pytest/junitxml.py
--- a/_pytest/junitxml.py
+++ b/_pytest/junitxml.py
@@ -5,8 +5,42 @@
 
 import py
 import os
+import re
+import sys
 import time
 
+
+# Python 2.X and 3.X compatibility
+try:
+    unichr(65)
+except NameError:
+    unichr = chr
+try:
+    unicode('A')
+except NameError:
+    unicode = str
+try:
+    long(1)
+except NameError:
+    long = int
+
+
+# We need to get the subset of the invalid unicode ranges according to
+# XML 1.0 which are valid in this python build.  Hence we calculate
+# this dynamically instead of hardcoding it.  The spec range of valid
+# chars is: Char ::= #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD]
+#                    | [#x10000-#x10FFFF]
+_illegal_unichrs = [(0x00, 0x08), (0x0B, 0x0C), (0x0E, 0x19),
+                   (0xD800, 0xDFFF), (0xFDD0, 0xFFFF)]
+_illegal_ranges = [unicode("%s-%s") % (unichr(low), unichr(high))
+                  for (low, high) in _illegal_unichrs
+                  if low < sys.maxunicode]
+illegal_xml_re = re.compile(unicode('[%s]') %
+                            unicode('').join(_illegal_ranges))
+del _illegal_unichrs
+del _illegal_ranges
+
+
 def pytest_addoption(parser):
     group = parser.getgroup("terminal reporting")
     group.addoption('--junitxml', action="store", dest="xmlpath",
@@ -28,9 +62,11 @@
         del config._xml
         config.pluginmanager.unregister(xml)
 
+
 class LogXML(object):
     def __init__(self, logfile, prefix):
-        self.logfile = logfile
+        logfile = os.path.expanduser(os.path.expandvars(logfile))
+        self.logfile = os.path.normpath(logfile)
         self.prefix = prefix
         self.test_logs = []
         self.passed = self.skipped = 0
@@ -41,7 +77,7 @@
         names = report.nodeid.split("::")
         names[0] = names[0].replace("/", '.')
         names = tuple(names)
-        d = {'time': self._durations.pop(names, "0")}
+        d = {'time': self._durations.pop(report.nodeid, "0")}
         names = [x.replace(".py", "") for x in names if x != "()"]
         classnames = names[:-1]
         if self.prefix:
@@ -55,7 +91,14 @@
         self.test_logs.append("</testcase>")
 
     def appendlog(self, fmt, *args):
-        args = tuple([py.xml.escape(arg) for arg in args])
+        def repl(matchobj):
+            i = ord(matchobj.group())
+            if i <= 0xFF:
+                return unicode('#x%02X') % i
+            else:
+                return unicode('#x%04X') % i
+        args = tuple([illegal_xml_re.sub(repl, py.xml.escape(arg))
+                      for arg in args])
         self.test_logs.append(fmt % args)
 
     def append_pass(self, report):
@@ -128,12 +171,11 @@
             self.append_skipped(report)
 
     def pytest_runtest_call(self, item, __multicall__):
-        names = tuple(item.listnames())
         start = time.time()
         try:
             return __multicall__.execute()
         finally:
-            self._durations[names] = time.time() - start
+            self._durations[item.nodeid] = time.time() - start
 
     def pytest_collectreport(self, report):
         if not report.passed:
diff --git a/_pytest/main.py b/_pytest/main.py
--- a/_pytest/main.py
+++ b/_pytest/main.py
@@ -46,23 +46,25 @@
 
 
 def pytest_namespace():
-    return dict(collect=dict(Item=Item, Collector=Collector, File=File))
+    collect = dict(Item=Item, Collector=Collector, File=File, Session=Session)
+    return dict(collect=collect)
         
 def pytest_configure(config):
     py.test.config = config # compatibiltiy
     if config.option.exitfirst:
         config.option.maxfail = 1
 
-def pytest_cmdline_main(config):
-    """ default command line protocol for initialization, session,
-    running tests and reporting. """
+def wrap_session(config, doit):
+    """Skeleton command line program"""
     session = Session(config)
     session.exitstatus = EXIT_OK
+    initstate = 0
     try:
         config.pluginmanager.do_configure(config)
+        initstate = 1
         config.hook.pytest_sessionstart(session=session)
-        config.hook.pytest_collection(session=session)
-        config.hook.pytest_runtestloop(session=session)
+        initstate = 2
+        doit(config, session)
     except pytest.UsageError:
         raise
     except KeyboardInterrupt:
@@ -71,24 +73,30 @@
         session.exitstatus = EXIT_INTERRUPTED
     except:
         excinfo = py.code.ExceptionInfo()
-        config.pluginmanager.notify_exception(excinfo)
+        config.pluginmanager.notify_exception(excinfo, config.option)
         session.exitstatus = EXIT_INTERNALERROR
         if excinfo.errisinstance(SystemExit):
             sys.stderr.write("mainloop: caught Spurious SystemExit!\n")
     if not session.exitstatus and session._testsfailed:
         session.exitstatus = EXIT_TESTSFAILED
-    config.hook.pytest_sessionfinish(session=session,
-        exitstatus=session.exitstatus)
-    config.pluginmanager.do_unconfigure(config)
+    if initstate >= 2:
+        config.hook.pytest_sessionfinish(session=session,
+            exitstatus=session.exitstatus)
+    if initstate >= 1:
+        config.pluginmanager.do_unconfigure(config)
     return session.exitstatus
 
+def pytest_cmdline_main(config):
+    return wrap_session(config, _main)
+
+def _main(config, session):
+    """ default command line protocol for initialization, session,
+    running tests and reporting. """
+    config.hook.pytest_collection(session=session)
+    config.hook.pytest_runtestloop(session=session)
+
 def pytest_collection(session):
-    session.perform_collect()
-    hook = session.config.hook
-    hook.pytest_collection_modifyitems(session=session,
-        config=session.config, items=session.items)
-    hook.pytest_collection_finish(session=session)
-    return True
+    return session.perform_collect()
 
 def pytest_runtestloop(session):
     if session.config.option.collectonly:
@@ -374,6 +382,16 @@
         return HookProxy(fspath, self.config)
 
     def perform_collect(self, args=None, genitems=True):
+        hook = self.config.hook
+        try:
+            items = self._perform_collect(args, genitems)
+            hook.pytest_collection_modifyitems(session=self,
+                config=self.config, items=items)
+        finally:
+            hook.pytest_collection_finish(session=self)
+        return items
+
+    def _perform_collect(self, args, genitems):
         if args is None:
             args = self.config.args
         self.trace("perform_collect", self, args)
diff --git a/_pytest/mark.py b/_pytest/mark.py
--- a/_pytest/mark.py
+++ b/_pytest/mark.py
@@ -153,7 +153,7 @@
 
     def __repr__(self):
         return "<MarkInfo %r args=%r kwargs=%r>" % (
-                self._name, self.args, self.kwargs)
+                self.name, self.args, self.kwargs)
 
 def pytest_itemcollected(item):
     if not isinstance(item, pytest.Function):
diff --git a/_pytest/pytester.py b/_pytest/pytester.py
--- a/_pytest/pytester.py
+++ b/_pytest/pytester.py
@@ -6,7 +6,7 @@
 import inspect
 import time
 from fnmatch import fnmatch
-from _pytest.main import Session
+from _pytest.main import Session, EXIT_OK
 from py.builtin import print_
 from _pytest.core import HookRelay
 
@@ -236,13 +236,14 @@
     def _makefile(self, ext, args, kwargs):
         items = list(kwargs.items())
         if args:
-            source = "\n".join(map(str, args)) + "\n"
+            source = py.builtin._totext("\n").join(
+                map(py.builtin._totext, args)) + py.builtin._totext("\n")
             basename = self.request.function.__name__
             items.insert(0, (basename, source))
         ret = None
         for name, value in items:
             p = self.tmpdir.join(name).new(ext=ext)
-            source = str(py.code.Source(value)).lstrip()
+            source = py.builtin._totext(py.code.Source(value)).lstrip()
             p.write(source.encode("utf-8"), "wb")
             if ret is None:
                 ret = p
@@ -291,13 +292,19 @@
         assert '::' not in str(arg)
         p = py.path.local(arg)
         x = session.fspath.bestrelpath(p)
-        return session.perform_collect([x], genitems=False)[0]
+        config.hook.pytest_sessionstart(session=session)
+        res = session.perform_collect([x], genitems=False)[0]
+        config.hook.pytest_sessionfinish(session=session, exitstatus=EXIT_OK)
+        return res
 
     def getpathnode(self, path):
-        config = self.parseconfig(path)
+        config = self.parseconfigure(path)
         session = Session(config)
         x = session.fspath.bestrelpath(path)
-        return session.perform_collect([x], genitems=False)[0]
+        config.hook.pytest_sessionstart(session=session)
+        res = session.perform_collect([x], genitems=False)[0]
+        config.hook.pytest_sessionfinish(session=session, exitstatus=EXIT_OK)
+        return res
 
     def genitems(self, colitems):
         session = colitems[0].session
@@ -311,7 +318,9 @@
         config = self.parseconfigure(*args)
         rec = self.getreportrecorder(config)
         session = Session(config)
+        config.hook.pytest_sessionstart(session=session)
         session.perform_collect()
+        config.hook.pytest_sessionfinish(session=session, exitstatus=EXIT_OK)
         return session.items, rec
 
     def runitem(self, source):
@@ -381,6 +390,8 @@
             c.basetemp = py.path.local.make_numbered_dir(prefix="reparse",
                 keep=0, rootdir=self.tmpdir, lock_timeout=None)
             c.parse(args)
+            c.pluginmanager.do_configure(c)
+            self.request.addfinalizer(lambda: c.pluginmanager.do_unconfigure(c))
             return c
         finally:
             py.test.config = oldconfig
diff --git a/_pytest/python.py b/_pytest/python.py
--- a/_pytest/python.py
+++ b/_pytest/python.py
@@ -226,8 +226,13 @@
 
     def _importtestmodule(self):
         # we assume we are only called once per module
+        from _pytest import assertion
+        assertion.before_module_import(self)
         try:
-            mod = self.fspath.pyimport(ensuresyspath=True)
+            try:
+                mod = self.fspath.pyimport(ensuresyspath=True)
+            finally:
+                assertion.after_module_import(self)
         except SyntaxError:
             excinfo = py.code.ExceptionInfo()
             raise self.CollectError(excinfo.getrepr(style="short"))
@@ -374,7 +379,7 @@
         # test generators are seen as collectors but they also
         # invoke setup/teardown on popular request
         # (induced by the common "test_*" naming shared with normal tests)
-        self.config._setupstate.prepare(self)
+        self.session._setupstate.prepare(self)
         # see FunctionMixin.setup and test_setupstate_is_preserved_134
         self._preservedparent = self.parent.obj
         l = []
@@ -721,7 +726,7 @@
 
     def _addfinalizer(self, finalizer, scope):
         colitem = self._getscopeitem(scope)
-        self.config._setupstate.addfinalizer(
+        self._pyfuncitem.session._setupstate.addfinalizer(
             finalizer=finalizer, colitem=colitem)
 
     def __repr__(self):
@@ -742,8 +747,10 @@
         raise self.LookupError(msg)
 
 def showfuncargs(config):
-    from _pytest.main import Session
-    session = Session(config)
+    from _pytest.main import wrap_session
+    return wrap_session(config, _showfuncargs_main)
+
+def _showfuncargs_main(config, session):
     session.perform_collect()
     if session.items:
         plugins = session.items[0].getplugins()
diff --git a/_pytest/resultlog.py b/_pytest/resultlog.py
--- a/_pytest/resultlog.py
+++ b/_pytest/resultlog.py
@@ -74,7 +74,7 @@
         elif report.failed:
             longrepr = str(report.longrepr)
         elif report.skipped:
-            longrepr = str(report.longrepr)
+            longrepr = str(report.longrepr[2])
         self.log_outcome(report, code, longrepr)
 
     def pytest_collectreport(self, report):
diff --git a/_pytest/runner.py b/_pytest/runner.py
--- a/_pytest/runner.py
+++ b/_pytest/runner.py
@@ -14,17 +14,15 @@
 #
 # pytest plugin hooks
 
-# XXX move to pytest_sessionstart and fix py.test owns tests
-def pytest_configure(config):
-    config._setupstate = SetupState()
+def pytest_sessionstart(session):
+    session._setupstate = SetupState()
 
 def pytest_sessionfinish(session, exitstatus):
-    if hasattr(session.config, '_setupstate'):
-        hook = session.config.hook
-        rep = hook.pytest__teardown_final(session=session)
-        if rep:
-            hook.pytest__teardown_final_logerror(session=session, report=rep)
-            session.exitstatus = 1
+    hook = session.config.hook
+    rep = hook.pytest__teardown_final(session=session)
+    if rep:
+        hook.pytest__teardown_final_logerror(session=session, report=rep)
+        session.exitstatus = 1
 
 class NodeInfo:
     def __init__(self, location):
@@ -46,16 +44,16 @@
     return reports
 
 def pytest_runtest_setup(item):
-    item.config._setupstate.prepare(item)
+    item.session._setupstate.prepare(item)
 
 def pytest_runtest_call(item):
     item.runtest()
 
 def pytest_runtest_teardown(item):
-    item.config._setupstate.teardown_exact(item)
+    item.session._setupstate.teardown_exact(item)
 
 def pytest__teardown_final(session):
-    call = CallInfo(session.config._setupstate.teardown_all, when="teardown")
+    call = CallInfo(session._setupstate.teardown_all, when="teardown")
     if call.excinfo:
         ntraceback = call.excinfo.traceback .cut(excludepath=py._pydir)
         call.excinfo.traceback = ntraceback.filter()
diff --git a/_pytest/tmpdir.py b/_pytest/tmpdir.py
--- a/_pytest/tmpdir.py
+++ b/_pytest/tmpdir.py
@@ -48,15 +48,12 @@
         self.trace("finish")
         
 def pytest_configure(config):
-    config._mp = mp = monkeypatch()
+    mp = monkeypatch()
     t = TempdirHandler(config)
+    config._cleanup.extend([mp.undo, t.finish])
     mp.setattr(config, '_tmpdirhandler', t, raising=False)
     mp.setattr(pytest, 'ensuretemp', t.ensuretemp, raising=False)
 
-def pytest_unconfigure(config):
-    config._tmpdirhandler.finish()
-    config._mp.undo()
-
 def pytest_funcarg__tmpdir(request):
     """return a temporary directory path object
     which is unique to each test function invocation,
diff --git a/lib-python/2.7.0/BaseHTTPServer.py b/lib-python/2.7/BaseHTTPServer.py
rename from lib-python/2.7.0/BaseHTTPServer.py
rename to lib-python/2.7/BaseHTTPServer.py
diff --git a/lib-python/2.7.0/Bastion.py b/lib-python/2.7/Bastion.py
rename from lib-python/2.7.0/Bastion.py
rename to lib-python/2.7/Bastion.py
diff --git a/lib-python/2.7.0/CGIHTTPServer.py b/lib-python/2.7/CGIHTTPServer.py
rename from lib-python/2.7.0/CGIHTTPServer.py
rename to lib-python/2.7/CGIHTTPServer.py
diff --git a/lib-python/2.7.0/ConfigParser.py b/lib-python/2.7/ConfigParser.py
rename from lib-python/2.7.0/ConfigParser.py
rename to lib-python/2.7/ConfigParser.py
diff --git a/lib-python/2.7.0/Cookie.py b/lib-python/2.7/Cookie.py
rename from lib-python/2.7.0/Cookie.py
rename to lib-python/2.7/Cookie.py
diff --git a/lib-python/2.7.0/DocXMLRPCServer.py b/lib-python/2.7/DocXMLRPCServer.py
rename from lib-python/2.7.0/DocXMLRPCServer.py
rename to lib-python/2.7/DocXMLRPCServer.py
diff --git a/lib-python/2.7.0/HTMLParser.py b/lib-python/2.7/HTMLParser.py
rename from lib-python/2.7.0/HTMLParser.py
rename to lib-python/2.7/HTMLParser.py
diff --git a/lib-python/2.7.0/MimeWriter.py b/lib-python/2.7/MimeWriter.py
rename from lib-python/2.7.0/MimeWriter.py
rename to lib-python/2.7/MimeWriter.py
diff --git a/lib-python/2.7.0/Queue.py b/lib-python/2.7/Queue.py
rename from lib-python/2.7.0/Queue.py
rename to lib-python/2.7/Queue.py
diff --git a/lib-python/2.7.0/SimpleHTTPServer.py b/lib-python/2.7/SimpleHTTPServer.py
rename from lib-python/2.7.0/SimpleHTTPServer.py
rename to lib-python/2.7/SimpleHTTPServer.py
diff --git a/lib-python/2.7.0/SimpleXMLRPCServer.py b/lib-python/2.7/SimpleXMLRPCServer.py
rename from lib-python/2.7.0/SimpleXMLRPCServer.py
rename to lib-python/2.7/SimpleXMLRPCServer.py
diff --git a/lib-python/2.7.0/SocketServer.py b/lib-python/2.7/SocketServer.py
rename from lib-python/2.7.0/SocketServer.py
rename to lib-python/2.7/SocketServer.py
diff --git a/lib-python/2.7.0/StringIO.py b/lib-python/2.7/StringIO.py
rename from lib-python/2.7.0/StringIO.py
rename to lib-python/2.7/StringIO.py
diff --git a/lib-python/2.7.0/UserDict.py b/lib-python/2.7/UserDict.py
rename from lib-python/2.7.0/UserDict.py
rename to lib-python/2.7/UserDict.py
diff --git a/lib-python/2.7.0/UserList.py b/lib-python/2.7/UserList.py
rename from lib-python/2.7.0/UserList.py
rename to lib-python/2.7/UserList.py
diff --git a/lib-python/2.7.0/UserString.py b/lib-python/2.7/UserString.py
rename from lib-python/2.7.0/UserString.py
rename to lib-python/2.7/UserString.py
diff --git a/lib-python/2.7.0/_LWPCookieJar.py b/lib-python/2.7/_LWPCookieJar.py
rename from lib-python/2.7.0/_LWPCookieJar.py
rename to lib-python/2.7/_LWPCookieJar.py
diff --git a/lib-python/2.7.0/_MozillaCookieJar.py b/lib-python/2.7/_MozillaCookieJar.py
rename from lib-python/2.7.0/_MozillaCookieJar.py
rename to lib-python/2.7/_MozillaCookieJar.py
diff --git a/lib-python/2.7.0/__future__.py b/lib-python/2.7/__future__.py
rename from lib-python/2.7.0/__future__.py
rename to lib-python/2.7/__future__.py
diff --git a/lib-python/2.7.0/__phello__.foo.py b/lib-python/2.7/__phello__.foo.py
rename from lib-python/2.7.0/__phello__.foo.py
rename to lib-python/2.7/__phello__.foo.py
diff --git a/lib-python/2.7.0/_abcoll.py b/lib-python/2.7/_abcoll.py
rename from lib-python/2.7.0/_abcoll.py
rename to lib-python/2.7/_abcoll.py
diff --git a/lib-python/2.7.0/_pyio.py b/lib-python/2.7/_pyio.py
rename from lib-python/2.7.0/_pyio.py
rename to lib-python/2.7/_pyio.py
diff --git a/lib-python/2.7.0/_strptime.py b/lib-python/2.7/_strptime.py
rename from lib-python/2.7.0/_strptime.py
rename to lib-python/2.7/_strptime.py
diff --git a/lib-python/2.7.0/_threading_local.py b/lib-python/2.7/_threading_local.py
rename from lib-python/2.7.0/_threading_local.py
rename to lib-python/2.7/_threading_local.py
diff --git a/lib-python/2.7.0/_weakrefset.py b/lib-python/2.7/_weakrefset.py
rename from lib-python/2.7.0/_weakrefset.py
rename to lib-python/2.7/_weakrefset.py
diff --git a/lib-python/2.7.0/abc.py b/lib-python/2.7/abc.py
rename from lib-python/2.7.0/abc.py
rename to lib-python/2.7/abc.py
diff --git a/lib-python/2.7.0/aifc.py b/lib-python/2.7/aifc.py
rename from lib-python/2.7.0/aifc.py
rename to lib-python/2.7/aifc.py
diff --git a/lib-python/2.7.0/antigravity.py b/lib-python/2.7/antigravity.py
rename from lib-python/2.7.0/antigravity.py
rename to lib-python/2.7/antigravity.py
diff --git a/lib-python/2.7.0/anydbm.py b/lib-python/2.7/anydbm.py
rename from lib-python/2.7.0/anydbm.py
rename to lib-python/2.7/anydbm.py
diff --git a/lib-python/2.7.0/argparse.py b/lib-python/2.7/argparse.py
rename from lib-python/2.7.0/argparse.py
rename to lib-python/2.7/argparse.py
diff --git a/lib-python/2.7.0/ast.py b/lib-python/2.7/ast.py
rename from lib-python/2.7.0/ast.py
rename to lib-python/2.7/ast.py
diff --git a/lib-python/2.7.0/asynchat.py b/lib-python/2.7/asynchat.py
rename from lib-python/2.7.0/asynchat.py
rename to lib-python/2.7/asynchat.py
diff --git a/lib-python/2.7.0/asyncore.py b/lib-python/2.7/asyncore.py
rename from lib-python/2.7.0/asyncore.py
rename to lib-python/2.7/asyncore.py
diff --git a/lib-python/2.7.0/atexit.py b/lib-python/2.7/atexit.py
rename from lib-python/2.7.0/atexit.py
rename to lib-python/2.7/atexit.py
diff --git a/lib-python/2.7.0/audiodev.py b/lib-python/2.7/audiodev.py
rename from lib-python/2.7.0/audiodev.py
rename to lib-python/2.7/audiodev.py
diff --git a/lib-python/2.7.0/base64.py b/lib-python/2.7/base64.py
rename from lib-python/2.7.0/base64.py
rename to lib-python/2.7/base64.py
diff --git a/lib-python/2.7.0/bdb.py b/lib-python/2.7/bdb.py
rename from lib-python/2.7.0/bdb.py
rename to lib-python/2.7/bdb.py
diff --git a/lib-python/2.7.0/binhex.py b/lib-python/2.7/binhex.py
rename from lib-python/2.7.0/binhex.py
rename to lib-python/2.7/binhex.py
diff --git a/lib-python/2.7.0/bisect.py b/lib-python/2.7/bisect.py
rename from lib-python/2.7.0/bisect.py
rename to lib-python/2.7/bisect.py
diff --git a/lib-python/2.7.0/bsddb/__init__.py b/lib-python/2.7/bsddb/__init__.py
rename from lib-python/2.7.0/bsddb/__init__.py
rename to lib-python/2.7/bsddb/__init__.py
diff --git a/lib-python/2.7.0/bsddb/db.py b/lib-python/2.7/bsddb/db.py
rename from lib-python/2.7.0/bsddb/db.py
rename to lib-python/2.7/bsddb/db.py
diff --git a/lib-python/2.7.0/bsddb/dbobj.py b/lib-python/2.7/bsddb/dbobj.py
rename from lib-python/2.7.0/bsddb/dbobj.py
rename to lib-python/2.7/bsddb/dbobj.py
diff --git a/lib-python/2.7.0/bsddb/dbrecio.py b/lib-python/2.7/bsddb/dbrecio.py
rename from lib-python/2.7.0/bsddb/dbrecio.py
rename to lib-python/2.7/bsddb/dbrecio.py
diff --git a/lib-python/2.7.0/bsddb/dbshelve.py b/lib-python/2.7/bsddb/dbshelve.py
rename from lib-python/2.7.0/bsddb/dbshelve.py
rename to lib-python/2.7/bsddb/dbshelve.py
diff --git a/lib-python/2.7.0/bsddb/dbtables.py b/lib-python/2.7/bsddb/dbtables.py
rename from lib-python/2.7.0/bsddb/dbtables.py
rename to lib-python/2.7/bsddb/dbtables.py
--- a/lib-python/2.7.0/bsddb/dbtables.py
+++ b/lib-python/2.7/bsddb/dbtables.py
@@ -15,7 +15,7 @@
 # This provides a simple database table interface built on top of
 # the Python Berkeley DB 3 interface.
 #
-_cvsid = '$Id: dbtables.py 79285 2010-03-22 14:22:26Z jesus.cea $'
+_cvsid = '$Id$'
 
 import re
 import sys
diff --git a/lib-python/2.7.0/bsddb/dbutils.py b/lib-python/2.7/bsddb/dbutils.py
rename from lib-python/2.7.0/bsddb/dbutils.py
rename to lib-python/2.7/bsddb/dbutils.py
diff --git a/lib-python/2.7.0/bsddb/test/__init__.py b/lib-python/2.7/bsddb/test/__init__.py
rename from lib-python/2.7.0/bsddb/test/__init__.py
rename to lib-python/2.7/bsddb/test/__init__.py
diff --git a/lib-python/2.7.0/bsddb/test/test_all.py b/lib-python/2.7/bsddb/test/test_all.py
rename from lib-python/2.7.0/bsddb/test/test_all.py
rename to lib-python/2.7/bsddb/test/test_all.py
diff --git a/lib-python/2.7.0/bsddb/test/test_associate.py b/lib-python/2.7/bsddb/test/test_associate.py
rename from lib-python/2.7.0/bsddb/test/test_associate.py
rename to lib-python/2.7/bsddb/test/test_associate.py
--- a/lib-python/2.7.0/bsddb/test/test_associate.py
+++ b/lib-python/2.7/bsddb/test/test_associate.py
@@ -233,7 +233,7 @@
         self.assertEqual(vals, None, vals)
 
         vals = secDB.pget('Unknown', txn=txn)
-        self.assert_(vals[0] == 99 or vals[0] == '99', vals)
+        self.assertTrue(vals[0] == 99 or vals[0] == '99', vals)
         vals[1].index('Unknown')
         vals[1].index('Unnamed')
         vals[1].index('unknown')
@@ -245,9 +245,9 @@
         rec = self.cur.first()
         while rec is not None:
             if type(self.keytype) == type(''):
-                self.assert_(int(rec[0]))  # for primary db, key is a number
+                self.assertTrue(int(rec[0]))  # for primary db, key is a number
             else:
-                self.assert_(rec[0] and type(rec[0]) == type(0))
+                self.assertTrue(rec[0] and type(rec[0]) == type(0))
             count = count + 1
             if verbose:
                 print rec
@@ -262,7 +262,7 @@
 
         # test cursor pget
         vals = self.cur.pget('Unknown', flags=db.DB_LAST)
-        self.assert_(vals[1] == 99 or vals[1] == '99', vals)
+        self.assertTrue(vals[1] == 99 or vals[1] == '99', vals)
         self.assertEqual(vals[0], 'Unknown')
         vals[2].index('Unknown')
         vals[2].index('Unnamed')
diff --git a/lib-python/2.7.0/bsddb/test/test_basics.py b/lib-python/2.7/bsddb/test/test_basics.py
rename from lib-python/2.7.0/bsddb/test/test_basics.py
rename to lib-python/2.7/bsddb/test/test_basics.py
--- a/lib-python/2.7.0/bsddb/test/test_basics.py
+++ b/lib-python/2.7/bsddb/test/test_basics.py
@@ -612,7 +612,7 @@
 
         d.put("abcde", "ABCDE");
         num = d.truncate()
-        self.assert_(num >= 1, "truncate returned <= 0 on non-empty database")
+        self.assertTrue(num >= 1, "truncate returned <= 0 on non-empty database")
         num = d.truncate()
         self.assertEqual(num, 0,
                 "truncate on empty DB returned nonzero (%r)" % (num,))
@@ -631,9 +631,9 @@
     if db.version() >= (4, 6):
         def test08_exists(self) :
             self.d.put("abcde", "ABCDE")
-            self.assert_(self.d.exists("abcde") == True,
+            self.assertTrue(self.d.exists("abcde") == True,
                     "DB->exists() returns wrong value")
-            self.assert_(self.d.exists("x") == False,
+            self.assertTrue(self.d.exists("x") == False,
                     "DB->exists() returns wrong value")
 
     #----------------------------------------
@@ -806,9 +806,9 @@
             self.d.put("abcde", "ABCDE", txn=txn)
             txn.commit()
             txn = self.env.txn_begin()
-            self.assert_(self.d.exists("abcde", txn=txn) == True,
+            self.assertTrue(self.d.exists("abcde", txn=txn) == True,
                     "DB->exists() returns wrong value")
-            self.assert_(self.d.exists("x", txn=txn) == False,
+            self.assertTrue(self.d.exists("x", txn=txn) == False,
                     "DB->exists() returns wrong value")
             txn.abort()
 
@@ -823,7 +823,7 @@
         d.put("abcde", "ABCDE");
         txn = self.env.txn_begin()
         num = d.truncate(txn)
-        self.assert_(num >= 1, "truncate returned <= 0 on non-empty database")
+        self.assertTrue(num >= 1, "truncate returned <= 0 on non-empty database")
         num = d.truncate(txn)
         self.assertEqual(num, 0,
                 "truncate on empty DB returned nonzero (%r)" % (num,))
diff --git a/lib-python/2.7.0/bsddb/test/test_compare.py b/lib-python/2.7/bsddb/test/test_compare.py
rename from lib-python/2.7.0/bsddb/test/test_compare.py
rename to lib-python/2.7/bsddb/test/test_compare.py
diff --git a/lib-python/2.7.0/bsddb/test/test_compat.py b/lib-python/2.7/bsddb/test/test_compat.py
rename from lib-python/2.7.0/bsddb/test/test_compat.py
rename to lib-python/2.7/bsddb/test/test_compat.py
--- a/lib-python/2.7.0/bsddb/test/test_compat.py
+++ b/lib-python/2.7/bsddb/test/test_compat.py
@@ -119,7 +119,7 @@
             if verbose:
                 print rec
 
-        self.assert_(f.has_key('f'), 'Error, missing key!')
+        self.assertTrue(f.has_key('f'), 'Error, missing key!')
 
         # test that set_location() returns the next nearest key, value
         # on btree databases and raises KeyError on others.
diff --git a/lib-python/2.7.0/bsddb/test/test_cursor_pget_bug.py b/lib-python/2.7/bsddb/test/test_cursor_pget_bug.py
rename from lib-python/2.7.0/bsddb/test/test_cursor_pget_bug.py
rename to lib-python/2.7/bsddb/test/test_cursor_pget_bug.py
--- a/lib-python/2.7.0/bsddb/test/test_cursor_pget_bug.py
+++ b/lib-python/2.7/bsddb/test/test_cursor_pget_bug.py
@@ -37,12 +37,12 @@
     def test_pget(self):
         cursor = self.secondary_db.cursor()
 
-        self.assertEquals(('eggs', 'salad', 'eggs'), cursor.pget(key='eggs', flags=db.DB_SET))
-        self.assertEquals(('eggs', 'omelet', 'eggs'), cursor.pget(db.DB_NEXT_DUP))
-        self.assertEquals(None, cursor.pget(db.DB_NEXT_DUP))
+        self.assertEqual(('eggs', 'salad', 'eggs'), cursor.pget(key='eggs', flags=db.DB_SET))
+        self.assertEqual(('eggs', 'omelet', 'eggs'), cursor.pget(db.DB_NEXT_DUP))
+        self.assertEqual(None, cursor.pget(db.DB_NEXT_DUP))
 
-        self.assertEquals(('ham', 'spam', 'ham'), cursor.pget('ham', 'spam', flags=db.DB_SET))
-        self.assertEquals(None, cursor.pget(db.DB_NEXT_DUP))
+        self.assertEqual(('ham', 'spam', 'ham'), cursor.pget('ham', 'spam', flags=db.DB_SET))
+        self.assertEqual(None, cursor.pget(db.DB_NEXT_DUP))
 
         cursor.close()
 
diff --git a/lib-python/2.7.0/bsddb/test/test_db.py b/lib-python/2.7/bsddb/test/test_db.py
rename from lib-python/2.7.0/bsddb/test/test_db.py
rename to lib-python/2.7/bsddb/test/test_db.py
diff --git a/lib-python/2.7.0/bsddb/test/test_dbenv.py b/lib-python/2.7/bsddb/test/test_dbenv.py
rename from lib-python/2.7.0/bsddb/test/test_dbenv.py
rename to lib-python/2.7/bsddb/test/test_dbenv.py
diff --git a/lib-python/2.7.0/bsddb/test/test_dbobj.py b/lib-python/2.7/bsddb/test/test_dbobj.py
rename from lib-python/2.7.0/bsddb/test/test_dbobj.py
rename to lib-python/2.7/bsddb/test/test_dbobj.py
diff --git a/lib-python/2.7.0/bsddb/test/test_dbshelve.py b/lib-python/2.7/bsddb/test/test_dbshelve.py
rename from lib-python/2.7.0/bsddb/test/test_dbshelve.py
rename to lib-python/2.7/bsddb/test/test_dbshelve.py
--- a/lib-python/2.7.0/bsddb/test/test_dbshelve.py
+++ b/lib-python/2.7/bsddb/test/test_dbshelve.py
@@ -255,7 +255,7 @@
             self.assertEqual(value.L, [x] * 10)
 
         else:
-            self.assert_(0, 'Unknown key type, fix the test')
+            self.assertTrue(0, 'Unknown key type, fix the test')
 
 #----------------------------------------------------------------------
 
diff --git a/lib-python/2.7.0/bsddb/test/test_dbtables.py b/lib-python/2.7/bsddb/test/test_dbtables.py
rename from lib-python/2.7.0/bsddb/test/test_dbtables.py
rename to lib-python/2.7/bsddb/test/test_dbtables.py
--- a/lib-python/2.7.0/bsddb/test/test_dbtables.py
+++ b/lib-python/2.7/bsddb/test/test_dbtables.py
@@ -18,7 +18,7 @@
 #
 #   --  Gregory P. Smith <greg at krypto.org>
 #
-# $Id: test_dbtables.py 79285 2010-03-22 14:22:26Z jesus.cea $
+# $Id$
 
 import os, re, sys
 
@@ -84,8 +84,8 @@
             colval = pickle.loads(values[0][colname])
         else :
             colval = pickle.loads(bytes(values[0][colname], "iso8859-1"))
-        self.assert_(colval > 3.141)
-        self.assert_(colval < 3.142)
+        self.assertTrue(colval > 3.141)
+        self.assertTrue(colval < 3.142)
 
 
     def test02(self):
diff --git a/lib-python/2.7.0/bsddb/test/test_distributed_transactions.py b/lib-python/2.7/bsddb/test/test_distributed_transactions.py
rename from lib-python/2.7.0/bsddb/test/test_distributed_transactions.py
rename to lib-python/2.7/bsddb/test/test_distributed_transactions.py
--- a/lib-python/2.7.0/bsddb/test/test_distributed_transactions.py
+++ b/lib-python/2.7/bsddb/test/test_distributed_transactions.py
@@ -88,9 +88,9 @@
     # Get "to be recovered" transactions but
     # let them be garbage collected.
         recovered_txns=self.dbenv.txn_recover()
-        self.assertEquals(self.num_txns,len(recovered_txns))
+        self.assertEqual(self.num_txns,len(recovered_txns))
         for gid,txn in recovered_txns :
-            self.assert_(gid in txns)
+            self.assertTrue(gid in txns)
         del txn
         del recovered_txns
 
@@ -99,7 +99,7 @@
     # Get "to be recovered" transactions. Commit, abort and
     # discard them.
         recovered_txns=self.dbenv.txn_recover()
-        self.assertEquals(self.num_txns,len(recovered_txns))
+        self.assertEqual(self.num_txns,len(recovered_txns))
         discard_txns=set()
         committed_txns=set()
         state=0
@@ -122,7 +122,7 @@
     # Verify the discarded transactions are still
     # around, and dispose them.
         recovered_txns=self.dbenv.txn_recover()
-        self.assertEquals(len(discard_txns),len(recovered_txns))
+        self.assertEqual(len(discard_txns),len(recovered_txns))
         for gid,txn in recovered_txns :
             txn.abort()
         del txn
@@ -133,8 +133,8 @@
     # Be sure there are not pending transactions.
     # Check also database size.
         recovered_txns=self.dbenv.txn_recover()
-        self.assert_(len(recovered_txns)==0)
-        self.assertEquals(len(committed_txns),self.db.stat()["nkeys"])
+        self.assertTrue(len(recovered_txns)==0)
+        self.assertEqual(len(committed_txns),self.db.stat()["nkeys"])
 
 class DBTxn_distributedSYNC(DBTxn_distributed):
     nosync=False
diff --git a/lib-python/2.7.0/bsddb/test/test_early_close.py b/lib-python/2.7/bsddb/test/test_early_close.py
rename from lib-python/2.7.0/bsddb/test/test_early_close.py
rename to lib-python/2.7/bsddb/test/test_early_close.py
--- a/lib-python/2.7.0/bsddb/test/test_early_close.py
+++ b/lib-python/2.7/bsddb/test/test_early_close.py
@@ -162,7 +162,7 @@
         txn = dbenv.txn_begin()
         c1 = d.cursor(txn)
         c2 = c1.dup()
-        self.assertEquals(("XXX", "yyy"), c1.first())
+        self.assertEqual(("XXX", "yyy"), c1.first())
 
         # Not interested in warnings about implicit close.
         import warnings
diff --git a/lib-python/2.7.0/bsddb/test/test_fileid.py b/lib-python/2.7/bsddb/test/test_fileid.py
rename from lib-python/2.7.0/bsddb/test/test_fileid.py
rename to lib-python/2.7/bsddb/test/test_fileid.py
--- a/lib-python/2.7.0/bsddb/test/test_fileid.py
+++ b/lib-python/2.7/bsddb/test/test_fileid.py
@@ -35,11 +35,11 @@
 
         self.db1 = db.DB(self.db_env)
         self.db1.open(self.db_path_1, dbtype=db.DB_HASH, flags=db.DB_RDONLY)
-        self.assertEquals(self.db1.get('spam'), 'eggs')
+        self.assertEqual(self.db1.get('spam'), 'eggs')
 
         self.db2 = db.DB(self.db_env)
         self.db2.open(self.db_path_2, dbtype=db.DB_HASH, flags=db.DB_RDONLY)
-        self.assertEquals(self.db2.get('spam'), 'spam')
+        self.assertEqual(self.db2.get('spam'), 'spam')
 
         self.db1.close()
         self.db2.close()
diff --git a/lib-python/2.7.0/bsddb/test/test_get_none.py b/lib-python/2.7/bsddb/test/test_get_none.py
rename from lib-python/2.7.0/bsddb/test/test_get_none.py
rename to lib-python/2.7/bsddb/test/test_get_none.py
--- a/lib-python/2.7.0/bsddb/test/test_get_none.py
+++ b/lib-python/2.7/bsddb/test/test_get_none.py
@@ -76,7 +76,7 @@
                 break
 
         self.assertNotEqual(rec, None)
-        self.assert_(exceptionHappened)
+        self.assertTrue(exceptionHappened)
         self.assertEqual(count, len(string.letters))
 
         c.close()
diff --git a/lib-python/2.7.0/bsddb/test/test_join.py b/lib-python/2.7/bsddb/test/test_join.py
rename from lib-python/2.7.0/bsddb/test/test_join.py
rename to lib-python/2.7/bsddb/test/test_join.py
--- a/lib-python/2.7.0/bsddb/test/test_join.py
+++ b/lib-python/2.7/bsddb/test/test_join.py
@@ -67,7 +67,7 @@
             # Don't do the .set() in an assert, or you can get a bogus failure
             # when running python -O
             tmp = sCursor.set('red')
-            self.assert_(tmp)
+            self.assertTrue(tmp)
 
             # FIXME: jCursor doesn't properly hold a reference to its
             # cursors, if they are closed before jcursor is used it
diff --git a/lib-python/2.7.0/bsddb/test/test_lock.py b/lib-python/2.7/bsddb/test/test_lock.py
rename from lib-python/2.7.0/bsddb/test/test_lock.py
rename to lib-python/2.7/bsddb/test/test_lock.py
diff --git a/lib-python/2.7.0/bsddb/test/test_misc.py b/lib-python/2.7/bsddb/test/test_misc.py
rename from lib-python/2.7.0/bsddb/test/test_misc.py
rename to lib-python/2.7/bsddb/test/test_misc.py
--- a/lib-python/2.7.0/bsddb/test/test_misc.py
+++ b/lib-python/2.7/bsddb/test/test_misc.py
@@ -32,7 +32,7 @@
     def test02_db_home(self):
         env = db.DBEnv()
         # check for crash fixed when db_home is used before open()
-        self.assert_(env.db_home is None)
+        self.assertTrue(env.db_home is None)
         env.open(self.homeDir, db.DB_CREATE)
         if sys.version_info[0] < 3 :
             self.assertEqual(self.homeDir, env.db_home)
@@ -43,7 +43,7 @@
         db = hashopen(self.filename)
         db.close()
         rp = repr(db)
-        self.assertEquals(rp, "{}")
+        self.assertEqual(rp, "{}")
 
     def test04_repr_db(self) :
         db = hashopen(self.filename)
@@ -54,7 +54,7 @@
         db.close()
         db = hashopen(self.filename)
         rp = repr(db)
-        self.assertEquals(rp, repr(d))
+        self.assertEqual(rp, repr(d))
         db.close()
 
     # http://sourceforge.net/tracker/index.php?func=detail&aid=1708868&group_id=13900&atid=313900
diff --git a/lib-python/2.7.0/bsddb/test/test_pickle.py b/lib-python/2.7/bsddb/test/test_pickle.py
rename from lib-python/2.7.0/bsddb/test/test_pickle.py
rename to lib-python/2.7/bsddb/test/test_pickle.py
diff --git a/lib-python/2.7.0/bsddb/test/test_queue.py b/lib-python/2.7/bsddb/test/test_queue.py
rename from lib-python/2.7.0/bsddb/test/test_queue.py
rename to lib-python/2.7/bsddb/test/test_queue.py
diff --git a/lib-python/2.7.0/bsddb/test/test_recno.py b/lib-python/2.7/bsddb/test/test_recno.py
rename from lib-python/2.7.0/bsddb/test/test_recno.py
rename to lib-python/2.7/bsddb/test/test_recno.py
--- a/lib-python/2.7.0/bsddb/test/test_recno.py
+++ b/lib-python/2.7/bsddb/test/test_recno.py
@@ -18,7 +18,7 @@
         def assertFalse(self, expr, msg=None) :
             return self.failIf(expr,msg=msg)
         def assertTrue(self, expr, msg=None) :
-            return self.assert_(expr, msg=msg)
+            return self.assertTrue(expr, msg=msg)
 
     if (sys.version_info < (2, 7)) or ((sys.version_info >= (3, 0)) and
             (sys.version_info < (3, 2))) :
diff --git a/lib-python/2.7.0/bsddb/test/test_replication.py b/lib-python/2.7/bsddb/test/test_replication.py
rename from lib-python/2.7.0/bsddb/test/test_replication.py
rename to lib-python/2.7/bsddb/test/test_replication.py
--- a/lib-python/2.7.0/bsddb/test/test_replication.py
+++ b/lib-python/2.7/bsddb/test/test_replication.py
@@ -88,23 +88,23 @@
 
         self.dbenvMaster.rep_set_timeout(db.DB_REP_CONNECTION_RETRY,100123)
         self.dbenvClient.rep_set_timeout(db.DB_REP_CONNECTION_RETRY,100321)
-        self.assertEquals(self.dbenvMaster.rep_get_timeout(
+        self.assertEqual(self.dbenvMaster.rep_get_timeout(
             db.DB_REP_CONNECTION_RETRY), 100123)
-        self.assertEquals(self.dbenvClient.rep_get_timeout(
+        self.assertEqual(self.dbenvClient.rep_get_timeout(
             db.DB_REP_CONNECTION_RETRY), 100321)
 
         self.dbenvMaster.rep_set_timeout(db.DB_REP_ELECTION_TIMEOUT, 100234)
         self.dbenvClient.rep_set_timeout(db.DB_REP_ELECTION_TIMEOUT, 100432)
-        self.assertEquals(self.dbenvMaster.rep_get_timeout(
+        self.assertEqual(self.dbenvMaster.rep_get_timeout(
             db.DB_REP_ELECTION_TIMEOUT), 100234)
-        self.assertEquals(self.dbenvClient.rep_get_timeout(
+        self.assertEqual(self.dbenvClient.rep_get_timeout(
             db.DB_REP_ELECTION_TIMEOUT), 100432)
 
         self.dbenvMaster.rep_set_timeout(db.DB_REP_ELECTION_RETRY, 100345)
         self.dbenvClient.rep_set_timeout(db.DB_REP_ELECTION_RETRY, 100543)
-        self.assertEquals(self.dbenvMaster.rep_get_timeout(
+        self.assertEqual(self.dbenvMaster.rep_get_timeout(
             db.DB_REP_ELECTION_RETRY), 100345)
-        self.assertEquals(self.dbenvClient.rep_get_timeout(
+        self.assertEqual(self.dbenvClient.rep_get_timeout(
             db.DB_REP_ELECTION_RETRY), 100543)
 
         self.dbenvMaster.repmgr_set_ack_policy(db.DB_REPMGR_ACKS_ALL)
@@ -113,13 +113,13 @@
         self.dbenvMaster.repmgr_start(1, db.DB_REP_MASTER);
         self.dbenvClient.repmgr_start(1, db.DB_REP_CLIENT);
 
-        self.assertEquals(self.dbenvMaster.rep_get_nsites(),2)
-        self.assertEquals(self.dbenvClient.rep_get_nsites(),2)
-        self.assertEquals(self.dbenvMaster.rep_get_priority(),10)
-        self.assertEquals(self.dbenvClient.rep_get_priority(),0)
-        self.assertEquals(self.dbenvMaster.repmgr_get_ack_policy(),
+        self.assertEqual(self.dbenvMaster.rep_get_nsites(),2)
+        self.assertEqual(self.dbenvClient.rep_get_nsites(),2)
+        self.assertEqual(self.dbenvMaster.rep_get_priority(),10)
+        self.assertEqual(self.dbenvClient.rep_get_priority(),0)
+        self.assertEqual(self.dbenvMaster.repmgr_get_ack_policy(),
                 db.DB_REPMGR_ACKS_ALL)
-        self.assertEquals(self.dbenvClient.repmgr_get_ack_policy(),
+        self.assertEqual(self.dbenvClient.repmgr_get_ack_policy(),
                 db.DB_REPMGR_ACKS_ALL)
 
         # The timeout is necessary in BDB 4.5, since DB_EVENT_REP_STARTUPDONE
@@ -143,16 +143,16 @@
             startup_timeout = True
 
         d = self.dbenvMaster.repmgr_site_list()
-        self.assertEquals(len(d), 1)
-        self.assertEquals(d[0][0], "127.0.0.1")
-        self.assertEquals(d[0][1], client_port)
+        self.assertEqual(len(d), 1)
+        self.assertEqual(d[0][0], "127.0.0.1")
+        self.assertEqual(d[0][1], client_port)
         self.assertTrue((d[0][2]==db.DB_REPMGR_CONNECTED) or \
                 (d[0][2]==db.DB_REPMGR_DISCONNECTED))
 
         d = self.dbenvClient.repmgr_site_list()
-        self.assertEquals(len(d), 1)
-        self.assertEquals(d[0][0], "127.0.0.1")
-        self.assertEquals(d[0][1], master_port)
+        self.assertEqual(len(d), 1)
+        self.assertEqual(d[0][0], "127.0.0.1")
+        self.assertEqual(d[0][1], master_port)
         self.assertTrue((d[0][2]==db.DB_REPMGR_CONNECTED) or \
                 (d[0][2]==db.DB_REPMGR_DISCONNECTED))
 
@@ -207,7 +207,7 @@
             self.skipTest("replication test skipped due to random failure, "
                 "see issue 3892")
         self.assertTrue(time.time()<timeout)
-        self.assertEquals("123", v)
+        self.assertEqual("123", v)
 
         txn=self.dbenvMaster.txn_begin()
         self.dbMaster.delete("ABC", txn=txn)
@@ -220,7 +220,7 @@
             if v is None :
                 time.sleep(0.02)
         self.assertTrue(time.time()<timeout)
-        self.assertEquals(None, v)
+        self.assertEqual(None, v)
 
 class DBBaseReplication(DBReplication) :
     def setUp(self) :
@@ -253,8 +253,8 @@
         self.dbenvClient.rep_set_transport(3,c2m)
         self.dbenvClient.rep_set_priority(0)
 
-        self.assertEquals(self.dbenvMaster.rep_get_priority(),10)
-        self.assertEquals(self.dbenvClient.rep_get_priority(),0)
+        self.assertEqual(self.dbenvMaster.rep_get_priority(),10)
+        self.assertEqual(self.dbenvClient.rep_get_priority(),0)
 
         #self.dbenvMaster.set_verbose(db.DB_VERB_REPLICATION, True)
         #self.dbenvMaster.set_verbose(db.DB_VERB_FILEOPS_ALL, True)
@@ -384,7 +384,7 @@
             if v is None :
                 time.sleep(0.02)
         self.assertTrue(time.time()<timeout)
-        self.assertEquals("123", v)
+        self.assertEqual("123", v)
 
         txn=self.dbenvMaster.txn_begin()
         self.dbMaster.delete("ABC", txn=txn)
@@ -397,7 +397,7 @@
             if v is None :
                 time.sleep(0.02)
         self.assertTrue(time.time()<timeout)
-        self.assertEquals(None, v)
+        self.assertEqual(None, v)
 
     if db.version() >= (4,7) :
         def test02_test_request(self) :
diff --git a/lib-python/2.7.0/bsddb/test/test_sequence.py b/lib-python/2.7/bsddb/test/test_sequence.py
rename from lib-python/2.7.0/bsddb/test/test_sequence.py
rename to lib-python/2.7/bsddb/test/test_sequence.py
--- a/lib-python/2.7.0/bsddb/test/test_sequence.py
+++ b/lib-python/2.7/bsddb/test/test_sequence.py
@@ -37,53 +37,53 @@
         self.seq = db.DBSequence(self.d, flags=0)
         start_value = 10 * self.int_32_max
         self.assertEqual(0xA00000000, start_value)
-        self.assertEquals(None, self.seq.initial_value(start_value))
-        self.assertEquals(None, self.seq.open(key='id', txn=None, flags=db.DB_CREATE))
-        self.assertEquals(start_value, self.seq.get(5))
-        self.assertEquals(start_value + 5, self.seq.get())
+        self.assertEqual(None, self.seq.initial_value(start_value))
+        self.assertEqual(None, self.seq.open(key='id', txn=None, flags=db.DB_CREATE))
+        self.assertEqual(start_value, self.seq.get(5))
+        self.assertEqual(start_value + 5, self.seq.get())
 
     def test_remove(self):
         self.seq = db.DBSequence(self.d, flags=0)
-        self.assertEquals(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE))
-        self.assertEquals(None, self.seq.remove(txn=None, flags=0))
+        self.assertEqual(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE))
+        self.assertEqual(None, self.seq.remove(txn=None, flags=0))
         del self.seq
 
     def test_get_key(self):
         self.seq = db.DBSequence(self.d, flags=0)
         key = 'foo'
-        self.assertEquals(None, self.seq.open(key=key, txn=None, flags=db.DB_CREATE))
-        self.assertEquals(key, self.seq.get_key())
+        self.assertEqual(None, self.seq.open(key=key, txn=None, flags=db.DB_CREATE))
+        self.assertEqual(key, self.seq.get_key())
 
     def test_get_dbp(self):
         self.seq = db.DBSequence(self.d, flags=0)
-        self.assertEquals(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE))
-        self.assertEquals(self.d, self.seq.get_dbp())
+        self.assertEqual(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE))
+        self.assertEqual(self.d, self.seq.get_dbp())
 
     def test_cachesize(self):
         self.seq = db.DBSequence(self.d, flags=0)
         cashe_size = 10
-        self.assertEquals(None, self.seq.set_cachesize(cashe_size))
-        self.assertEquals(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE))
-        self.assertEquals(cashe_size, self.seq.get_cachesize())
+        self.assertEqual(None, self.seq.set_cachesize(cashe_size))
+        self.assertEqual(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE))
+        self.assertEqual(cashe_size, self.seq.get_cachesize())
 
     def test_flags(self):
         self.seq = db.DBSequence(self.d, flags=0)
         flag = db.DB_SEQ_WRAP;
-        self.assertEquals(None, self.seq.set_flags(flag))
-        self.assertEquals(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE))
-        self.assertEquals(flag, self.seq.get_flags() & flag)
+        self.assertEqual(None, self.seq.set_flags(flag))
+        self.assertEqual(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE))
+        self.assertEqual(flag, self.seq.get_flags() & flag)
 
     def test_range(self):
         self.seq = db.DBSequence(self.d, flags=0)
         seq_range = (10 * self.int_32_max, 11 * self.int_32_max - 1)
-        self.assertEquals(None, self.seq.set_range(seq_range))
+        self.assertEqual(None, self.seq.set_range(seq_range))
         self.seq.initial_value(seq_range[0])
-        self.assertEquals(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE))
-        self.assertEquals(seq_range, self.seq.get_range())
+        self.assertEqual(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE))
+        self.assertEqual(seq_range, self.seq.get_range())
 
     def test_stat(self):
         self.seq = db.DBSequence(self.d, flags=0)
-        self.assertEquals(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE))
+        self.assertEqual(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE))
         stat = self.seq.stat()
         for param in ('nowait', 'min', 'max', 'value', 'current',
                       'flags', 'cache_size', 'last_value', 'wait'):
@@ -106,24 +106,24 @@
     def test_64bits(self) :
         # We don't use both extremes because they are problematic
         value_plus=(1L<<63)-2
-        self.assertEquals(9223372036854775806L,value_plus)
+        self.assertEqual(9223372036854775806L,value_plus)
         value_minus=(-1L<<63)+1  # Two complement
-        self.assertEquals(-9223372036854775807L,value_minus)
+        self.assertEqual(-9223372036854775807L,value_minus)
         self.seq = db.DBSequence(self.d, flags=0)
-        self.assertEquals(None, self.seq.initial_value(value_plus-1))
-        self.assertEquals(None, self.seq.open(key='id', txn=None,
+        self.assertEqual(None, self.seq.initial_value(value_plus-1))
+        self.assertEqual(None, self.seq.open(key='id', txn=None,
             flags=db.DB_CREATE))
-        self.assertEquals(value_plus-1, self.seq.get(1))
-        self.assertEquals(value_plus, self.seq.get(1))
+        self.assertEqual(value_plus-1, self.seq.get(1))
+        self.assertEqual(value_plus, self.seq.get(1))
 
         self.seq.remove(txn=None, flags=0)
 
         self.seq = db.DBSequence(self.d, flags=0)
-        self.assertEquals(None, self.seq.initial_value(value_minus))
-        self.assertEquals(None, self.seq.open(key='id', txn=None,
+        self.assertEqual(None, self.seq.initial_value(value_minus))
+        self.assertEqual(None, self.seq.open(key='id', txn=None,
             flags=db.DB_CREATE))
-        self.assertEquals(value_minus, self.seq.get(1))
-        self.assertEquals(value_minus+1, self.seq.get(1))
+        self.assertEqual(value_minus, self.seq.get(1))
+        self.assertEqual(value_minus+1, self.seq.get(1))
 
     def test_multiple_close(self):
         self.seq = db.DBSequence(self.d)
diff --git a/lib-python/2.7.0/bsddb/test/test_thread.py b/lib-python/2.7/bsddb/test/test_thread.py
rename from lib-python/2.7.0/bsddb/test/test_thread.py
rename to lib-python/2.7/bsddb/test/test_thread.py
diff --git a/lib-python/2.7.0/cProfile.py b/lib-python/2.7/cProfile.py
rename from lib-python/2.7.0/cProfile.py
rename to lib-python/2.7/cProfile.py
diff --git a/lib-python/2.7.0/calendar.py b/lib-python/2.7/calendar.py
rename from lib-python/2.7.0/calendar.py
rename to lib-python/2.7/calendar.py
--- a/lib-python/2.7.0/calendar.py
+++ b/lib-python/2.7/calendar.py
@@ -486,8 +486,8 @@
         self.locale = locale
 
     def __enter__(self):
-        self.oldlocale = _locale.setlocale(_locale.LC_TIME, self.locale)
-        return _locale.getlocale(_locale.LC_TIME)[1]
+        self.oldlocale = _locale.getlocale(_locale.LC_TIME)
+        _locale.setlocale(_locale.LC_TIME, self.locale)
 
     def __exit__(self, *args):
         _locale.setlocale(_locale.LC_TIME, self.oldlocale)
diff --git a/lib-python/2.7.0/cgi.py b/lib-python/2.7/cgi.py
rename from lib-python/2.7.0/cgi.py
rename to lib-python/2.7/cgi.py
diff --git a/lib-python/2.7.0/cgitb.py b/lib-python/2.7/cgitb.py
rename from lib-python/2.7.0/cgitb.py
rename to lib-python/2.7/cgitb.py
diff --git a/lib-python/2.7.0/chunk.py b/lib-python/2.7/chunk.py
rename from lib-python/2.7.0/chunk.py
rename to lib-python/2.7/chunk.py
diff --git a/lib-python/2.7.0/cmd.py b/lib-python/2.7/cmd.py
rename from lib-python/2.7.0/cmd.py
rename to lib-python/2.7/cmd.py
diff --git a/lib-python/2.7.0/code.py b/lib-python/2.7/code.py
rename from lib-python/2.7.0/code.py
rename to lib-python/2.7/code.py
diff --git a/lib-python/2.7.0/codecs.py b/lib-python/2.7/codecs.py
rename from lib-python/2.7.0/codecs.py
rename to lib-python/2.7/codecs.py
diff --git a/lib-python/2.7.0/codeop.py b/lib-python/2.7/codeop.py
rename from lib-python/2.7.0/codeop.py
rename to lib-python/2.7/codeop.py
diff --git a/lib-python/2.7.0/collections.py b/lib-python/2.7/collections.py
rename from lib-python/2.7.0/collections.py
rename to lib-python/2.7/collections.py
diff --git a/lib-python/2.7.0/colorsys.py b/lib-python/2.7/colorsys.py
rename from lib-python/2.7.0/colorsys.py
rename to lib-python/2.7/colorsys.py
diff --git a/lib-python/2.7.0/commands.py b/lib-python/2.7/commands.py
rename from lib-python/2.7.0/commands.py
rename to lib-python/2.7/commands.py
diff --git a/lib-python/2.7.0/compileall.py b/lib-python/2.7/compileall.py
rename from lib-python/2.7.0/compileall.py
rename to lib-python/2.7/compileall.py
diff --git a/lib-python/2.7.0/compiler/__init__.py b/lib-python/2.7/compiler/__init__.py
rename from lib-python/2.7.0/compiler/__init__.py
rename to lib-python/2.7/compiler/__init__.py
diff --git a/lib-python/2.7.0/compiler/ast.py b/lib-python/2.7/compiler/ast.py
rename from lib-python/2.7.0/compiler/ast.py
rename to lib-python/2.7/compiler/ast.py
diff --git a/lib-python/2.7.0/compiler/consts.py b/lib-python/2.7/compiler/consts.py
rename from lib-python/2.7.0/compiler/consts.py
rename to lib-python/2.7/compiler/consts.py
diff --git a/lib-python/2.7.0/compiler/future.py b/lib-python/2.7/compiler/future.py
rename from lib-python/2.7.0/compiler/future.py
rename to lib-python/2.7/compiler/future.py
diff --git a/lib-python/2.7.0/compiler/misc.py b/lib-python/2.7/compiler/misc.py
rename from lib-python/2.7.0/compiler/misc.py
rename to lib-python/2.7/compiler/misc.py
diff --git a/lib-python/2.7.0/compiler/pyassem.py b/lib-python/2.7/compiler/pyassem.py
rename from lib-python/2.7.0/compiler/pyassem.py
rename to lib-python/2.7/compiler/pyassem.py
diff --git a/lib-python/2.7.0/compiler/pycodegen.py b/lib-python/2.7/compiler/pycodegen.py
rename from lib-python/2.7.0/compiler/pycodegen.py
rename to lib-python/2.7/compiler/pycodegen.py
diff --git a/lib-python/2.7.0/compiler/symbols.py b/lib-python/2.7/compiler/symbols.py
rename from lib-python/2.7.0/compiler/symbols.py
rename to lib-python/2.7/compiler/symbols.py
diff --git a/lib-python/2.7.0/compiler/syntax.py b/lib-python/2.7/compiler/syntax.py
rename from lib-python/2.7.0/compiler/syntax.py
rename to lib-python/2.7/compiler/syntax.py
diff --git a/lib-python/2.7.0/compiler/transformer.py b/lib-python/2.7/compiler/transformer.py
rename from lib-python/2.7.0/compiler/transformer.py
rename to lib-python/2.7/compiler/transformer.py
diff --git a/lib-python/2.7.0/compiler/visitor.py b/lib-python/2.7/compiler/visitor.py
rename from lib-python/2.7.0/compiler/visitor.py
rename to lib-python/2.7/compiler/visitor.py
diff --git a/lib-python/2.7.0/contextlib.py b/lib-python/2.7/contextlib.py
rename from lib-python/2.7.0/contextlib.py
rename to lib-python/2.7/contextlib.py
diff --git a/lib-python/2.7.0/cookielib.py b/lib-python/2.7/cookielib.py
rename from lib-python/2.7.0/cookielib.py
rename to lib-python/2.7/cookielib.py
diff --git a/lib-python/2.7.0/copy.py b/lib-python/2.7/copy.py
rename from lib-python/2.7.0/copy.py
rename to lib-python/2.7/copy.py
diff --git a/lib-python/2.7.0/copy_reg.py b/lib-python/2.7/copy_reg.py
rename from lib-python/2.7.0/copy_reg.py
rename to lib-python/2.7/copy_reg.py
diff --git a/lib-python/2.7.0/csv.py b/lib-python/2.7/csv.py
rename from lib-python/2.7.0/csv.py
rename to lib-python/2.7/csv.py
diff --git a/lib-python/2.7.0/ctypes/__init__.py b/lib-python/2.7/ctypes/__init__.py
rename from lib-python/2.7.0/ctypes/__init__.py
rename to lib-python/2.7/ctypes/__init__.py
diff --git a/lib-python/2.7.0/ctypes/_endian.py b/lib-python/2.7/ctypes/_endian.py
rename from lib-python/2.7.0/ctypes/_endian.py
rename to lib-python/2.7/ctypes/_endian.py
diff --git a/lib-python/2.7.0/ctypes/macholib/README.ctypes b/lib-python/2.7/ctypes/macholib/README.ctypes
rename from lib-python/2.7.0/ctypes/macholib/README.ctypes
rename to lib-python/2.7/ctypes/macholib/README.ctypes
diff --git a/lib-python/2.7.0/ctypes/macholib/__init__.py b/lib-python/2.7/ctypes/macholib/__init__.py
rename from lib-python/2.7.0/ctypes/macholib/__init__.py
rename to lib-python/2.7/ctypes/macholib/__init__.py
diff --git a/lib-python/2.7.0/ctypes/macholib/dyld.py b/lib-python/2.7/ctypes/macholib/dyld.py
rename from lib-python/2.7.0/ctypes/macholib/dyld.py
rename to lib-python/2.7/ctypes/macholib/dyld.py
diff --git a/lib-python/2.7.0/ctypes/macholib/dylib.py b/lib-python/2.7/ctypes/macholib/dylib.py
rename from lib-python/2.7.0/ctypes/macholib/dylib.py
rename to lib-python/2.7/ctypes/macholib/dylib.py
diff --git a/lib-python/2.7.0/ctypes/macholib/fetch_macholib b/lib-python/2.7/ctypes/macholib/fetch_macholib
rename from lib-python/2.7.0/ctypes/macholib/fetch_macholib
rename to lib-python/2.7/ctypes/macholib/fetch_macholib
diff --git a/lib-python/2.7.0/ctypes/macholib/fetch_macholib.bat b/lib-python/2.7/ctypes/macholib/fetch_macholib.bat
rename from lib-python/2.7.0/ctypes/macholib/fetch_macholib.bat
rename to lib-python/2.7/ctypes/macholib/fetch_macholib.bat
diff --git a/lib-python/2.7.0/ctypes/macholib/framework.py b/lib-python/2.7/ctypes/macholib/framework.py
rename from lib-python/2.7.0/ctypes/macholib/framework.py
rename to lib-python/2.7/ctypes/macholib/framework.py
diff --git a/lib-python/2.7.0/ctypes/test/__init__.py b/lib-python/2.7/ctypes/test/__init__.py
rename from lib-python/2.7.0/ctypes/test/__init__.py
rename to lib-python/2.7/ctypes/test/__init__.py
diff --git a/lib-python/2.7.0/ctypes/test/runtests.py b/lib-python/2.7/ctypes/test/runtests.py
rename from lib-python/2.7.0/ctypes/test/runtests.py
rename to lib-python/2.7/ctypes/test/runtests.py
diff --git a/lib-python/2.7.0/ctypes/test/test_anon.py b/lib-python/2.7/ctypes/test/test_anon.py
rename from lib-python/2.7.0/ctypes/test/test_anon.py
rename to lib-python/2.7/ctypes/test/test_anon.py
diff --git a/lib-python/2.7.0/ctypes/test/test_array_in_pointer.py b/lib-python/2.7/ctypes/test/test_array_in_pointer.py
rename from lib-python/2.7.0/ctypes/test/test_array_in_pointer.py
rename to lib-python/2.7/ctypes/test/test_array_in_pointer.py
diff --git a/lib-python/2.7.0/ctypes/test/test_arrays.py b/lib-python/2.7/ctypes/test/test_arrays.py
rename from lib-python/2.7.0/ctypes/test/test_arrays.py
rename to lib-python/2.7/ctypes/test/test_arrays.py
diff --git a/lib-python/2.7.0/ctypes/test/test_as_parameter.py b/lib-python/2.7/ctypes/test/test_as_parameter.py
rename from lib-python/2.7.0/ctypes/test/test_as_parameter.py
rename to lib-python/2.7/ctypes/test/test_as_parameter.py
diff --git a/lib-python/2.7.0/ctypes/test/test_bitfields.py b/lib-python/2.7/ctypes/test/test_bitfields.py
rename from lib-python/2.7.0/ctypes/test/test_bitfields.py
rename to lib-python/2.7/ctypes/test/test_bitfields.py
diff --git a/lib-python/2.7.0/ctypes/test/test_buffers.py b/lib-python/2.7/ctypes/test/test_buffers.py
rename from lib-python/2.7.0/ctypes/test/test_buffers.py
rename to lib-python/2.7/ctypes/test/test_buffers.py
diff --git a/lib-python/2.7.0/ctypes/test/test_byteswap.py b/lib-python/2.7/ctypes/test/test_byteswap.py
rename from lib-python/2.7.0/ctypes/test/test_byteswap.py
rename to lib-python/2.7/ctypes/test/test_byteswap.py
diff --git a/lib-python/2.7.0/ctypes/test/test_callbacks.py b/lib-python/2.7/ctypes/test/test_callbacks.py
rename from lib-python/2.7.0/ctypes/test/test_callbacks.py
rename to lib-python/2.7/ctypes/test/test_callbacks.py
diff --git a/lib-python/2.7.0/ctypes/test/test_cast.py b/lib-python/2.7/ctypes/test/test_cast.py
rename from lib-python/2.7.0/ctypes/test/test_cast.py
rename to lib-python/2.7/ctypes/test/test_cast.py
diff --git a/lib-python/2.7.0/ctypes/test/test_cfuncs.py b/lib-python/2.7/ctypes/test/test_cfuncs.py
rename from lib-python/2.7.0/ctypes/test/test_cfuncs.py
rename to lib-python/2.7/ctypes/test/test_cfuncs.py
diff --git a/lib-python/2.7.0/ctypes/test/test_checkretval.py b/lib-python/2.7/ctypes/test/test_checkretval.py
rename from lib-python/2.7.0/ctypes/test/test_checkretval.py
rename to lib-python/2.7/ctypes/test/test_checkretval.py
diff --git a/lib-python/2.7.0/ctypes/test/test_delattr.py b/lib-python/2.7/ctypes/test/test_delattr.py
rename from lib-python/2.7.0/ctypes/test/test_delattr.py
rename to lib-python/2.7/ctypes/test/test_delattr.py
diff --git a/lib-python/2.7.0/ctypes/test/test_errcheck.py b/lib-python/2.7/ctypes/test/test_errcheck.py
rename from lib-python/2.7.0/ctypes/test/test_errcheck.py
rename to lib-python/2.7/ctypes/test/test_errcheck.py
diff --git a/lib-python/2.7.0/ctypes/test/test_errno.py b/lib-python/2.7/ctypes/test/test_errno.py
rename from lib-python/2.7.0/ctypes/test/test_errno.py
rename to lib-python/2.7/ctypes/test/test_errno.py
diff --git a/lib-python/2.7.0/ctypes/test/test_find.py b/lib-python/2.7/ctypes/test/test_find.py
rename from lib-python/2.7.0/ctypes/test/test_find.py
rename to lib-python/2.7/ctypes/test/test_find.py
diff --git a/lib-python/2.7.0/ctypes/test/test_frombuffer.py b/lib-python/2.7/ctypes/test/test_frombuffer.py
rename from lib-python/2.7.0/ctypes/test/test_frombuffer.py
rename to lib-python/2.7/ctypes/test/test_frombuffer.py
diff --git a/lib-python/2.7.0/ctypes/test/test_funcptr.py b/lib-python/2.7/ctypes/test/test_funcptr.py
rename from lib-python/2.7.0/ctypes/test/test_funcptr.py
rename to lib-python/2.7/ctypes/test/test_funcptr.py
diff --git a/lib-python/2.7.0/ctypes/test/test_functions.py b/lib-python/2.7/ctypes/test/test_functions.py
rename from lib-python/2.7.0/ctypes/test/test_functions.py
rename to lib-python/2.7/ctypes/test/test_functions.py
diff --git a/lib-python/2.7.0/ctypes/test/test_incomplete.py b/lib-python/2.7/ctypes/test/test_incomplete.py
rename from lib-python/2.7.0/ctypes/test/test_incomplete.py
rename to lib-python/2.7/ctypes/test/test_incomplete.py
diff --git a/lib-python/2.7.0/ctypes/test/test_init.py b/lib-python/2.7/ctypes/test/test_init.py
rename from lib-python/2.7.0/ctypes/test/test_init.py
rename to lib-python/2.7/ctypes/test/test_init.py
diff --git a/lib-python/2.7.0/ctypes/test/test_integers.py b/lib-python/2.7/ctypes/test/test_integers.py
rename from lib-python/2.7.0/ctypes/test/test_integers.py
rename to lib-python/2.7/ctypes/test/test_integers.py
diff --git a/lib-python/2.7.0/ctypes/test/test_internals.py b/lib-python/2.7/ctypes/test/test_internals.py
rename from lib-python/2.7.0/ctypes/test/test_internals.py
rename to lib-python/2.7/ctypes/test/test_internals.py
diff --git a/lib-python/2.7.0/ctypes/test/test_keeprefs.py b/lib-python/2.7/ctypes/test/test_keeprefs.py
rename from lib-python/2.7.0/ctypes/test/test_keeprefs.py
rename to lib-python/2.7/ctypes/test/test_keeprefs.py
--- a/lib-python/2.7.0/ctypes/test/test_keeprefs.py
+++ b/lib-python/2.7/ctypes/test/test_keeprefs.py
@@ -4,19 +4,19 @@
 class SimpleTestCase(unittest.TestCase):
     def test_cint(self):
         x = c_int()
-        self.assertEquals(x._objects, None)
+        self.assertEqual(x._objects, None)
         x.value = 42
-        self.assertEquals(x._objects, None)
+        self.assertEqual(x._objects, None)
         x = c_int(99)
-        self.assertEquals(x._objects, None)
+        self.assertEqual(x._objects, None)
 
     def test_ccharp(self):
         x = c_char_p()
-        self.assertEquals(x._objects, None)
+        self.assertEqual(x._objects, None)
         x.value = "abc"
-        self.assertEquals(x._objects, "abc")
+        self.assertEqual(x._objects, "abc")
         x = c_char_p("spam")
-        self.assertEquals(x._objects, "spam")
+        self.assertEqual(x._objects, "spam")
 
 class StructureTestCase(unittest.TestCase):
     def test_cint_struct(self):
@@ -25,21 +25,21 @@
                         ("b", c_int)]
 
         x = X()
-        self.assertEquals(x._objects, None)
+        self.assertEqual(x._objects, None)
         x.a = 42
         x.b = 99
-        self.assertEquals(x._objects, None)
+        self.assertEqual(x._objects, None)
 
     def test_ccharp_struct(self):
         class X(Structure):
             _fields_ = [("a", c_char_p),
                         ("b", c_char_p)]
         x = X()
-        self.assertEquals(x._objects, None)
+        self.assertEqual(x._objects, None)
 
         x.a = "spam"
         x.b = "foo"
-        self.assertEquals(x._objects, {"0": "spam", "1": "foo"})
+        self.assertEqual(x._objects, {"0": "spam", "1": "foo"})
 
     def test_struct_struct(self):
         class POINT(Structure):
@@ -52,28 +52,28 @@
         r.ul.y = 1
         r.lr.x = 2
         r.lr.y = 3
-        self.assertEquals(r._objects, None)
+        self.assertEqual(r._objects, None)
 
         r = RECT()
         pt = POINT(1, 2)
         r.ul = pt
-        self.assertEquals(r._objects, {'0': {}})
+        self.assertEqual(r._objects, {'0': {}})
         r.ul.x = 22
         r.ul.y = 44
-        self.assertEquals(r._objects, {'0': {}})
+        self.assertEqual(r._objects, {'0': {}})
         r.lr = POINT()
-        self.assertEquals(r._objects, {'0': {}, '1': {}})
+        self.assertEqual(r._objects, {'0': {}, '1': {}})
 
 class ArrayTestCase(unittest.TestCase):
     def test_cint_array(self):
         INTARR = c_int * 3
 
         ia = INTARR()
-        self.assertEquals(ia._objects, None)
+        self.assertEqual(ia._objects, None)
         ia[0] = 1
         ia[1] = 2
         ia[2] = 3
-        self.assertEquals(ia._objects, None)
+        self.assertEqual(ia._objects, None)
 
         class X(Structure):
             _fields_ = [("x", c_int),
@@ -83,9 +83,9 @@
         x.x = 1000
         x.a[0] = 42
         x.a[1] = 96
-        self.assertEquals(x._objects, None)
+        self.assertEqual(x._objects, None)
         x.a = ia
-        self.assertEquals(x._objects, {'1': {}})
+        self.assertEqual(x._objects, {'1': {}})
 
 class PointerTestCase(unittest.TestCase):
     def test_p_cint(self):
diff --git a/lib-python/2.7.0/ctypes/test/test_libc.py b/lib-python/2.7/ctypes/test/test_libc.py
rename from lib-python/2.7.0/ctypes/test/test_libc.py
rename to lib-python/2.7/ctypes/test/test_libc.py
diff --git a/lib-python/2.7.0/ctypes/test/test_loading.py b/lib-python/2.7/ctypes/test/test_loading.py
rename from lib-python/2.7.0/ctypes/test/test_loading.py
rename to lib-python/2.7/ctypes/test/test_loading.py
diff --git a/lib-python/2.7.0/ctypes/test/test_macholib.py b/lib-python/2.7/ctypes/test/test_macholib.py
rename from lib-python/2.7.0/ctypes/test/test_macholib.py
rename to lib-python/2.7/ctypes/test/test_macholib.py
diff --git a/lib-python/2.7.0/ctypes/test/test_memfunctions.py b/lib-python/2.7/ctypes/test/test_memfunctions.py
rename from lib-python/2.7.0/ctypes/test/test_memfunctions.py
rename to lib-python/2.7/ctypes/test/test_memfunctions.py
diff --git a/lib-python/2.7.0/ctypes/test/test_numbers.py b/lib-python/2.7/ctypes/test/test_numbers.py
rename from lib-python/2.7.0/ctypes/test/test_numbers.py
rename to lib-python/2.7/ctypes/test/test_numbers.py
diff --git a/lib-python/2.7.0/ctypes/test/test_objects.py b/lib-python/2.7/ctypes/test/test_objects.py
rename from lib-python/2.7.0/ctypes/test/test_objects.py
rename to lib-python/2.7/ctypes/test/test_objects.py
diff --git a/lib-python/2.7.0/ctypes/test/test_parameters.py b/lib-python/2.7/ctypes/test/test_parameters.py
rename from lib-python/2.7.0/ctypes/test/test_parameters.py
rename to lib-python/2.7/ctypes/test/test_parameters.py
diff --git a/lib-python/2.7.0/ctypes/test/test_pep3118.py b/lib-python/2.7/ctypes/test/test_pep3118.py
rename from lib-python/2.7.0/ctypes/test/test_pep3118.py
rename to lib-python/2.7/ctypes/test/test_pep3118.py
diff --git a/lib-python/2.7.0/ctypes/test/test_pickling.py b/lib-python/2.7/ctypes/test/test_pickling.py
rename from lib-python/2.7.0/ctypes/test/test_pickling.py
rename to lib-python/2.7/ctypes/test/test_pickling.py
diff --git a/lib-python/2.7.0/ctypes/test/test_pointers.py b/lib-python/2.7/ctypes/test/test_pointers.py
rename from lib-python/2.7.0/ctypes/test/test_pointers.py
rename to lib-python/2.7/ctypes/test/test_pointers.py
diff --git a/lib-python/2.7.0/ctypes/test/test_prototypes.py b/lib-python/2.7/ctypes/test/test_prototypes.py
rename from lib-python/2.7.0/ctypes/test/test_prototypes.py
rename to lib-python/2.7/ctypes/test/test_prototypes.py
diff --git a/lib-python/2.7.0/ctypes/test/test_python_api.py b/lib-python/2.7/ctypes/test/test_python_api.py
rename from lib-python/2.7.0/ctypes/test/test_python_api.py
rename to lib-python/2.7/ctypes/test/test_python_api.py
diff --git a/lib-python/2.7.0/ctypes/test/test_random_things.py b/lib-python/2.7/ctypes/test/test_random_things.py
rename from lib-python/2.7.0/ctypes/test/test_random_things.py
rename to lib-python/2.7/ctypes/test/test_random_things.py
diff --git a/lib-python/2.7.0/ctypes/test/test_refcounts.py b/lib-python/2.7/ctypes/test/test_refcounts.py
rename from lib-python/2.7.0/ctypes/test/test_refcounts.py
rename to lib-python/2.7/ctypes/test/test_refcounts.py
diff --git a/lib-python/2.7.0/ctypes/test/test_repr.py b/lib-python/2.7/ctypes/test/test_repr.py
rename from lib-python/2.7.0/ctypes/test/test_repr.py
rename to lib-python/2.7/ctypes/test/test_repr.py
diff --git a/lib-python/2.7.0/ctypes/test/test_returnfuncptrs.py b/lib-python/2.7/ctypes/test/test_returnfuncptrs.py
rename from lib-python/2.7.0/ctypes/test/test_returnfuncptrs.py
rename to lib-python/2.7/ctypes/test/test_returnfuncptrs.py
diff --git a/lib-python/2.7.0/ctypes/test/test_simplesubclasses.py b/lib-python/2.7/ctypes/test/test_simplesubclasses.py
rename from lib-python/2.7.0/ctypes/test/test_simplesubclasses.py
rename to lib-python/2.7/ctypes/test/test_simplesubclasses.py
diff --git a/lib-python/2.7.0/ctypes/test/test_sizes.py b/lib-python/2.7/ctypes/test/test_sizes.py
rename from lib-python/2.7.0/ctypes/test/test_sizes.py
rename to lib-python/2.7/ctypes/test/test_sizes.py
diff --git a/lib-python/2.7.0/ctypes/test/test_slicing.py b/lib-python/2.7/ctypes/test/test_slicing.py
rename from lib-python/2.7.0/ctypes/test/test_slicing.py
rename to lib-python/2.7/ctypes/test/test_slicing.py
diff --git a/lib-python/2.7.0/ctypes/test/test_stringptr.py b/lib-python/2.7/ctypes/test/test_stringptr.py
rename from lib-python/2.7.0/ctypes/test/test_stringptr.py
rename to lib-python/2.7/ctypes/test/test_stringptr.py
diff --git a/lib-python/2.7.0/ctypes/test/test_strings.py b/lib-python/2.7/ctypes/test/test_strings.py
rename from lib-python/2.7.0/ctypes/test/test_strings.py
rename to lib-python/2.7/ctypes/test/test_strings.py
diff --git a/lib-python/2.7.0/ctypes/test/test_struct_fields.py b/lib-python/2.7/ctypes/test/test_struct_fields.py
rename from lib-python/2.7.0/ctypes/test/test_struct_fields.py
rename to lib-python/2.7/ctypes/test/test_struct_fields.py
diff --git a/lib-python/2.7.0/ctypes/test/test_structures.py b/lib-python/2.7/ctypes/test/test_structures.py
rename from lib-python/2.7.0/ctypes/test/test_structures.py
rename to lib-python/2.7/ctypes/test/test_structures.py
diff --git a/lib-python/2.7.0/ctypes/test/test_unaligned_structures.py b/lib-python/2.7/ctypes/test/test_unaligned_structures.py
rename from lib-python/2.7.0/ctypes/test/test_unaligned_structures.py
rename to lib-python/2.7/ctypes/test/test_unaligned_structures.py
diff --git a/lib-python/2.7.0/ctypes/test/test_unicode.py b/lib-python/2.7/ctypes/test/test_unicode.py
rename from lib-python/2.7.0/ctypes/test/test_unicode.py
rename to lib-python/2.7/ctypes/test/test_unicode.py
diff --git a/lib-python/2.7.0/ctypes/test/test_values.py b/lib-python/2.7/ctypes/test/test_values.py
rename from lib-python/2.7.0/ctypes/test/test_values.py
rename to lib-python/2.7/ctypes/test/test_values.py
diff --git a/lib-python/2.7.0/ctypes/test/test_varsize_struct.py b/lib-python/2.7/ctypes/test/test_varsize_struct.py
rename from lib-python/2.7.0/ctypes/test/test_varsize_struct.py
rename to lib-python/2.7/ctypes/test/test_varsize_struct.py
diff --git a/lib-python/2.7.0/ctypes/test/test_win32.py b/lib-python/2.7/ctypes/test/test_win32.py
rename from lib-python/2.7.0/ctypes/test/test_win32.py
rename to lib-python/2.7/ctypes/test/test_win32.py
diff --git a/lib-python/2.7.0/ctypes/util.py b/lib-python/2.7/ctypes/util.py
rename from lib-python/2.7.0/ctypes/util.py
rename to lib-python/2.7/ctypes/util.py
diff --git a/lib-python/2.7.0/ctypes/wintypes.py b/lib-python/2.7/ctypes/wintypes.py
rename from lib-python/2.7.0/ctypes/wintypes.py
rename to lib-python/2.7/ctypes/wintypes.py
diff --git a/lib-python/2.7.0/curses/__init__.py b/lib-python/2.7/curses/__init__.py
rename from lib-python/2.7.0/curses/__init__.py
rename to lib-python/2.7/curses/__init__.py
--- a/lib-python/2.7.0/curses/__init__.py
+++ b/lib-python/2.7/curses/__init__.py
@@ -10,7 +10,7 @@
 
 """
 
-__revision__ = "$Id: __init__.py 61064 2008-02-25 16:29:58Z andrew.kuchling $"
+__revision__ = "$Id$"
 
 from _curses import *
 from curses.wrapper import wrapper
diff --git a/lib-python/2.7.0/curses/ascii.py b/lib-python/2.7/curses/ascii.py
rename from lib-python/2.7.0/curses/ascii.py
rename to lib-python/2.7/curses/ascii.py
diff --git a/lib-python/2.7.0/curses/has_key.py b/lib-python/2.7/curses/has_key.py
rename from lib-python/2.7.0/curses/has_key.py
rename to lib-python/2.7/curses/has_key.py
diff --git a/lib-python/2.7.0/curses/panel.py b/lib-python/2.7/curses/panel.py
rename from lib-python/2.7.0/curses/panel.py
rename to lib-python/2.7/curses/panel.py
--- a/lib-python/2.7.0/curses/panel.py
+++ b/lib-python/2.7/curses/panel.py
@@ -3,6 +3,6 @@
 Module for using panels with curses.
 """
 
-__revision__ = "$Id: panel.py 36560 2004-07-18 06:16:08Z tim_one $"
+__revision__ = "$Id$"
 
 from _curses_panel import *
diff --git a/lib-python/2.7.0/curses/textpad.py b/lib-python/2.7/curses/textpad.py
rename from lib-python/2.7.0/curses/textpad.py
rename to lib-python/2.7/curses/textpad.py
diff --git a/lib-python/2.7.0/curses/wrapper.py b/lib-python/2.7/curses/wrapper.py
rename from lib-python/2.7.0/curses/wrapper.py
rename to lib-python/2.7/curses/wrapper.py
diff --git a/lib-python/2.7.0/dbhash.py b/lib-python/2.7/dbhash.py
rename from lib-python/2.7.0/dbhash.py
rename to lib-python/2.7/dbhash.py
diff --git a/lib-python/2.7.0/decimal.py b/lib-python/2.7/decimal.py
rename from lib-python/2.7.0/decimal.py
rename to lib-python/2.7/decimal.py
diff --git a/lib-python/2.7.0/difflib.py b/lib-python/2.7/difflib.py
rename from lib-python/2.7.0/difflib.py
rename to lib-python/2.7/difflib.py
--- a/lib-python/2.7.0/difflib.py
+++ b/lib-python/2.7/difflib.py
@@ -151,7 +151,7 @@
         Return an upper bound on ratio() very quickly.
     """
 
-    def __init__(self, isjunk=None, a='', b=''):
+    def __init__(self, isjunk=None, a='', b='', autojunk=True):
         """Construct a SequenceMatcher.
 
         Optional arg isjunk is None (the default), or a one-argument
@@ -169,6 +169,10 @@
         Optional arg b is the second of two sequences to be compared.  By
         default, an empty string.  The elements of b must be hashable. See
         also .set_seqs() and .set_seq2().
+
+        Optional arg autojunk should be set to False to disable the
+        "automatic junk heuristic" that treats popular elements as junk
+        (see module documentation for more information).
         """
 
         # Members:
@@ -207,11 +211,13 @@
         #      DOES NOT WORK for x in a!
         # isbpopular
         #      for x in b, isbpopular(x) is true iff b is reasonably long
-        #      (at least 200 elements) and x accounts for more than 1% of
-        #      its elements.  DOES NOT WORK for x in a!
+        #      (at least 200 elements) and x accounts for more than 1 + 1% of
+        #      its elements (when autojunk is enabled).
+        #      DOES NOT WORK for x in a!
 
         self.isjunk = isjunk
         self.a = self.b = None
+        self.autojunk = autojunk
         self.set_seqs(a, b)
 
     def set_seqs(self, a, b):
@@ -288,7 +294,7 @@
     # from starting any matching block at a junk element ...
     # also creates the fast isbjunk function ...
     # b2j also does not contain entries for "popular" elements, meaning
-    # elements that account for more than 1% of the total elements, and
+    # elements that account for more than 1 + 1% of the total elements, and
     # when the sequence is reasonably large (>= 200 elements); this can
     # be viewed as an adaptive notion of semi-junk, and yields an enormous
     # speedup when, e.g., comparing program files with hundreds of
@@ -309,44 +315,37 @@
         # out the junk later is much cheaper than building b2j "right"
         # from the start.
         b = self.b
+        self.b2j = b2j = {}
+
+        for i, elt in enumerate(b):
+            indices = b2j.setdefault(elt, [])
+            indices.append(i)
+
+        # Purge junk elements
+        junk = set()
+        isjunk = self.isjunk
+        if isjunk:
+            for elt in list(b2j.keys()):  # using list() since b2j is modified
+                if isjunk(elt):
+                    junk.add(elt)
+                    del b2j[elt]
+
+        # Purge popular elements that are not junk
+        popular = set()
         n = len(b)
-        self.b2j = b2j = {}
-        populardict = {}
-        for i, elt in enumerate(b):
-            if elt in b2j:
-                indices = b2j[elt]
-                if n >= 200 and len(indices) * 100 > n:
-                    populardict[elt] = 1
-                    del indices[:]
-                else:
-                    indices.append(i)
-            else:
-                b2j[elt] = [i]
+        if self.autojunk and n >= 200:
+            ntest = n // 100 + 1
+            for elt, idxs in list(b2j.items()):
+                if len(idxs) > ntest:
+                    popular.add(elt)
+                    del b2j[elt]
 
-        # Purge leftover indices for popular elements.
-        for elt in populardict:
-            del b2j[elt]
-
-        # Now b2j.keys() contains elements uniquely, and especially when
-        # the sequence is a string, that's usually a good deal smaller
-        # than len(string).  The difference is the number of isjunk calls
-        # saved.
-        isjunk = self.isjunk
-        junkdict = {}
-        if isjunk:
-            for d in populardict, b2j:
-                for elt in d.keys():
-                    if isjunk(elt):
-                        junkdict[elt] = 1
-                        del d[elt]
-
-        # Now for x in b, isjunk(x) == x in junkdict, but the
-        # latter is much faster.  Note too that while there may be a
-        # lot of junk in the sequence, the number of *unique* junk
-        # elements is probably small.  So the memory burden of keeping
-        # this dict alive is likely trivial compared to the size of b2j.
-        self.isbjunk = junkdict.__contains__
-        self.isbpopular = populardict.__contains__
+        # Now for x in b, isjunk(x) == x in junk, but the latter is much faster.
+        # Sicne the number of *unique* junk elements is probably small, the
+        # memory burden of keeping this set alive is likely trivial compared to
+        # the size of b2j.
+        self.isbjunk = junk.__contains__
+        self.isbpopular = popular.__contains__
 
     def find_longest_match(self, alo, ahi, blo, bhi):
         """Find longest matching block in a[alo:ahi] and b[blo:bhi].
diff --git a/lib-python/2.7.0/dircache.py b/lib-python/2.7/dircache.py
rename from lib-python/2.7.0/dircache.py
rename to lib-python/2.7/dircache.py
diff --git a/lib-python/2.7.0/dis.py b/lib-python/2.7/dis.py
rename from lib-python/2.7.0/dis.py
rename to lib-python/2.7/dis.py
diff --git a/lib-python/2.7.0/distutils/README b/lib-python/2.7/distutils/README
rename from lib-python/2.7.0/distutils/README
rename to lib-python/2.7/distutils/README
--- a/lib-python/2.7.0/distutils/README
+++ b/lib-python/2.7/distutils/README
@@ -10,4 +10,4 @@
 
 WARNING : Distutils must remain compatible with 2.3
 
-$Id: README 70017 2009-02-27 12:53:34Z tarek.ziade $
+$Id$
diff --git a/lib-python/2.7.0/distutils/__init__.py b/lib-python/2.7/distutils/__init__.py
rename from lib-python/2.7.0/distutils/__init__.py
rename to lib-python/2.7/distutils/__init__.py
--- a/lib-python/2.7.0/distutils/__init__.py
+++ b/lib-python/2.7/distutils/__init__.py
@@ -8,12 +8,12 @@
    setup (...)
 """
 
-__revision__ = "$Id: __init__.py 82506 2010-07-03 14:51:25Z benjamin.peterson $"
+__revision__ = "$Id$"
 
 # Distutils version
 #
 # Updated automatically by the Python release process.
 #
 #--start constants--
-__version__ = "2.7.1a0"
+__version__ = "2.7.1"
 #--end constants--
diff --git a/lib-python/2.7.0/distutils/archive_util.py b/lib-python/2.7/distutils/archive_util.py
rename from lib-python/2.7.0/distutils/archive_util.py
rename to lib-python/2.7/distutils/archive_util.py
--- a/lib-python/2.7.0/distutils/archive_util.py
+++ b/lib-python/2.7/distutils/archive_util.py
@@ -3,7 +3,7 @@
 Utility functions for creating archive files (tarballs, zip files,
 that sort of thing)."""
 
-__revision__ = "$Id: archive_util.py 75659 2009-10-24 13:29:44Z tarek.ziade $"
+__revision__ = "$Id$"
 
 import os
 from warnings import warn
diff --git a/lib-python/2.7.0/distutils/bcppcompiler.py b/lib-python/2.7/distutils/bcppcompiler.py
rename from lib-python/2.7.0/distutils/bcppcompiler.py
rename to lib-python/2.7/distutils/bcppcompiler.py
--- a/lib-python/2.7.0/distutils/bcppcompiler.py
+++ b/lib-python/2.7/distutils/bcppcompiler.py
@@ -11,7 +11,7 @@
 # someone should sit down and factor out the common code as
 # WindowsCCompiler!  --GPW
 
-__revision__ = "$Id: bcppcompiler.py 76956 2009-12-21 01:22:46Z tarek.ziade $"
+__revision__ = "$Id$"
 
 import os
 
diff --git a/lib-python/2.7.0/distutils/ccompiler.py b/lib-python/2.7/distutils/ccompiler.py
rename from lib-python/2.7.0/distutils/ccompiler.py
rename to lib-python/2.7/distutils/ccompiler.py
--- a/lib-python/2.7.0/distutils/ccompiler.py
+++ b/lib-python/2.7/distutils/ccompiler.py
@@ -3,7 +3,7 @@
 Contains CCompiler, an abstract base class that defines the interface
 for the Distutils compiler abstraction model."""
 
-__revision__ = "$Id: ccompiler.py 77704 2010-01-23 09:23:15Z tarek.ziade $"
+__revision__ = "$Id$"
 
 import sys
 import os
@@ -794,14 +794,16 @@
             library_dirs = []
         fd, fname = tempfile.mkstemp(".c", funcname, text=True)
         f = os.fdopen(fd, "w")
-        for incl in includes:
-            f.write("""#include "%s"\n""" % incl)
-        f.write("""\
+        try:
+            for incl in includes:
+                f.write("""#include "%s"\n""" % incl)
+            f.write("""\
 main (int argc, char **argv) {
     %s();
 }
 """ % funcname)
-        f.close()
+        finally:
+            f.close()
         try:
             objects = self.compile([fname], include_dirs=include_dirs)
         except CompileError:
diff --git a/lib-python/2.7.0/distutils/cmd.py b/lib-python/2.7/distutils/cmd.py
rename from lib-python/2.7.0/distutils/cmd.py
rename to lib-python/2.7/distutils/cmd.py
--- a/lib-python/2.7.0/distutils/cmd.py
+++ b/lib-python/2.7/distutils/cmd.py
@@ -4,7 +4,7 @@
 in the distutils.command package.
 """
 
-__revision__ = "$Id: cmd.py 75192 2009-10-02 23:49:48Z tarek.ziade $"
+__revision__ = "$Id$"
 
 import sys, os, re
 from distutils.errors import DistutilsOptionError
diff --git a/lib-python/2.7.0/distutils/command/__init__.py b/lib-python/2.7/distutils/command/__init__.py
rename from lib-python/2.7.0/distutils/command/__init__.py
rename to lib-python/2.7/distutils/command/__init__.py
--- a/lib-python/2.7.0/distutils/command/__init__.py
+++ b/lib-python/2.7/distutils/command/__init__.py
@@ -3,7 +3,7 @@
 Package containing implementation of all the standard Distutils
 commands."""
 
-__revision__ = "$Id: __init__.py 71473 2009-04-11 14:55:07Z tarek.ziade $"
+__revision__ = "$Id$"
 
 __all__ = ['build',
            'build_py',
diff --git a/lib-python/2.7.0/distutils/command/bdist.py b/lib-python/2.7/distutils/command/bdist.py
rename from lib-python/2.7.0/distutils/command/bdist.py
rename to lib-python/2.7/distutils/command/bdist.py
--- a/lib-python/2.7.0/distutils/command/bdist.py
+++ b/lib-python/2.7/distutils/command/bdist.py
@@ -3,7 +3,7 @@
 Implements the Distutils 'bdist' command (create a built [binary]
 distribution)."""
 
-__revision__ = "$Id: bdist.py 77761 2010-01-26 22:46:15Z tarek.ziade $"
+__revision__ = "$Id$"
 
 import os
 
diff --git a/lib-python/2.7.0/distutils/command/bdist_dumb.py b/lib-python/2.7/distutils/command/bdist_dumb.py
rename from lib-python/2.7.0/distutils/command/bdist_dumb.py
rename to lib-python/2.7/distutils/command/bdist_dumb.py
--- a/lib-python/2.7.0/distutils/command/bdist_dumb.py
+++ b/lib-python/2.7/distutils/command/bdist_dumb.py
@@ -4,7 +4,7 @@
 distribution -- i.e., just an archive to be unpacked under $prefix or
 $exec_prefix)."""
 
-__revision__ = "$Id: bdist_dumb.py 77761 2010-01-26 22:46:15Z tarek.ziade $"
+__revision__ = "$Id$"
 
 import os
 
diff --git a/lib-python/2.7.0/distutils/command/bdist_msi.py b/lib-python/2.7/distutils/command/bdist_msi.py
rename from lib-python/2.7.0/distutils/command/bdist_msi.py
rename to lib-python/2.7/distutils/command/bdist_msi.py
diff --git a/lib-python/2.7.0/distutils/command/bdist_rpm.py b/lib-python/2.7/distutils/command/bdist_rpm.py
rename from lib-python/2.7.0/distutils/command/bdist_rpm.py
rename to lib-python/2.7/distutils/command/bdist_rpm.py
--- a/lib-python/2.7.0/distutils/command/bdist_rpm.py
+++ b/lib-python/2.7/distutils/command/bdist_rpm.py
@@ -3,7 +3,7 @@
 Implements the Distutils 'bdist_rpm' command (create RPM source and binary
 distributions)."""
 
-__revision__ = "$Id: bdist_rpm.py 76956 2009-12-21 01:22:46Z tarek.ziade $"
+__revision__ = "$Id$"
 
 import sys
 import os
@@ -355,22 +355,26 @@
             src_rpm, non_src_rpm, spec_path)
 
         out = os.popen(q_cmd)
-        binary_rpms = []
-        source_rpm = None
-        while 1:
-            line = out.readline()
-            if not line:
-                break
-            l = string.split(string.strip(line))
-            assert(len(l) == 2)
-            binary_rpms.append(l[1])
-            # The source rpm is named after the first entry in the spec file
-            if source_rpm is None:
-                source_rpm = l[0]
+        try:
+            binary_rpms = []
+            source_rpm = None
+            while 1:
+                line = out.readline()
+                if not line:
+                    break
+                l = string.split(string.strip(line))
+                assert(len(l) == 2)
+                binary_rpms.append(l[1])
+                # The source rpm is named after the first entry in the spec file
+                if source_rpm is None:
+                    source_rpm = l[0]
 
-        status = out.close()
-        if status:
-            raise DistutilsExecError("Failed to execute: %s" % repr(q_cmd))
+            status = out.close()
+            if status:
+                raise DistutilsExecError("Failed to execute: %s" % repr(q_cmd))
+
+        finally:
+            out.close()
 
         self.spawn(rpm_cmd)
 
diff --git a/lib-python/2.7.0/distutils/command/bdist_wininst.py b/lib-python/2.7/distutils/command/bdist_wininst.py
rename from lib-python/2.7.0/distutils/command/bdist_wininst.py
rename to lib-python/2.7/distutils/command/bdist_wininst.py
--- a/lib-python/2.7.0/distutils/command/bdist_wininst.py
+++ b/lib-python/2.7/distutils/command/bdist_wininst.py
@@ -3,7 +3,7 @@
 Implements the Distutils 'bdist_wininst' command: create a windows installer
 exe-program."""
 
-__revision__ = "$Id: bdist_wininst.py 83593 2010-08-02 21:44:25Z georg.brandl $"
+__revision__ = "$Id$"
 
 import sys
 import os
@@ -356,5 +356,9 @@
             sfix = ''
 
         filename = os.path.join(directory, "wininst-%.1f%s.exe" % (bv, sfix))
-        return open(filename, "rb").read()
+        f = open(filename, "rb")
+        try:
+            return f.read()
+        finally:
+            f.close()
 # class bdist_wininst
diff --git a/lib-python/2.7.0/distutils/command/build.py b/lib-python/2.7/distutils/command/build.py
rename from lib-python/2.7.0/distutils/command/build.py
rename to lib-python/2.7/distutils/command/build.py
--- a/lib-python/2.7.0/distutils/command/build.py
+++ b/lib-python/2.7/distutils/command/build.py
@@ -2,7 +2,7 @@
 
 Implements the Distutils 'build' command."""
 
-__revision__ = "$Id: build.py 77761 2010-01-26 22:46:15Z tarek.ziade $"
+__revision__ = "$Id$"
 
 import sys, os
 
diff --git a/lib-python/2.7.0/distutils/command/build_clib.py b/lib-python/2.7/distutils/command/build_clib.py
rename from lib-python/2.7.0/distutils/command/build_clib.py
rename to lib-python/2.7/distutils/command/build_clib.py
--- a/lib-python/2.7.0/distutils/command/build_clib.py
+++ b/lib-python/2.7/distutils/command/build_clib.py
@@ -4,7 +4,7 @@
 that is included in the module distribution and needed by an extension
 module."""
 
-__revision__ = "$Id: build_clib.py 84610 2010-09-07 22:18:34Z eric.araujo $"
+__revision__ = "$Id$"
 
 
 # XXX this module has *lots* of code ripped-off quite transparently from
diff --git a/lib-python/2.7.0/distutils/command/build_ext.py b/lib-python/2.7/distutils/command/build_ext.py
rename from lib-python/2.7.0/distutils/command/build_ext.py
rename to lib-python/2.7/distutils/command/build_ext.py
--- a/lib-python/2.7.0/distutils/command/build_ext.py
+++ b/lib-python/2.7/distutils/command/build_ext.py
@@ -6,7 +6,7 @@
 
 # This module should be kept compatible with Python 2.1.
 
-__revision__ = "$Id: build_ext.py 84683 2010-09-10 20:03:17Z antoine.pitrou $"
+__revision__ = "$Id$"
 
 import sys, os, string, re
 from types import *
diff --git a/lib-python/2.7.0/distutils/command/build_py.py b/lib-python/2.7/distutils/command/build_py.py
rename from lib-python/2.7.0/distutils/command/build_py.py
rename to lib-python/2.7/distutils/command/build_py.py
--- a/lib-python/2.7.0/distutils/command/build_py.py
+++ b/lib-python/2.7/distutils/command/build_py.py
@@ -2,7 +2,7 @@
 
 Implements the Distutils 'build_py' command."""
 
-__revision__ = "$Id: build_py.py 76956 2009-12-21 01:22:46Z tarek.ziade $"
+__revision__ = "$Id$"
 
 import os
 import sys
diff --git a/lib-python/2.7.0/distutils/command/build_scripts.py b/lib-python/2.7/distutils/command/build_scripts.py
rename from lib-python/2.7.0/distutils/command/build_scripts.py
rename to lib-python/2.7/distutils/command/build_scripts.py
--- a/lib-python/2.7.0/distutils/command/build_scripts.py
+++ b/lib-python/2.7/distutils/command/build_scripts.py
@@ -2,7 +2,7 @@
 
 Implements the Distutils 'build_scripts' command."""
 
-__revision__ = "$Id: build_scripts.py 77704 2010-01-23 09:23:15Z tarek.ziade $"
+__revision__ = "$Id$"
 
 import os, re
 from stat import ST_MODE
diff --git a/lib-python/2.7.0/distutils/command/check.py b/lib-python/2.7/distutils/command/check.py
rename from lib-python/2.7.0/distutils/command/check.py
rename to lib-python/2.7/distutils/command/check.py
--- a/lib-python/2.7.0/distutils/command/check.py
+++ b/lib-python/2.7/distutils/command/check.py
@@ -2,7 +2,7 @@
 
 Implements the Distutils 'check' command.
 """
-__revision__ = "$Id: check.py 75266 2009-10-05 22:32:48Z andrew.kuchling $"
+__revision__ = "$Id$"
 
 from distutils.core import Command
 from distutils.errors import DistutilsSetupError
diff --git a/lib-python/2.7.0/distutils/command/clean.py b/lib-python/2.7/distutils/command/clean.py
rename from lib-python/2.7.0/distutils/command/clean.py
rename to lib-python/2.7/distutils/command/clean.py
--- a/lib-python/2.7.0/distutils/command/clean.py
+++ b/lib-python/2.7/distutils/command/clean.py
@@ -4,7 +4,7 @@
 
 # contributed by Bastian Kleineidam <calvin at cs.uni-sb.de>, added 2000-03-18
 
-__revision__ = "$Id: clean.py 70886 2009-03-31 20:50:59Z tarek.ziade $"
+__revision__ = "$Id$"
 
 import os
 from distutils.core import Command
diff --git a/lib-python/2.7.0/distutils/command/command_template b/lib-python/2.7/distutils/command/command_template
rename from lib-python/2.7.0/distutils/command/command_template
rename to lib-python/2.7/distutils/command/command_template
diff --git a/lib-python/2.7.0/distutils/command/config.py b/lib-python/2.7/distutils/command/config.py
rename from lib-python/2.7.0/distutils/command/config.py
rename to lib-python/2.7/distutils/command/config.py
--- a/lib-python/2.7.0/distutils/command/config.py
+++ b/lib-python/2.7/distutils/command/config.py
@@ -9,7 +9,7 @@
 this header file lives".
 """
 
-__revision__ = "$Id: config.py 77704 2010-01-23 09:23:15Z tarek.ziade $"
+__revision__ = "$Id$"
 
 import os
 import re
diff --git a/lib-python/2.7.0/distutils/command/install.py b/lib-python/2.7/distutils/command/install.py
rename from lib-python/2.7.0/distutils/command/install.py
rename to lib-python/2.7/distutils/command/install.py
--- a/lib-python/2.7.0/distutils/command/install.py
+++ b/lib-python/2.7/distutils/command/install.py
@@ -6,7 +6,7 @@
 
 # This module should be kept compatible with Python 2.1.
 
-__revision__ = "$Id: install.py 80804 2010-05-05 19:09:31Z ronald.oussoren $"
+__revision__ = "$Id$"
 
 import sys, os, string
 from types import *
diff --git a/lib-python/2.7.0/distutils/command/install_data.py b/lib-python/2.7/distutils/command/install_data.py
rename from lib-python/2.7.0/distutils/command/install_data.py
rename to lib-python/2.7/distutils/command/install_data.py
--- a/lib-python/2.7.0/distutils/command/install_data.py
+++ b/lib-python/2.7/distutils/command/install_data.py
@@ -5,7 +5,7 @@
 
 # contributed by Bastian Kleineidam
 
-__revision__ = "$Id: install_data.py 76849 2009-12-15 06:29:19Z tarek.ziade $"
+__revision__ = "$Id$"
 
 import os
 from distutils.core import Command
diff --git a/lib-python/2.7.0/distutils/command/install_egg_info.py b/lib-python/2.7/distutils/command/install_egg_info.py
rename from lib-python/2.7.0/distutils/command/install_egg_info.py
rename to lib-python/2.7/distutils/command/install_egg_info.py
diff --git a/lib-python/2.7.0/distutils/command/install_headers.py b/lib-python/2.7/distutils/command/install_headers.py
rename from lib-python/2.7.0/distutils/command/install_headers.py
rename to lib-python/2.7/distutils/command/install_headers.py
--- a/lib-python/2.7.0/distutils/command/install_headers.py
+++ b/lib-python/2.7/distutils/command/install_headers.py
@@ -3,7 +3,7 @@
 Implements the Distutils 'install_headers' command, to install C/C++ header
 files to the Python include directory."""
 
-__revision__ = "$Id: install_headers.py 70891 2009-03-31 20:55:21Z tarek.ziade $"
+__revision__ = "$Id$"
 
 from distutils.core import Command
 
diff --git a/lib-python/2.7.0/distutils/command/install_lib.py b/lib-python/2.7/distutils/command/install_lib.py
rename from lib-python/2.7.0/distutils/command/install_lib.py
rename to lib-python/2.7/distutils/command/install_lib.py
--- a/lib-python/2.7.0/distutils/command/install_lib.py
+++ b/lib-python/2.7/distutils/command/install_lib.py
@@ -3,7 +3,7 @@
 Implements the Distutils 'install_lib' command
 (install all Python modules)."""
 
-__revision__ = "$Id: install_lib.py 75671 2009-10-24 15:51:30Z tarek.ziade $"
+__revision__ = "$Id$"
 
 import os
 import sys
diff --git a/lib-python/2.7.0/distutils/command/install_scripts.py b/lib-python/2.7/distutils/command/install_scripts.py
rename from lib-python/2.7.0/distutils/command/install_scripts.py
rename to lib-python/2.7/distutils/command/install_scripts.py
--- a/lib-python/2.7.0/distutils/command/install_scripts.py
+++ b/lib-python/2.7/distutils/command/install_scripts.py
@@ -5,7 +5,7 @@
 
 # contributed by Bastian Kleineidam
 
-__revision__ = "$Id: install_scripts.py 68943 2009-01-25 22:09:10Z tarek.ziade $"
+__revision__ = "$Id$"
 
 import os
 from distutils.core import Command
diff --git a/lib-python/2.7.0/distutils/command/register.py b/lib-python/2.7/distutils/command/register.py
rename from lib-python/2.7.0/distutils/command/register.py
rename to lib-python/2.7/distutils/command/register.py
--- a/lib-python/2.7.0/distutils/command/register.py
+++ b/lib-python/2.7/distutils/command/register.py
@@ -5,7 +5,7 @@
 
 # created 2002/10/21, Richard Jones
 
-__revision__ = "$Id: register.py 77717 2010-01-24 00:33:32Z tarek.ziade $"
+__revision__ = "$Id$"
 
 import urllib2
 import getpass
diff --git a/lib-python/2.7.0/distutils/command/sdist.py b/lib-python/2.7/distutils/command/sdist.py
rename from lib-python/2.7.0/distutils/command/sdist.py
rename to lib-python/2.7/distutils/command/sdist.py
--- a/lib-python/2.7.0/distutils/command/sdist.py
+++ b/lib-python/2.7/distutils/command/sdist.py
@@ -2,7 +2,7 @@
 
 Implements the Distutils 'sdist' command (create a source distribution)."""
 
-__revision__ = "$Id: sdist.py 84713 2010-09-11 15:31:13Z eric.araujo $"
+__revision__ = "$Id$"
 
 import os
 import string
diff --git a/lib-python/2.7.0/distutils/command/upload.py b/lib-python/2.7/distutils/command/upload.py
rename from lib-python/2.7.0/distutils/command/upload.py
rename to lib-python/2.7/distutils/command/upload.py
--- a/lib-python/2.7.0/distutils/command/upload.py
+++ b/lib-python/2.7/distutils/command/upload.py
@@ -79,7 +79,11 @@
 
         # Fill in the data - send all the meta-data in case we need to
         # register a new release
-        content = open(filename,'rb').read()
+        f = open(filename,'rb')
+        try:
+            content = f.read()
+        finally:
+            f.close()
         meta = self.distribution.metadata
         data = {
             # action
diff --git a/lib-python/2.7.0/distutils/command/wininst-6.0.exe b/lib-python/2.7/distutils/command/wininst-6.0.exe
rename from lib-python/2.7.0/distutils/command/wininst-6.0.exe
rename to lib-python/2.7/distutils/command/wininst-6.0.exe
diff --git a/lib-python/2.7.0/distutils/command/wininst-7.1.exe b/lib-python/2.7/distutils/command/wininst-7.1.exe
rename from lib-python/2.7.0/distutils/command/wininst-7.1.exe
rename to lib-python/2.7/distutils/command/wininst-7.1.exe
diff --git a/lib-python/2.7.0/distutils/command/wininst-8.0.exe b/lib-python/2.7/distutils/command/wininst-8.0.exe
rename from lib-python/2.7.0/distutils/command/wininst-8.0.exe
rename to lib-python/2.7/distutils/command/wininst-8.0.exe
diff --git a/lib-python/2.7.0/distutils/command/wininst-9.0-amd64.exe b/lib-python/2.7/distutils/command/wininst-9.0-amd64.exe
rename from lib-python/2.7.0/distutils/command/wininst-9.0-amd64.exe
rename to lib-python/2.7/distutils/command/wininst-9.0-amd64.exe
diff --git a/lib-python/2.7.0/distutils/command/wininst-9.0.exe b/lib-python/2.7/distutils/command/wininst-9.0.exe
rename from lib-python/2.7.0/distutils/command/wininst-9.0.exe
rename to lib-python/2.7/distutils/command/wininst-9.0.exe
diff --git a/lib-python/2.7.0/distutils/config.py b/lib-python/2.7/distutils/config.py
rename from lib-python/2.7.0/distutils/config.py
rename to lib-python/2.7/distutils/config.py
diff --git a/lib-python/2.7.0/distutils/core.py b/lib-python/2.7/distutils/core.py
rename from lib-python/2.7.0/distutils/core.py
rename to lib-python/2.7/distutils/core.py
--- a/lib-python/2.7.0/distutils/core.py
+++ b/lib-python/2.7/distutils/core.py
@@ -6,7 +6,7 @@
 really defined in distutils.dist and distutils.cmd.
 """
 
-__revision__ = "$Id: core.py 77704 2010-01-23 09:23:15Z tarek.ziade $"
+__revision__ = "$Id$"
 
 import sys
 import os
@@ -216,7 +216,11 @@
             sys.argv[0] = script_name
             if script_args is not None:
                 sys.argv[1:] = script_args
-            exec open(script_name, 'r').read() in g, l
+            f = open(script_name)
+            try:
+                exec f.read() in g, l
+            finally:
+                f.close()
         finally:
             sys.argv = save_argv
             _setup_stop_after = None
diff --git a/lib-python/2.7.0/distutils/cygwinccompiler.py b/lib-python/2.7/distutils/cygwinccompiler.py
rename from lib-python/2.7.0/distutils/cygwinccompiler.py
rename to lib-python/2.7/distutils/cygwinccompiler.py
--- a/lib-python/2.7.0/distutils/cygwinccompiler.py
+++ b/lib-python/2.7/distutils/cygwinccompiler.py
@@ -47,7 +47,7 @@
 
 # This module should be kept compatible with Python 2.1.
 
-__revision__ = "$Id: cygwinccompiler.py 78666 2010-03-05 00:16:02Z tarek.ziade $"
+__revision__ = "$Id$"
 
 import os,sys,copy
 from distutils.ccompiler import gen_preprocess_options, gen_lib_options
@@ -382,8 +382,10 @@
         # It would probably better to read single lines to search.
         # But we do this only once, and it is fast enough
         f = open(fn)
-        s = f.read()
-        f.close()
+        try:
+            s = f.read()
+        finally:
+            f.close()
 
     except IOError, exc:
         # if we can't read this file, we cannot say it is wrong
diff --git a/lib-python/2.7.0/distutils/debug.py b/lib-python/2.7/distutils/debug.py
rename from lib-python/2.7.0/distutils/debug.py
rename to lib-python/2.7/distutils/debug.py
--- a/lib-python/2.7.0/distutils/debug.py
+++ b/lib-python/2.7/distutils/debug.py
@@ -1,6 +1,6 @@
 import os
 
-__revision__ = "$Id: debug.py 68943 2009-01-25 22:09:10Z tarek.ziade $"
+__revision__ = "$Id$"
 
 # If DISTUTILS_DEBUG is anything other than the empty string, we run in
 # debug mode.
diff --git a/lib-python/2.7.0/distutils/dep_util.py b/lib-python/2.7/distutils/dep_util.py
rename from lib-python/2.7.0/distutils/dep_util.py
rename to lib-python/2.7/distutils/dep_util.py
--- a/lib-python/2.7.0/distutils/dep_util.py
+++ b/lib-python/2.7/distutils/dep_util.py
@@ -4,7 +4,7 @@
 and groups of files; also, function based entirely on such
 timestamp dependency analysis."""
 
-__revision__ = "$Id: dep_util.py 76746 2009-12-10 15:29:03Z tarek.ziade $"
+__revision__ = "$Id$"
 
 import os
 from distutils.errors import DistutilsFileError
diff --git a/lib-python/2.7.0/distutils/dir_util.py b/lib-python/2.7/distutils/dir_util.py
rename from lib-python/2.7.0/distutils/dir_util.py
rename to lib-python/2.7/distutils/dir_util.py
--- a/lib-python/2.7.0/distutils/dir_util.py
+++ b/lib-python/2.7/distutils/dir_util.py
@@ -2,9 +2,10 @@
 
 Utility functions for manipulating directories and directory trees."""
 
-__revision__ = "$Id: dir_util.py 84862 2010-09-17 16:40:01Z senthil.kumaran $"
+__revision__ = "$Id$"
 
 import os
+import errno
 from distutils.errors import DistutilsFileError, DistutilsInternalError
 from distutils import log
 
@@ -69,10 +70,11 @@
         if not dry_run:
             try:
                 os.mkdir(head, mode)
-                created_dirs.append(head)
             except OSError, exc:
-                raise DistutilsFileError, \
-                      "could not create '%s': %s" % (head, exc[-1])
+                if not (exc.errno == errno.EEXIST and os.path.isdir(head)):
+                    raise DistutilsFileError(
+                          "could not create '%s': %s" % (head, exc.args[-1]))
+            created_dirs.append(head)
 
         _path_created[abs_head] = 1
     return created_dirs
diff --git a/lib-python/2.7.0/distutils/dist.py b/lib-python/2.7/distutils/dist.py
rename from lib-python/2.7.0/distutils/dist.py
rename to lib-python/2.7/distutils/dist.py
--- a/lib-python/2.7.0/distutils/dist.py
+++ b/lib-python/2.7/distutils/dist.py
@@ -4,7 +4,7 @@
 being built/installed/distributed.
 """
 
-__revision__ = "$Id: dist.py 77717 2010-01-24 00:33:32Z tarek.ziade $"
+__revision__ = "$Id$"
 
 import sys, os, re
 from email import message_from_file
@@ -1101,9 +1101,11 @@
     def write_pkg_info(self, base_dir):
         """Write the PKG-INFO file into the release tree.
         """
-        pkg_info = open( os.path.join(base_dir, 'PKG-INFO'), 'w')
-        self.write_pkg_file(pkg_info)
-        pkg_info.close()
+        pkg_info = open(os.path.join(base_dir, 'PKG-INFO'), 'w')
+        try:
+            self.write_pkg_file(pkg_info)
+        finally:
+            pkg_info.close()
 
     def write_pkg_file(self, file):
         """Write the PKG-INFO format data to a file object.
diff --git a/lib-python/2.7.0/distutils/emxccompiler.py b/lib-python/2.7/distutils/emxccompiler.py
rename from lib-python/2.7.0/distutils/emxccompiler.py
rename to lib-python/2.7/distutils/emxccompiler.py
--- a/lib-python/2.7.0/distutils/emxccompiler.py
+++ b/lib-python/2.7/distutils/emxccompiler.py
@@ -19,7 +19,7 @@
 #
 # * EMX gcc 2.81/EMX 0.9d fix03
 
-__revision__ = "$Id: emxccompiler.py 78666 2010-03-05 00:16:02Z tarek.ziade $"
+__revision__ = "$Id$"
 
 import os,sys,copy
 from distutils.ccompiler import gen_preprocess_options, gen_lib_options
@@ -272,8 +272,10 @@
         # It would probably better to read single lines to search.
         # But we do this only once, and it is fast enough
         f = open(fn)
-        s = f.read()
-        f.close()
+        try:
+            s = f.read()
+        finally:
+            f.close()
 
     except IOError, exc:
         # if we can't read this file, we cannot say it is wrong
@@ -300,8 +302,10 @@
     gcc_exe = find_executable('gcc')
     if gcc_exe:
         out = os.popen(gcc_exe + ' -dumpversion','r')
-        out_string = out.read()
-        out.close()
+        try:
+            out_string = out.read()
+        finally:
+            out.close()
         result = re.search('(\d+\.\d+\.\d+)',out_string)
         if result:
             gcc_version = StrictVersion(result.group(1))
diff --git a/lib-python/2.7.0/distutils/errors.py b/lib-python/2.7/distutils/errors.py
rename from lib-python/2.7.0/distutils/errors.py
rename to lib-python/2.7/distutils/errors.py
--- a/lib-python/2.7.0/distutils/errors.py
+++ b/lib-python/2.7/distutils/errors.py
@@ -8,7 +8,7 @@
 This module is safe to use in "from ... import *" mode; it only exports
 symbols whose names start with "Distutils" and end with "Error"."""
 
-__revision__ = "$Id: errors.py 75901 2009-10-28 06:45:18Z tarek.ziade $"
+__revision__ = "$Id$"
 
 class DistutilsError(Exception):
     """The root of all Distutils evil."""
diff --git a/lib-python/2.7.0/distutils/extension.py b/lib-python/2.7/distutils/extension.py
rename from lib-python/2.7.0/distutils/extension.py
rename to lib-python/2.7/distutils/extension.py
--- a/lib-python/2.7.0/distutils/extension.py
+++ b/lib-python/2.7/distutils/extension.py
@@ -3,7 +3,7 @@
 Provides the Extension class, used to describe C/C++ extension
 modules in setup scripts."""
 
-__revision__ = "$Id: extension.py 78666 2010-03-05 00:16:02Z tarek.ziade $"
+__revision__ = "$Id$"
 
 import os, string, sys
 from types import *
@@ -150,87 +150,96 @@
     file = TextFile(filename,
                     strip_comments=1, skip_blanks=1, join_lines=1,
                     lstrip_ws=1, rstrip_ws=1)
-    extensions = []
+    try:
+        extensions = []
 
-    while 1:
-        line = file.readline()
-        if line is None:                # eof
-            break
-        if _variable_rx.match(line):    # VAR=VALUE, handled in first pass
-            continue
-
-        if line[0] == line[-1] == "*":
-            file.warn("'%s' lines not handled yet" % line)
-            continue
-
-        #print "original line: " + line
-        line = expand_makefile_vars(line, vars)
-        words = split_quoted(line)
-        #print "expanded line: " + line
-
-        # NB. this parses a slightly different syntax than the old
-        # makesetup script: here, there must be exactly one extension per
-        # line, and it must be the first word of the line.  I have no idea
-        # why the old syntax supported multiple extensions per line, as
-        # they all wind up being the same.
-
-        module = words[0]
-        ext = Extension(module, [])
-        append_next_word = None
-
-        for word in words[1:]:
-            if append_next_word is not None:
-                append_next_word.append(word)
-                append_next_word = None
+        while 1:
+            line = file.readline()
+            if line is None:                # eof
+                break
+            if _variable_rx.match(line):    # VAR=VALUE, handled in first pass
                 continue
 
-            suffix = os.path.splitext(word)[1]
-            switch = word[0:2] ; value = word[2:]
+                if line[0] == line[-1] == "*":
+                    file.warn("'%s' lines not handled yet" % line)
+                    continue
 
-            if suffix in (".c", ".cc", ".cpp", ".cxx", ".c++", ".m", ".mm"):
-                # hmm, should we do something about C vs. C++ sources?
-                # or leave it up to the CCompiler implementation to
-                # worry about?
-                ext.sources.append(word)
-            elif switch == "-I":
-                ext.include_dirs.append(value)
-            elif switch == "-D":
-                equals = string.find(value, "=")
-                if equals == -1:        # bare "-DFOO" -- no value
-                    ext.define_macros.append((value, None))
-                else:                   # "-DFOO=blah"
-                    ext.define_macros.append((value[0:equals],
-                                              value[equals+2:]))
-            elif switch == "-U":
-                ext.undef_macros.append(value)
-            elif switch == "-C":        # only here 'cause makesetup has it!
-                ext.extra_compile_args.append(word)
-            elif switch == "-l":
-                ext.libraries.append(value)
-            elif switch == "-L":
-                ext.library_dirs.append(value)
-            elif switch == "-R":
-                ext.runtime_library_dirs.append(value)
-            elif word == "-rpath":
-                append_next_word = ext.runtime_library_dirs
-            elif word == "-Xlinker":
-                append_next_word = ext.extra_link_args
-            elif word == "-Xcompiler":
-                append_next_word = ext.extra_compile_args
-            elif switch == "-u":
-                ext.extra_link_args.append(word)
-                if not value:
+            #print "original line: " + line
+            line = expand_makefile_vars(line, vars)
+            words = split_quoted(line)
+            #print "expanded line: " + line
+
+            # NB. this parses a slightly different syntax than the old
+            # makesetup script: here, there must be exactly one extension per
+            # line, and it must be the first word of the line.  I have no idea
+            # why the old syntax supported multiple extensions per line, as
+            # they all wind up being the same.
+
+            module = words[0]
+            ext = Extension(module, [])
+            append_next_word = None
+
+            for word in words[1:]:
+                if append_next_word is not None:
+                    append_next_word.append(word)
+                    append_next_word = None
+                    continue
+
+                suffix = os.path.splitext(word)[1]
+                switch = word[0:2] ; value = word[2:]
+
+                if suffix in (".c", ".cc", ".cpp", ".cxx", ".c++", ".m", ".mm"):
+                    # hmm, should we do something about C vs. C++ sources?
+                    # or leave it up to the CCompiler implementation to
+                    # worry about?
+                    ext.sources.append(word)
+                elif switch == "-I":
+                    ext.include_dirs.append(value)
+                elif switch == "-D":
+                    equals = string.find(value, "=")
+                    if equals == -1:        # bare "-DFOO" -- no value
+                        ext.define_macros.append((value, None))
+                    else:                   # "-DFOO=blah"
+                        ext.define_macros.append((value[0:equals],
+                                                  value[equals+2:]))
+                elif switch == "-U":
+                    ext.undef_macros.append(value)
+                elif switch == "-C":        # only here 'cause makesetup has it!
+                    ext.extra_compile_args.append(word)
+                elif switch == "-l":
+                    ext.libraries.append(value)
+                elif switch == "-L":
+                    ext.library_dirs.append(value)
+                elif switch == "-R":
+                    ext.runtime_library_dirs.append(value)
+                elif word == "-rpath":
+                    append_next_word = ext.runtime_library_dirs
+                elif word == "-Xlinker":
                     append_next_word = ext.extra_link_args
-            elif suffix in (".a", ".so", ".sl", ".o", ".dylib"):
-                # NB. a really faithful emulation of makesetup would
-                # append a .o file to extra_objects only if it
-                # had a slash in it; otherwise, it would s/.o/.c/
-                # and append it to sources.  Hmmmm.
-                ext.extra_objects.append(word)
-            else:
-                file.warn("unrecognized argument '%s'" % word)
+                elif word == "-Xcompiler":
+                    append_next_word = ext.extra_compile_args
+                elif switch == "-u":
+                    ext.extra_link_args.append(word)
+                    if not value:
+                        append_next_word = ext.extra_link_args
+                elif word == "-Xcompiler":
+                    append_next_word = ext.extra_compile_args
+                elif switch == "-u":
+                    ext.extra_link_args.append(word)
+                    if not value:
+                        append_next_word = ext.extra_link_args
+                elif suffix in (".a", ".so", ".sl", ".o", ".dylib"):
+                    # NB. a really faithful emulation of makesetup would
+                    # append a .o file to extra_objects only if it
+                    # had a slash in it; otherwise, it would s/.o/.c/
+                    # and append it to sources.  Hmmmm.
+                    ext.extra_objects.append(word)
+                else:
+                    file.warn("unrecognized argument '%s'" % word)
 
-        extensions.append(ext)
+            extensions.append(ext)
+    finally:
+        file.close()
 
         #print "module:", module
         #print "source files:", source_files
diff --git a/lib-python/2.7.0/distutils/fancy_getopt.py b/lib-python/2.7/distutils/fancy_getopt.py
rename from lib-python/2.7.0/distutils/fancy_getopt.py
rename to lib-python/2.7/distutils/fancy_getopt.py
--- a/lib-python/2.7.0/distutils/fancy_getopt.py
+++ b/lib-python/2.7/distutils/fancy_getopt.py
@@ -8,7 +8,7 @@
   * options set attributes of a passed-in object
 """
 
-__revision__ = "$Id: fancy_getopt.py 76956 2009-12-21 01:22:46Z tarek.ziade $"
+__revision__ = "$Id$"
 
 import sys
 import string
diff --git a/lib-python/2.7.0/distutils/file_util.py b/lib-python/2.7/distutils/file_util.py
rename from lib-python/2.7.0/distutils/file_util.py
rename to lib-python/2.7/distutils/file_util.py
--- a/lib-python/2.7.0/distutils/file_util.py
+++ b/lib-python/2.7/distutils/file_util.py
@@ -3,7 +3,7 @@
 Utility functions for operating on single files.
 """
 
-__revision__ = "$Id: file_util.py 80804 2010-05-05 19:09:31Z ronald.oussoren $"
+__revision__ = "$Id$"
 
 import os
 from distutils.errors import DistutilsFileError
@@ -224,6 +224,8 @@
     sequence of strings without line terminators) to it.
     """
     f = open(filename, "w")
-    for line in contents:
-        f.write(line + "\n")
-    f.close()
+    try:
+        for line in contents:
+            f.write(line + "\n")
+    finally:
+        f.close()
diff --git a/lib-python/2.7.0/distutils/filelist.py b/lib-python/2.7/distutils/filelist.py
rename from lib-python/2.7.0/distutils/filelist.py
rename to lib-python/2.7/distutils/filelist.py
--- a/lib-python/2.7.0/distutils/filelist.py
+++ b/lib-python/2.7/distutils/filelist.py
@@ -4,7 +4,7 @@
 and building lists of files.
 """
 
-__revision__ = "$Id: filelist.py 75196 2009-10-03 00:07:35Z tarek.ziade $"
+__revision__ = "$Id$"
 
 import os, re
 import fnmatch
diff --git a/lib-python/2.7.0/distutils/log.py b/lib-python/2.7/distutils/log.py
rename from lib-python/2.7.0/distutils/log.py
rename to lib-python/2.7/distutils/log.py
diff --git a/lib-python/2.7.0/distutils/msvc9compiler.py b/lib-python/2.7/distutils/msvc9compiler.py
rename from lib-python/2.7.0/distutils/msvc9compiler.py
rename to lib-python/2.7/distutils/msvc9compiler.py
--- a/lib-python/2.7.0/distutils/msvc9compiler.py
+++ b/lib-python/2.7/distutils/msvc9compiler.py
@@ -12,7 +12,7 @@
 #   finding DevStudio (through the registry)
 # ported to VS2005 and VS 2008 by Christian Heimes
 
-__revision__ = "$Id: msvc9compiler.py 82130 2010-06-21 15:27:46Z benjamin.peterson $"
+__revision__ = "$Id$"
 
 import os
 import subprocess
@@ -273,23 +273,27 @@
     popen = subprocess.Popen('"%s" %s & set' % (vcvarsall, arch),
                              stdout=subprocess.PIPE,
                              stderr=subprocess.PIPE)
+    try:
+        stdout, stderr = popen.communicate()
+        if popen.wait() != 0:
+            raise DistutilsPlatformError(stderr.decode("mbcs"))
 
-    stdout, stderr = popen.communicate()
-    if popen.wait() != 0:
-        raise DistutilsPlatformError(stderr.decode("mbcs"))
+        stdout = stdout.decode("mbcs")
+        for line in stdout.split("\n"):
+            line = Reg.convert_mbcs(line)
+            if '=' not in line:
+                continue
+            line = line.strip()
+            key, value = line.split('=', 1)
+            key = key.lower()
+            if key in interesting:
+                if value.endswith(os.pathsep):
+                    value = value[:-1]
+                result[key] = removeDuplicates(value)
 
-    stdout = stdout.decode("mbcs")
-    for line in stdout.split("\n"):
-        line = Reg.convert_mbcs(line)
-        if '=' not in line:
-            continue
-        line = line.strip()
-        key, value = line.split('=', 1)
-        key = key.lower()
-        if key in interesting:
-            if value.endswith(os.pathsep):
-                value = value[:-1]
-            result[key] = removeDuplicates(value)
+    finally:
+        popen.stdout.close()
+        popen.stderr.close()
 
     if len(result) != len(interesting):
         raise ValueError(str(list(result.keys())))
diff --git a/lib-python/2.7.0/distutils/msvccompiler.py b/lib-python/2.7/distutils/msvccompiler.py
rename from lib-python/2.7.0/distutils/msvccompiler.py
rename to lib-python/2.7/distutils/msvccompiler.py
--- a/lib-python/2.7.0/distutils/msvccompiler.py
+++ b/lib-python/2.7/distutils/msvccompiler.py
@@ -8,7 +8,7 @@
 # hacked by Robin Becker and Thomas Heller to do a better job of
 #   finding DevStudio (through the registry)
 
-__revision__ = "$Id: msvccompiler.py 76956 2009-12-21 01:22:46Z tarek.ziade $"
+__revision__ = "$Id$"
 
 import sys
 import os
diff --git a/lib-python/2.7.0/distutils/spawn.py b/lib-python/2.7/distutils/spawn.py
rename from lib-python/2.7.0/distutils/spawn.py
rename to lib-python/2.7/distutils/spawn.py
--- a/lib-python/2.7.0/distutils/spawn.py
+++ b/lib-python/2.7/distutils/spawn.py
@@ -6,7 +6,7 @@
 executable name.
 """
 
-__revision__ = "$Id: spawn.py 73147 2009-06-02 15:58:43Z tarek.ziade $"
+__revision__ = "$Id$"
 
 import sys
 import os
diff --git a/lib-python/2.7.0/distutils/sysconfig.py b/lib-python/2.7/distutils/sysconfig.py
rename from lib-python/2.7.0/distutils/sysconfig.py
rename to lib-python/2.7/distutils/sysconfig.py
--- a/lib-python/2.7.0/distutils/sysconfig.py
+++ b/lib-python/2.7/distutils/sysconfig.py
@@ -9,7 +9,7 @@
 Email:        <fdrake at acm.org>
 """
 
-__revision__ = "$Id: sysconfig.py 85358 2010-10-10 09:54:59Z antoine.pitrou $"
+__revision__ = "$Id$"
 
 import os
 import re
@@ -453,32 +453,6 @@
     _config_vars = g
 
 
-def _init_mac():
-    """Initialize the module as appropriate for Macintosh systems"""
-    g = {}
-    # set basic install directories
-    g['LIBDEST'] = get_python_lib(plat_specific=0, standard_lib=1)
-    g['BINLIBDEST'] = get_python_lib(plat_specific=1, standard_lib=1)
-
-    # XXX hmmm.. a normal install puts include files here
-    g['INCLUDEPY'] = get_python_inc(plat_specific=0)
-
-    import MacOS
-    if not hasattr(MacOS, 'runtimemodel'):
-        g['SO'] = '.ppc.slb'
-    else:
-        g['SO'] = '.%s.slb' % MacOS.runtimemodel
-
-    # XXX are these used anywhere?
-    g['install_lib'] = os.path.join(EXEC_PREFIX, "Lib")
-    g['install_platlib'] = os.path.join(EXEC_PREFIX, "Mac", "Lib")
-
-    # These are used by the extension module build
-    g['srcdir'] = ':'
-    global _config_vars
-    _config_vars = g
-
-
 def _init_os2():
     """Initialize the module as appropriate for OS/2"""
     g = {}
diff --git a/lib-python/2.7.0/distutils/tests/Setup.sample b/lib-python/2.7/distutils/tests/Setup.sample
rename from lib-python/2.7.0/distutils/tests/Setup.sample
rename to lib-python/2.7/distutils/tests/Setup.sample
diff --git a/lib-python/2.7.0/distutils/tests/__init__.py b/lib-python/2.7/distutils/tests/__init__.py
rename from lib-python/2.7.0/distutils/tests/__init__.py
rename to lib-python/2.7/distutils/tests/__init__.py
diff --git a/lib-python/2.7.0/distutils/tests/setuptools_build_ext.py b/lib-python/2.7/distutils/tests/setuptools_build_ext.py
rename from lib-python/2.7.0/distutils/tests/setuptools_build_ext.py
rename to lib-python/2.7/distutils/tests/setuptools_build_ext.py
diff --git a/lib-python/2.7.0/distutils/tests/setuptools_extension.py b/lib-python/2.7/distutils/tests/setuptools_extension.py
rename from lib-python/2.7.0/distutils/tests/setuptools_extension.py
rename to lib-python/2.7/distutils/tests/setuptools_extension.py
diff --git a/lib-python/2.7.0/distutils/tests/support.py b/lib-python/2.7/distutils/tests/support.py
rename from lib-python/2.7.0/distutils/tests/support.py
rename to lib-python/2.7/distutils/tests/support.py
diff --git a/lib-python/2.7.0/distutils/tests/test_archive_util.py b/lib-python/2.7/distutils/tests/test_archive_util.py
rename from lib-python/2.7.0/distutils/tests/test_archive_util.py
rename to lib-python/2.7/distutils/tests/test_archive_util.py
--- a/lib-python/2.7.0/distutils/tests/test_archive_util.py
+++ b/lib-python/2.7/distutils/tests/test_archive_util.py
@@ -1,5 +1,5 @@
 """Tests for distutils.archive_util."""
-__revision__ = "$Id: test_archive_util.py 75659 2009-10-24 13:29:44Z tarek.ziade $"
+__revision__ = "$Id$"
 
 import unittest
 import os
@@ -129,7 +129,7 @@
 
         self.assertTrue(os.path.exists(tarball2))
         # let's compare both tarballs
-        self.assertEquals(self._tarinfo(tarball), self._tarinfo(tarball2))
+        self.assertEqual(self._tarinfo(tarball), self._tarinfo(tarball2))
 
         # trying an uncompressed one
         base_name = os.path.join(tmpdir2, 'archive')
@@ -169,7 +169,7 @@
             os.chdir(old_dir)
         tarball = base_name + '.tar.Z'
         self.assertTrue(os.path.exists(tarball))
-        self.assertEquals(len(w.warnings), 1)
+        self.assertEqual(len(w.warnings), 1)
 
         # same test with dry_run
         os.remove(tarball)
@@ -183,7 +183,7 @@
         finally:
             os.chdir(old_dir)
         self.assertTrue(not os.path.exists(tarball))
-        self.assertEquals(len(w.warnings), 1)
+        self.assertEqual(len(w.warnings), 1)
 
     @unittest.skipUnless(zlib, "Requires zlib")
     @unittest.skipUnless(ZIP_SUPPORT, 'Need zip support to run')
@@ -201,9 +201,9 @@
         tarball = base_name + '.zip'
 
     def test_check_archive_formats(self):
-        self.assertEquals(check_archive_formats(['gztar', 'xxx', 'zip']),
-                          'xxx')
-        self.assertEquals(check_archive_formats(['gztar', 'zip']), None)
+        self.assertEqual(check_archive_formats(['gztar', 'xxx', 'zip']),
+                         'xxx')
+        self.assertEqual(check_archive_formats(['gztar', 'zip']), None)
 
     def test_make_archive(self):
         tmpdir = self.mkdtemp()
@@ -258,8 +258,8 @@
         archive = tarfile.open(archive_name)
         try:
             for member in archive.getmembers():
-                self.assertEquals(member.uid, 0)
-                self.assertEquals(member.gid, 0)
+                self.assertEqual(member.uid, 0)
+                self.assertEqual(member.gid, 0)
         finally:
             archive.close()
 
@@ -273,7 +273,7 @@
                 make_archive('xxx', 'xxx', root_dir=self.mkdtemp())
             except:
                 pass
-            self.assertEquals(os.getcwd(), current_dir)
+            self.assertEqual(os.getcwd(), current_dir)
         finally:
             del ARCHIVE_FORMATS['xxx']
 
diff --git a/lib-python/2.7.0/distutils/tests/test_bdist.py b/lib-python/2.7/distutils/tests/test_bdist.py
rename from lib-python/2.7.0/distutils/tests/test_bdist.py
rename to lib-python/2.7/distutils/tests/test_bdist.py
--- a/lib-python/2.7.0/distutils/tests/test_bdist.py
+++ b/lib-python/2.7/distutils/tests/test_bdist.py
@@ -25,7 +25,7 @@
         cmd = bdist(dist)
         cmd.formats = ['msi']
         cmd.ensure_finalized()
-        self.assertEquals(cmd.formats, ['msi'])
+        self.assertEqual(cmd.formats, ['msi'])
 
         # what format bdist offers ?
         # XXX an explicit list in bdist is
@@ -36,7 +36,7 @@
         formats.sort()
         founded = cmd.format_command.keys()
         founded.sort()
-        self.assertEquals(founded, formats)
+        self.assertEqual(founded, formats)
 
 def test_suite():
     return unittest.makeSuite(BuildTestCase)
diff --git a/lib-python/2.7.0/distutils/tests/test_bdist_dumb.py b/lib-python/2.7/distutils/tests/test_bdist_dumb.py
rename from lib-python/2.7.0/distutils/tests/test_bdist_dumb.py
rename to lib-python/2.7/distutils/tests/test_bdist_dumb.py
--- a/lib-python/2.7.0/distutils/tests/test_bdist_dumb.py
+++ b/lib-python/2.7/distutils/tests/test_bdist_dumb.py
@@ -78,7 +78,7 @@
             base = base.replace(':', '-')
 
         wanted = ['%s.zip' % base]
-        self.assertEquals(dist_created, wanted)
+        self.assertEqual(dist_created, wanted)
 
         # now let's check what we have in the zip file
         # XXX to be done
@@ -87,16 +87,16 @@
         pkg_dir, dist = self.create_dist()
         os.chdir(pkg_dir)
         cmd = bdist_dumb(dist)
-        self.assertEquals(cmd.bdist_dir, None)
+        self.assertEqual(cmd.bdist_dir, None)
         cmd.finalize_options()
 
         # bdist_dir is initialized to bdist_base/dumb if not set
         base = cmd.get_finalized_command('bdist').bdist_base
-        self.assertEquals(cmd.bdist_dir, os.path.join(base, 'dumb'))
+        self.assertEqual(cmd.bdist_dir, os.path.join(base, 'dumb'))
 
         # the format is set to a default value depending on the os.name
         default = cmd.default_format[os.name]
-        self.assertEquals(cmd.format, default)
+        self.assertEqual(cmd.format, default)
 
 def test_suite():
     return unittest.makeSuite(BuildDumbTestCase)
diff --git a/lib-python/2.7.0/distutils/tests/test_bdist_msi.py b/lib-python/2.7/distutils/tests/test_bdist_msi.py
rename from lib-python/2.7.0/distutils/tests/test_bdist_msi.py
rename to lib-python/2.7/distutils/tests/test_bdist_msi.py
diff --git a/lib-python/2.7.0/distutils/tests/test_bdist_rpm.py b/lib-python/2.7/distutils/tests/test_bdist_rpm.py
rename from lib-python/2.7.0/distutils/tests/test_bdist_rpm.py
rename to lib-python/2.7/distutils/tests/test_bdist_rpm.py
diff --git a/lib-python/2.7.0/distutils/tests/test_bdist_wininst.py b/lib-python/2.7/distutils/tests/test_bdist_wininst.py
rename from lib-python/2.7.0/distutils/tests/test_bdist_wininst.py
rename to lib-python/2.7/distutils/tests/test_bdist_wininst.py
diff --git a/lib-python/2.7.0/distutils/tests/test_build.py b/lib-python/2.7/distutils/tests/test_build.py
rename from lib-python/2.7.0/distutils/tests/test_build.py
rename to lib-python/2.7/distutils/tests/test_build.py
--- a/lib-python/2.7.0/distutils/tests/test_build.py
+++ b/lib-python/2.7/distutils/tests/test_build.py
@@ -17,11 +17,11 @@
         cmd.finalize_options()
 
         # if not specified, plat_name gets the current platform
-        self.assertEquals(cmd.plat_name, get_platform())
+        self.assertEqual(cmd.plat_name, get_platform())
 
         # build_purelib is build + lib
         wanted = os.path.join(cmd.build_base, 'lib')
-        self.assertEquals(cmd.build_purelib, wanted)
+        self.assertEqual(cmd.build_purelib, wanted)
 
         # build_platlib is 'build/lib.platform-x.x[-pydebug]'
         # examples:
@@ -31,21 +31,21 @@
             self.assertTrue(cmd.build_platlib.endswith('-pydebug'))
             plat_spec += '-pydebug'
         wanted = os.path.join(cmd.build_base, 'lib' + plat_spec)
-        self.assertEquals(cmd.build_platlib, wanted)
+        self.assertEqual(cmd.build_platlib, wanted)
 
         # by default, build_lib = build_purelib
-        self.assertEquals(cmd.build_lib, cmd.build_purelib)
+        self.assertEqual(cmd.build_lib, cmd.build_purelib)
 
         # build_temp is build/temp.<plat>
         wanted = os.path.join(cmd.build_base, 'temp' + plat_spec)
-        self.assertEquals(cmd.build_temp, wanted)
+        self.assertEqual(cmd.build_temp, wanted)
 
         # build_scripts is build/scripts-x.x
         wanted = os.path.join(cmd.build_base, 'scripts-' +  sys.version[0:3])
-        self.assertEquals(cmd.build_scripts, wanted)
+        self.assertEqual(cmd.build_scripts, wanted)
 
         # executable is os.path.normpath(sys.executable)
-        self.assertEquals(cmd.executable, os.path.normpath(sys.executable))
+        self.assertEqual(cmd.executable, os.path.normpath(sys.executable))
 
 def test_suite():
     return unittest.makeSuite(BuildTestCase)
diff --git a/lib-python/2.7.0/distutils/tests/test_build_clib.py b/lib-python/2.7/distutils/tests/test_build_clib.py
rename from lib-python/2.7.0/distutils/tests/test_build_clib.py
rename to lib-python/2.7/distutils/tests/test_build_clib.py
--- a/lib-python/2.7.0/distutils/tests/test_build_clib.py
+++ b/lib-python/2.7/distutils/tests/test_build_clib.py
@@ -55,14 +55,14 @@
         self.assertRaises(DistutilsSetupError, cmd.get_source_files)
 
         cmd.libraries = [('name', {'sources': ['a', 'b']})]
-        self.assertEquals(cmd.get_source_files(), ['a', 'b'])
+        self.assertEqual(cmd.get_source_files(), ['a', 'b'])
 
         cmd.libraries = [('name', {'sources': ('a', 'b')})]
-        self.assertEquals(cmd.get_source_files(), ['a', 'b'])
+        self.assertEqual(cmd.get_source_files(), ['a', 'b'])
 
         cmd.libraries = [('name', {'sources': ('a', 'b')}),
                          ('name2', {'sources': ['c', 'd']})]
-        self.assertEquals(cmd.get_source_files(), ['a', 'b', 'c', 'd'])
+        self.assertEqual(cmd.get_source_files(), ['a', 'b', 'c', 'd'])
 
     def test_build_libraries(self):
 
@@ -91,11 +91,11 @@
 
         cmd.include_dirs = 'one-dir'
         cmd.finalize_options()
-        self.assertEquals(cmd.include_dirs, ['one-dir'])
+        self.assertEqual(cmd.include_dirs, ['one-dir'])
 
         cmd.include_dirs = None
         cmd.finalize_options()
-        self.assertEquals(cmd.include_dirs, [])
+        self.assertEqual(cmd.include_dirs, [])
 
         cmd.distribution.libraries = 'WONTWORK'
         self.assertRaises(DistutilsSetupError, cmd.finalize_options)
diff --git a/lib-python/2.7.0/distutils/tests/test_build_ext.py b/lib-python/2.7/distutils/tests/test_build_ext.py
rename from lib-python/2.7.0/distutils/tests/test_build_ext.py
rename to lib-python/2.7/distutils/tests/test_build_ext.py
--- a/lib-python/2.7.0/distutils/tests/test_build_ext.py
+++ b/lib-python/2.7/distutils/tests/test_build_ext.py
@@ -103,15 +103,15 @@
         import xx
 
         for attr in ('error', 'foo', 'new', 'roj'):
-            self.assert_(hasattr(xx, attr))
+            self.assertTrue(hasattr(xx, attr))
 
-        self.assertEquals(xx.foo(2, 5), 7)
-        self.assertEquals(xx.foo(13,15), 28)
-        self.assertEquals(xx.new().demo(), None)
+        self.assertEqual(xx.foo(2, 5), 7)
+        self.assertEqual(xx.foo(13,15), 28)
+        self.assertEqual(xx.new().demo(), None)
         doc = 'This is a template module just for instruction.'
-        self.assertEquals(xx.__doc__, doc)
-        self.assert_(isinstance(xx.Null(), xx.Null))
-        self.assert_(isinstance(xx.Str(), xx.Str))
+        self.assertEqual(xx.__doc__, doc)
+        self.assertTrue(isinstance(xx.Null(), xx.Null))
+        self.assertTrue(isinstance(xx.Str(), xx.Str))
 
     def test_solaris_enable_shared(self):
         dist = Distribution({'name': 'xx'})
@@ -132,7 +132,7 @@
                 _config_vars['Py_ENABLE_SHARED'] = old_var
 
         # make sure we get some library dirs under solaris
-        self.assert_(len(cmd.library_dirs) > 0)
+        self.assertTrue(len(cmd.library_dirs) > 0)
 
     def test_finalize_options(self):
         # Make sure Python's include directories (for Python.h, pyconfig.h,
@@ -144,31 +144,31 @@
 
         from distutils import sysconfig
         py_include = sysconfig.get_python_inc()
-        self.assert_(py_include in cmd.include_dirs)
+        self.assertTrue(py_include in cmd.include_dirs)
 
         plat_py_include = sysconfig.get_python_inc(plat_specific=1)
-        self.assert_(plat_py_include in cmd.include_dirs)
+        self.assertTrue(plat_py_include in cmd.include_dirs)
 
         # make sure cmd.libraries is turned into a list
         # if it's a string
         cmd = build_ext(dist)
         cmd.libraries = 'my_lib'
         cmd.finalize_options()
-        self.assertEquals(cmd.libraries, ['my_lib'])
+        self.assertEqual(cmd.libraries, ['my_lib'])
 
         # make sure cmd.library_dirs is turned into a list
         # if it's a string
         cmd = build_ext(dist)
         cmd.library_dirs = 'my_lib_dir'
         cmd.finalize_options()
-        self.assert_('my_lib_dir' in cmd.library_dirs)
+        self.assertTrue('my_lib_dir' in cmd.library_dirs)
 
         # make sure rpath is turned into a list
         # if it's a list of os.pathsep's paths
         cmd = build_ext(dist)
         cmd.rpath = os.pathsep.join(['one', 'two'])
         cmd.finalize_options()
-        self.assertEquals(cmd.rpath, ['one', 'two'])
+        self.assertEqual(cmd.rpath, ['one', 'two'])
 
         # XXX more tests to perform for win32
 
@@ -177,25 +177,25 @@
         cmd = build_ext(dist)
         cmd.define = 'one,two'
         cmd.finalize_options()
-        self.assertEquals(cmd.define, [('one', '1'), ('two', '1')])
+        self.assertEqual(cmd.define, [('one', '1'), ('two', '1')])
 
         # make sure undef is turned into a list of
         # strings if they are ','-separated strings
         cmd = build_ext(dist)
         cmd.undef = 'one,two'
         cmd.finalize_options()
-        self.assertEquals(cmd.undef, ['one', 'two'])
+        self.assertEqual(cmd.undef, ['one', 'two'])
 
         # make sure swig_opts is turned into a list
         cmd = build_ext(dist)
         cmd.swig_opts = None
         cmd.finalize_options()
-        self.assertEquals(cmd.swig_opts, [])
+        self.assertEqual(cmd.swig_opts, [])
 
         cmd = build_ext(dist)
         cmd.swig_opts = '1 2'
         cmd.finalize_options()
-        self.assertEquals(cmd.swig_opts, ['1', '2'])
+        self.assertEqual(cmd.swig_opts, ['1', '2'])
 
     def test_check_extensions_list(self):
         dist = Distribution()
@@ -226,13 +226,13 @@
                              'some': 'bar'})]
         cmd.check_extensions_list(exts)
         ext = exts[0]
-        self.assert_(isinstance(ext, Extension))
+        self.assertTrue(isinstance(ext, Extension))
 
         # check_extensions_list adds in ext the values passed
         # when they are in ('include_dirs', 'library_dirs', 'libraries'
         # 'extra_objects', 'extra_compile_args', 'extra_link_args')
-        self.assertEquals(ext.libraries, 'foo')
-        self.assert_(not hasattr(ext, 'some'))
+        self.assertEqual(ext.libraries, 'foo')
+        self.assertTrue(not hasattr(ext, 'some'))
 
         # 'macros' element of build info dict must be 1- or 2-tuple
         exts = [('foo.bar', {'sources': [''], 'libraries': 'foo',
@@ -241,15 +241,15 @@
 
         exts[0][1]['macros'] = [('1', '2'), ('3',)]
         cmd.check_extensions_list(exts)
-        self.assertEquals(exts[0].undef_macros, ['3'])
-        self.assertEquals(exts[0].define_macros, [('1', '2')])
+        self.assertEqual(exts[0].undef_macros, ['3'])
+        self.assertEqual(exts[0].define_macros, [('1', '2')])
 
     def test_get_source_files(self):
         modules = [Extension('foo', ['xxx'])]
         dist = Distribution({'name': 'xx', 'ext_modules': modules})
         cmd = build_ext(dist)
         cmd.ensure_finalized()
-        self.assertEquals(cmd.get_source_files(), ['xxx'])
+        self.assertEqual(cmd.get_source_files(), ['xxx'])
 
     def test_compiler_option(self):
         # cmd.compiler is an option and
@@ -260,7 +260,7 @@
         cmd.compiler = 'unix'
         cmd.ensure_finalized()
         cmd.run()
-        self.assertEquals(cmd.compiler, 'unix')
+        self.assertEqual(cmd.compiler, 'unix')
 
     def test_get_outputs(self):
         tmp_dir = self.mkdtemp()
@@ -272,7 +272,7 @@
         cmd = build_ext(dist)
         self._fixup_command(cmd)
         cmd.ensure_finalized()
-        self.assertEquals(len(cmd.get_outputs()), 1)
+        self.assertEqual(len(cmd.get_outputs()), 1)
 
         if os.name == "nt":
             cmd.debug = sys.executable.endswith("_d.exe")
@@ -291,20 +291,20 @@
             so_file = cmd.get_outputs()[0]
         finally:
             os.chdir(old_wd)
-        self.assert_(os.path.exists(so_file))
-        self.assertEquals(os.path.splitext(so_file)[-1],
-                          sysconfig.get_config_var('SO'))
+        self.assertTrue(os.path.exists(so_file))
+        self.assertEqual(os.path.splitext(so_file)[-1],
+                         sysconfig.get_config_var('SO'))
         so_dir = os.path.dirname(so_file)
-        self.assertEquals(so_dir, other_tmp_dir)
+        self.assertEqual(so_dir, other_tmp_dir)
         cmd.compiler = None
         cmd.inplace = 0
         cmd.run()
         so_file = cmd.get_outputs()[0]
-        self.assert_(os.path.exists(so_file))
-        self.assertEquals(os.path.splitext(so_file)[-1],
-                          sysconfig.get_config_var('SO'))
+        self.assertTrue(os.path.exists(so_file))
+        self.assertEqual(os.path.splitext(so_file)[-1],
+                         sysconfig.get_config_var('SO'))
         so_dir = os.path.dirname(so_file)
-        self.assertEquals(so_dir, cmd.build_lib)
+        self.assertEqual(so_dir, cmd.build_lib)
 
         # inplace = 0, cmd.package = 'bar'
         build_py = cmd.get_finalized_command('build_py')
@@ -312,7 +312,7 @@
         path = cmd.get_ext_fullpath('foo')
         # checking that the last directory is the build_dir
         path = os.path.split(path)[0]
-        self.assertEquals(path, cmd.build_lib)
+        self.assertEqual(path, cmd.build_lib)
 
         # inplace = 1, cmd.package = 'bar'
         cmd.inplace = 1
@@ -326,7 +326,7 @@
         # checking that the last directory is bar
         path = os.path.split(path)[0]
         lastdir = os.path.split(path)[-1]
-        self.assertEquals(lastdir, 'bar')
+        self.assertEqual(lastdir, 'bar')
 
     def test_ext_fullpath(self):
         ext = sysconfig.get_config_vars()['SO']
@@ -338,14 +338,14 @@
         curdir = os.getcwd()
         wanted = os.path.join(curdir, 'src', 'lxml', 'etree' + ext)
         path = cmd.get_ext_fullpath('lxml.etree')
-        self.assertEquals(wanted, path)
+        self.assertEqual(wanted, path)
 
         # building lxml.etree not inplace
         cmd.inplace = 0
         cmd.build_lib = os.path.join(curdir, 'tmpdir')
         wanted = os.path.join(curdir, 'tmpdir', 'lxml', 'etree' + ext)
         path = cmd.get_ext_fullpath('lxml.etree')
-        self.assertEquals(wanted, path)
+        self.assertEqual(wanted, path)
 
         # building twisted.runner.portmap not inplace
         build_py = cmd.get_finalized_command('build_py')
@@ -354,13 +354,13 @@
         path = cmd.get_ext_fullpath('twisted.runner.portmap')
         wanted = os.path.join(curdir, 'tmpdir', 'twisted', 'runner',
                               'portmap' + ext)
-        self.assertEquals(wanted, path)
+        self.assertEqual(wanted, path)
 
         # building twisted.runner.portmap inplace
         cmd.inplace = 1
         path = cmd.get_ext_fullpath('twisted.runner.portmap')
         wanted = os.path.join(curdir, 'twisted', 'runner', 'portmap' + ext)
-        self.assertEquals(wanted, path)
+        self.assertEqual(wanted, path)
 
     def test_build_ext_inplace(self):
         etree_c = os.path.join(self.tmp_dir, 'lxml.etree.c')
@@ -375,7 +375,7 @@
         ext = sysconfig.get_config_var("SO")
         wanted = os.path.join(curdir, 'src', 'lxml', 'etree' + ext)
         path = cmd.get_ext_fullpath('lxml.etree')
-        self.assertEquals(wanted, path)
+        self.assertEqual(wanted, path)
 
     def test_setuptools_compat(self):
         import distutils.core, distutils.extension, distutils.command.build_ext
@@ -400,7 +400,7 @@
             ext = sysconfig.get_config_var("SO")
             wanted = os.path.join(curdir, 'src', 'lxml', 'etree' + ext)
             path = cmd.get_ext_fullpath('lxml.etree')
-            self.assertEquals(wanted, path)
+            self.assertEqual(wanted, path)
         finally:
             # restoring Distutils' Extension class otherwise its broken
             distutils.extension.Extension = saved_ext
@@ -415,7 +415,7 @@
         ext_name = os.path.join('UpdateManager', 'fdsend')
         ext_path = cmd.get_ext_fullpath(ext_name)
         wanted = os.path.join(cmd.build_lib, 'UpdateManager', 'fdsend' + ext)
-        self.assertEquals(ext_path, wanted)
+        self.assertEqual(ext_path, wanted)
 
     def test_build_ext_path_cross_platform(self):
         if sys.platform != 'win32':
@@ -428,7 +428,7 @@
         ext_name = 'UpdateManager/fdsend'
         ext_path = cmd.get_ext_fullpath(ext_name)
         wanted = os.path.join(cmd.build_lib, 'UpdateManager', 'fdsend' + ext)
-        self.assertEquals(ext_path, wanted)
+        self.assertEqual(ext_path, wanted)
 
 def test_suite():
     return unittest.makeSuite(BuildExtTestCase)
diff --git a/lib-python/2.7.0/distutils/tests/test_build_py.py b/lib-python/2.7/distutils/tests/test_build_py.py
rename from lib-python/2.7.0/distutils/tests/test_build_py.py
rename to lib-python/2.7/distutils/tests/test_build_py.py
--- a/lib-python/2.7.0/distutils/tests/test_build_py.py
+++ b/lib-python/2.7/distutils/tests/test_build_py.py
@@ -19,11 +19,15 @@
     def _setup_package_data(self):
         sources = self.mkdtemp()
         f = open(os.path.join(sources, "__init__.py"), "w")
-        f.write("# Pretend this is a package.")
-        f.close()
+        try:
+            f.write("# Pretend this is a package.")
+        finally:
+            f.close()
         f = open(os.path.join(sources, "README.txt"), "w")
-        f.write("Info about this package")
-        f.close()
+        try:
+            f.write("Info about this package")
+        finally:
+            f.close()
 
         destination = self.mkdtemp()
 
diff --git a/lib-python/2.7.0/distutils/tests/test_build_scripts.py b/lib-python/2.7/distutils/tests/test_build_scripts.py
rename from lib-python/2.7.0/distutils/tests/test_build_scripts.py
rename to lib-python/2.7/distutils/tests/test_build_scripts.py
--- a/lib-python/2.7.0/distutils/tests/test_build_scripts.py
+++ b/lib-python/2.7/distutils/tests/test_build_scripts.py
@@ -71,8 +71,10 @@
 
     def write_script(self, dir, name, text):
         f = open(os.path.join(dir, name), "w")
-        f.write(text)
-        f.close()
+        try:
+            f.write(text)
+        finally:
+            f.close()
 
     def test_version_int(self):
         source = self.mkdtemp()
diff --git a/lib-python/2.7.0/distutils/tests/test_ccompiler.py b/lib-python/2.7/distutils/tests/test_ccompiler.py
rename from lib-python/2.7.0/distutils/tests/test_ccompiler.py
rename to lib-python/2.7/distutils/tests/test_ccompiler.py
--- a/lib-python/2.7.0/distutils/tests/test_ccompiler.py
+++ b/lib-python/2.7/distutils/tests/test_ccompiler.py
@@ -32,7 +32,7 @@
         opts = gen_lib_options(compiler, libdirs, runlibdirs, libs)
         wanted = ['-Llib1', '-Llib2', '-cool', '-Rrunlib1', 'found',
                   '-lname2']
-        self.assertEquals(opts, wanted)
+        self.assertEqual(opts, wanted)
 
     def test_debug_print(self):
 
@@ -43,14 +43,14 @@
         with captured_stdout() as stdout:
             compiler.debug_print('xxx')
         stdout.seek(0)
-        self.assertEquals(stdout.read(), '')
+        self.assertEqual(stdout.read(), '')
 
         debug.DEBUG = True
         try:
             with captured_stdout() as stdout:
                 compiler.debug_print('xxx')
             stdout.seek(0)
-            self.assertEquals(stdout.read(), 'xxx\n')
+            self.assertEqual(stdout.read(), 'xxx\n')
         finally:
             debug.DEBUG = False
 
@@ -72,7 +72,7 @@
 
         comp = compiler()
         customize_compiler(comp)
-        self.assertEquals(comp.exes['archiver'], 'my_ar -arflags')
+        self.assertEqual(comp.exes['archiver'], 'my_ar -arflags')
 
 def test_suite():
     return unittest.makeSuite(CCompilerTestCase)
diff --git a/lib-python/2.7.0/distutils/tests/test_check.py b/lib-python/2.7/distutils/tests/test_check.py
rename from lib-python/2.7.0/distutils/tests/test_check.py
rename to lib-python/2.7/distutils/tests/test_check.py
--- a/lib-python/2.7.0/distutils/tests/test_check.py
+++ b/lib-python/2.7/distutils/tests/test_check.py
@@ -26,7 +26,7 @@
         # by default, check is checking the metadata
         # should have some warnings
         cmd = self._run()
-        self.assertEquals(cmd._warnings, 2)
+        self.assertEqual(cmd._warnings, 2)
 
         # now let's add the required fields
         # and run it again, to make sure we don't get
@@ -35,7 +35,7 @@
                     'author_email': 'xxx',
                     'name': 'xxx', 'version': 'xxx'}
         cmd = self._run(metadata)
-        self.assertEquals(cmd._warnings, 0)
+        self.assertEqual(cmd._warnings, 0)
 
         # now with the strict mode, we should
         # get an error if there are missing metadata
@@ -43,7 +43,7 @@
 
         # and of course, no error when all metadata are present
         cmd = self._run(metadata, strict=1)
-        self.assertEquals(cmd._warnings, 0)
+        self.assertEqual(cmd._warnings, 0)
 
     def test_check_document(self):
         if not HAS_DOCUTILS: # won't test without docutils
@@ -54,12 +54,12 @@
         # let's see if it detects broken rest
         broken_rest = 'title\n===\n\ntest'
         msgs = cmd._check_rst_data(broken_rest)
-        self.assertEquals(len(msgs), 1)
+        self.assertEqual(len(msgs), 1)
 
         # and non-broken rest
         rest = 'title\n=====\n\ntest'
         msgs = cmd._check_rst_data(rest)
-        self.assertEquals(len(msgs), 0)
+        self.assertEqual(len(msgs), 0)
 
     def test_check_restructuredtext(self):
         if not HAS_DOCUTILS: # won't test without docutils
@@ -69,7 +69,7 @@
         pkg_info, dist = self.create_dist(long_description=broken_rest)
         cmd = check(dist)
         cmd.check_restructuredtext()
-        self.assertEquals(cmd._warnings, 1)
+        self.assertEqual(cmd._warnings, 1)
 
         # let's see if we have an error with strict=1
         metadata = {'url': 'xxx', 'author': 'xxx',
@@ -82,7 +82,7 @@
         # and non-broken rest
         metadata['long_description'] = 'title\n=====\n\ntest'
         cmd = self._run(metadata, strict=1, restructuredtext=1)
-        self.assertEquals(cmd._warnings, 0)
+        self.assertEqual(cmd._warnings, 0)
 
     def test_check_all(self):
 
diff --git a/lib-python/2.7.0/distutils/tests/test_clean.py b/lib-python/2.7/distutils/tests/test_clean.py
rename from lib-python/2.7.0/distutils/tests/test_clean.py
rename to lib-python/2.7/distutils/tests/test_clean.py
diff --git a/lib-python/2.7.0/distutils/tests/test_cmd.py b/lib-python/2.7/distutils/tests/test_cmd.py
rename from lib-python/2.7.0/distutils/tests/test_cmd.py
rename to lib-python/2.7/distutils/tests/test_cmd.py
--- a/lib-python/2.7.0/distutils/tests/test_cmd.py
+++ b/lib-python/2.7/distutils/tests/test_cmd.py
@@ -44,7 +44,7 @@
 
         # making sure execute gets called properly
         def _execute(func, args, exec_msg, level):
-            self.assertEquals(exec_msg, 'generating out from in')
+            self.assertEqual(exec_msg, 'generating out from in')
         cmd.force = True
         cmd.execute = _execute
         cmd.make_file(infiles='in', outfile='out', func='func', args=())
@@ -63,7 +63,7 @@
 
         wanted = ["command options for 'MyCmd':", '  option1 = 1',
                   '  option2 = 1']
-        self.assertEquals(msgs, wanted)
+        self.assertEqual(msgs, wanted)
 
     def test_ensure_string(self):
         cmd = self.cmd
@@ -81,7 +81,7 @@
         cmd = self.cmd
         cmd.option1 = 'ok,dok'
         cmd.ensure_string_list('option1')
-        self.assertEquals(cmd.option1, ['ok', 'dok'])
+        self.assertEqual(cmd.option1, ['ok', 'dok'])
 
         cmd.option2 = ['xxx', 'www']
         cmd.ensure_string_list('option2')
@@ -109,14 +109,14 @@
         with captured_stdout() as stdout:
             cmd.debug_print('xxx')
         stdout.seek(0)
-        self.assertEquals(stdout.read(), '')
+        self.assertEqual(stdout.read(), '')
 
         debug.DEBUG = True
         try:
             with captured_stdout() as stdout:
                 cmd.debug_print('xxx')
             stdout.seek(0)
-            self.assertEquals(stdout.read(), 'xxx\n')
+            self.assertEqual(stdout.read(), 'xxx\n')
         finally:
             debug.DEBUG = False
 
diff --git a/lib-python/2.7.0/distutils/tests/test_config.py b/lib-python/2.7/distutils/tests/test_config.py
rename from lib-python/2.7.0/distutils/tests/test_config.py
rename to lib-python/2.7/distutils/tests/test_config.py
--- a/lib-python/2.7.0/distutils/tests/test_config.py
+++ b/lib-python/2.7/distutils/tests/test_config.py
@@ -90,7 +90,7 @@
         waited = [('password', 'secret'), ('realm', 'pypi'),
                   ('repository', 'http://pypi.python.org/pypi'),
                   ('server', 'server1'), ('username', 'me')]
-        self.assertEquals(config, waited)
+        self.assertEqual(config, waited)
 
         # old format
         self.write_file(self.rc, PYPIRC_OLD)
@@ -100,7 +100,7 @@
         waited = [('password', 'secret'), ('realm', 'pypi'),
                   ('repository', 'http://pypi.python.org/pypi'),
                   ('server', 'server-login'), ('username', 'tarek')]
-        self.assertEquals(config, waited)
+        self.assertEqual(config, waited)
 
     def test_server_empty_registration(self):
         cmd = self._cmd(self.dist)
@@ -108,8 +108,12 @@
         self.assertTrue(not os.path.exists(rc))
         cmd._store_pypirc('tarek', 'xxx')
         self.assertTrue(os.path.exists(rc))
-        content = open(rc).read()
-        self.assertEquals(content, WANTED)
+        f = open(rc)
+        try:
+            content = f.read()
+            self.assertEqual(content, WANTED)
+        finally:
+            f.close()
 
 def test_suite():
     return unittest.makeSuite(PyPIRCCommandTestCase)
diff --git a/lib-python/2.7.0/distutils/tests/test_config_cmd.py b/lib-python/2.7/distutils/tests/test_config_cmd.py
rename from lib-python/2.7.0/distutils/tests/test_config_cmd.py
rename to lib-python/2.7/distutils/tests/test_config_cmd.py
--- a/lib-python/2.7.0/distutils/tests/test_config_cmd.py
+++ b/lib-python/2.7/distutils/tests/test_config_cmd.py
@@ -34,7 +34,7 @@
             f.close()
 
         dump_file(this_file, 'I am the header')
-        self.assertEquals(len(self._logs), numlines+1)
+        self.assertEqual(len(self._logs), numlines+1)
 
     def test_search_cpp(self):
         if sys.platform == 'win32':
@@ -44,10 +44,10 @@
 
         # simple pattern searches
         match = cmd.search_cpp(pattern='xxx', body='// xxx')
-        self.assertEquals(match, 0)
+        self.assertEqual(match, 0)
 
         match = cmd.search_cpp(pattern='_configtest', body='// xxx')
-        self.assertEquals(match, 1)
+        self.assertEqual(match, 1)
 
     def test_finalize_options(self):
         # finalize_options does a bit of transformation
@@ -59,9 +59,9 @@
         cmd.library_dirs = 'three%sfour' % os.pathsep
         cmd.ensure_finalized()
 
-        self.assertEquals(cmd.include_dirs, ['one', 'two'])
-        self.assertEquals(cmd.libraries, ['one'])
-        self.assertEquals(cmd.library_dirs, ['three', 'four'])
+        self.assertEqual(cmd.include_dirs, ['one', 'two'])
+        self.assertEqual(cmd.libraries, ['one'])
+        self.assertEqual(cmd.library_dirs, ['three', 'four'])
 
     def test_clean(self):
         # _clean removes files
diff --git a/lib-python/2.7.0/distutils/tests/test_core.py b/lib-python/2.7/distutils/tests/test_core.py
rename from lib-python/2.7.0/distutils/tests/test_core.py
rename to lib-python/2.7/distutils/tests/test_core.py
--- a/lib-python/2.7.0/distutils/tests/test_core.py
+++ b/lib-python/2.7/distutils/tests/test_core.py
@@ -52,7 +52,11 @@
             shutil.rmtree(path)
 
     def write_setup(self, text, path=test.test_support.TESTFN):
-        open(path, "w").write(text)
+        f = open(path, "w")
+        try:
+            f.write(text)
+        finally:
+            f.close()
         return path
 
     def test_run_setup_provides_file(self):
@@ -85,7 +89,7 @@
         with captured_stdout() as stdout:
             distutils.core.setup(name='bar')
         stdout.seek(0)
-        self.assertEquals(stdout.read(), 'bar\n')
+        self.assertEqual(stdout.read(), 'bar\n')
 
         distutils.core.DEBUG = True
         try:
@@ -95,7 +99,7 @@
             distutils.core.DEBUG = False
         stdout.seek(0)
         wanted = "options (after parsing config files):\n"
-        self.assertEquals(stdout.readlines()[0], wanted)
+        self.assertEqual(stdout.readlines()[0], wanted)
 
 def test_suite():
     return unittest.makeSuite(CoreTestCase)
diff --git a/lib-python/2.7.0/distutils/tests/test_dep_util.py b/lib-python/2.7/distutils/tests/test_dep_util.py
rename from lib-python/2.7.0/distutils/tests/test_dep_util.py
rename to lib-python/2.7/distutils/tests/test_dep_util.py
--- a/lib-python/2.7.0/distutils/tests/test_dep_util.py
+++ b/lib-python/2.7/distutils/tests/test_dep_util.py
@@ -42,8 +42,8 @@
         self.write_file(two)
         self.write_file(four)
 
-        self.assertEquals(newer_pairwise([one, two], [three, four]),
-                          ([one],[three]))
+        self.assertEqual(newer_pairwise([one, two], [three, four]),
+                         ([one],[three]))
 
     def test_newer_group(self):
         tmpdir = self.mkdtemp()
diff --git a/lib-python/2.7.0/distutils/tests/test_dir_util.py b/lib-python/2.7/distutils/tests/test_dir_util.py
rename from lib-python/2.7.0/distutils/tests/test_dir_util.py
rename to lib-python/2.7/distutils/tests/test_dir_util.py
--- a/lib-python/2.7.0/distutils/tests/test_dir_util.py
+++ b/lib-python/2.7/distutils/tests/test_dir_util.py
@@ -37,18 +37,18 @@
 
         mkpath(self.target, verbose=0)
         wanted = []
-        self.assertEquals(self._logs, wanted)
+        self.assertEqual(self._logs, wanted)
         remove_tree(self.root_target, verbose=0)
 
         mkpath(self.target, verbose=1)
         wanted = ['creating %s' % self.root_target,
                   'creating %s' % self.target]
-        self.assertEquals(self._logs, wanted)
+        self.assertEqual(self._logs, wanted)
         self._logs = []
 
         remove_tree(self.root_target, verbose=1)
         wanted = ["removing '%s' (and everything under it)" % self.root_target]
-        self.assertEquals(self._logs, wanted)
+        self.assertEqual(self._logs, wanted)
 
     @unittest.skipIf(sys.platform.startswith('win'),
                         "This test is only appropriate for POSIX-like systems.")
@@ -66,12 +66,12 @@
     def test_create_tree_verbosity(self):
 
         create_tree(self.root_target, ['one', 'two', 'three'], verbose=0)
-        self.assertEquals(self._logs, [])
+        self.assertEqual(self._logs, [])
         remove_tree(self.root_target, verbose=0)
 
         wanted = ['creating %s' % self.root_target]
         create_tree(self.root_target, ['one', 'two', 'three'], verbose=1)
-        self.assertEquals(self._logs, wanted)
+        self.assertEqual(self._logs, wanted)
 
         remove_tree(self.root_target, verbose=0)
 
@@ -81,30 +81,32 @@
         mkpath(self.target, verbose=0)
 
         copy_tree(self.target, self.target2, verbose=0)
-        self.assertEquals(self._logs, [])
+        self.assertEqual(self._logs, [])
 
         remove_tree(self.root_target, verbose=0)
 
         mkpath(self.target, verbose=0)
         a_file = os.path.join(self.target, 'ok.txt')
         f = open(a_file, 'w')
-        f.write('some content')
-        f.close()
+        try:
+            f.write('some content')
+        finally:
+            f.close()
 
         wanted = ['copying %s -> %s' % (a_file, self.target2)]
         copy_tree(self.target, self.target2, verbose=1)
-        self.assertEquals(self._logs, wanted)
+        self.assertEqual(self._logs, wanted)
 
         remove_tree(self.root_target, verbose=0)
         remove_tree(self.target2, verbose=0)
 
     def test_ensure_relative(self):
         if os.sep == '/':
-            self.assertEquals(ensure_relative('/home/foo'), 'home/foo')
-            self.assertEquals(ensure_relative('some/path'), 'some/path')
+            self.assertEqual(ensure_relative('/home/foo'), 'home/foo')
+            self.assertEqual(ensure_relative('some/path'), 'some/path')
         else:   # \\
-            self.assertEquals(ensure_relative('c:\\home\\foo'), 'c:home\\foo')
-            self.assertEquals(ensure_relative('home\\foo'), 'home\\foo')
+            self.assertEqual(ensure_relative('c:\\home\\foo'), 'c:home\\foo')
+            self.assertEqual(ensure_relative('home\\foo'), 'home\\foo')
 
 def test_suite():
     return unittest.makeSuite(DirUtilTestCase)
diff --git a/lib-python/2.7.0/distutils/tests/test_dist.py b/lib-python/2.7/distutils/tests/test_dist.py
rename from lib-python/2.7.0/distutils/tests/test_dist.py
rename to lib-python/2.7/distutils/tests/test_dist.py
--- a/lib-python/2.7.0/distutils/tests/test_dist.py
+++ b/lib-python/2.7/distutils/tests/test_dist.py
@@ -70,13 +70,13 @@
         with captured_stdout() as stdout:
             self.create_distribution(files)
         stdout.seek(0)
-        self.assertEquals(stdout.read(), '')
+        self.assertEqual(stdout.read(), '')
         distutils.dist.DEBUG = True
         try:
             with captured_stdout() as stdout:
                 self.create_distribution(files)
             stdout.seek(0)
-            self.assertEquals(stdout.read(), '')
+            self.assertEqual(stdout.read(), '')
         finally:
             distutils.dist.DEBUG = False
 
@@ -102,29 +102,29 @@
 
     def test_command_packages_configfile(self):
         sys.argv.append("build")
+        self.addCleanup(os.unlink, TESTFN)
         f = open(TESTFN, "w")
         try:
             print >>f, "[global]"
             print >>f, "command_packages = foo.bar, splat"
+        finally:
             f.close()
-            d = self.create_distribution([TESTFN])
-            self.assertEqual(d.get_command_packages(),
-                             ["distutils.command", "foo.bar", "splat"])
 
-            # ensure command line overrides config:
-            sys.argv[1:] = ["--command-packages", "spork", "build"]
-            d = self.create_distribution([TESTFN])
-            self.assertEqual(d.get_command_packages(),
-                             ["distutils.command", "spork"])
+        d = self.create_distribution([TESTFN])
+        self.assertEqual(d.get_command_packages(),
+                         ["distutils.command", "foo.bar", "splat"])
 
-            # Setting --command-packages to '' should cause the default to
-            # be used even if a config file specified something else:
-            sys.argv[1:] = ["--command-packages", "", "build"]
-            d = self.create_distribution([TESTFN])
-            self.assertEqual(d.get_command_packages(), ["distutils.command"])
+        # ensure command line overrides config:
+        sys.argv[1:] = ["--command-packages", "spork", "build"]
+        d = self.create_distribution([TESTFN])
+        self.assertEqual(d.get_command_packages(),
+                         ["distutils.command", "spork"])
 
-        finally:
-            os.unlink(TESTFN)
+        # Setting --command-packages to '' should cause the default to
+        # be used even if a config file specified something else:
+        sys.argv[1:] = ["--command-packages", "", "build"]
+        d = self.create_distribution([TESTFN])
+        self.assertEqual(d.get_command_packages(), ["distutils.command"])
 
     def test_write_pkg_file(self):
         # Check DistributionMetadata handling of Unicode fields
@@ -175,7 +175,7 @@
         finally:
             warnings.warn = old_warn
 
-        self.assertEquals(len(warns), 0)
+        self.assertEqual(len(warns), 0)
 
     def test_finalize_options(self):
 
@@ -186,20 +186,20 @@
         dist.finalize_options()
 
         # finalize_option splits platforms and keywords
-        self.assertEquals(dist.metadata.platforms, ['one', 'two'])
-        self.assertEquals(dist.metadata.keywords, ['one', 'two'])
+        self.assertEqual(dist.metadata.platforms, ['one', 'two'])
+        self.assertEqual(dist.metadata.keywords, ['one', 'two'])
 
     def test_get_command_packages(self):
         dist = Distribution()
-        self.assertEquals(dist.command_packages, None)
+        self.assertEqual(dist.command_packages, None)
         cmds = dist.get_command_packages()
-        self.assertEquals(cmds, ['distutils.command'])
-        self.assertEquals(dist.command_packages,
-                          ['distutils.command'])
+        self.assertEqual(cmds, ['distutils.command'])
+        self.assertEqual(dist.command_packages,
+                         ['distutils.command'])
 
         dist.command_packages = 'one,two'
         cmds = dist.get_command_packages()
-        self.assertEquals(cmds, ['distutils.command', 'one', 'two'])
+        self.assertEqual(cmds, ['distutils.command', 'one', 'two'])
 
 
     def test_announce(self):
@@ -236,7 +236,7 @@
             os.path.expanduser = old_expander
 
         # make sure --no-user-cfg disables the user cfg file
-        self.assertEquals(len(all_files)-1, len(files))
+        self.assertEqual(len(all_files)-1, len(files))
 
 
 class MetadataTestCase(support.TempdirManager, support.EnvironGuard,
@@ -341,8 +341,10 @@
         temp_dir = self.mkdtemp()
         user_filename = os.path.join(temp_dir, user_filename)
         f = open(user_filename, 'w')
-        f.write('.')
-        f.close()
+        try:
+            f.write('.')
+        finally:
+            f.close()
 
         try:
             dist = Distribution()
@@ -366,8 +368,8 @@
     def test_fix_help_options(self):
         help_tuples = [('a', 'b', 'c', 'd'), (1, 2, 3, 4)]
         fancy_options = fix_help_options(help_tuples)
-        self.assertEquals(fancy_options[0], ('a', 'b', 'c'))
-        self.assertEquals(fancy_options[1], (1, 2, 3))
+        self.assertEqual(fancy_options[0], ('a', 'b', 'c'))
+        self.assertEqual(fancy_options[1], (1, 2, 3))
 
     def test_show_help(self):
         # smoke test, just makes sure some help is displayed
@@ -415,14 +417,14 @@
         PKG_INFO.seek(0)
         metadata.read_pkg_file(PKG_INFO)
 
-        self.assertEquals(metadata.name, "package")
-        self.assertEquals(metadata.version, "1.0")
-        self.assertEquals(metadata.description, "xxx")
-        self.assertEquals(metadata.download_url, 'http://example.com')
-        self.assertEquals(metadata.keywords, ['one', 'two'])
-        self.assertEquals(metadata.platforms, ['UNKNOWN'])
-        self.assertEquals(metadata.obsoletes, None)
-        self.assertEquals(metadata.requires, ['foo'])
+        self.assertEqual(metadata.name, "package")
+        self.assertEqual(metadata.version, "1.0")
+        self.assertEqual(metadata.description, "xxx")
+        self.assertEqual(metadata.download_url, 'http://example.com')
+        self.assertEqual(metadata.keywords, ['one', 'two'])
+        self.assertEqual(metadata.platforms, ['UNKNOWN'])
+        self.assertEqual(metadata.obsoletes, None)
+        self.assertEqual(metadata.requires, ['foo'])
 
 def test_suite():
     suite = unittest.TestSuite()
diff --git a/lib-python/2.7.0/distutils/tests/test_file_util.py b/lib-python/2.7/distutils/tests/test_file_util.py
rename from lib-python/2.7.0/distutils/tests/test_file_util.py
rename to lib-python/2.7/distutils/tests/test_file_util.py
--- a/lib-python/2.7.0/distutils/tests/test_file_util.py
+++ b/lib-python/2.7/distutils/tests/test_file_util.py
@@ -31,19 +31,21 @@
 
     def test_move_file_verbosity(self):
         f = open(self.source, 'w')
-        f.write('some content')
-        f.close()
+        try:
+            f.write('some content')
+        finally:
+            f.close()
 
         move_file(self.source, self.target, verbose=0)
         wanted = []
-        self.assertEquals(self._logs, wanted)
+        self.assertEqual(self._logs, wanted)
 
         # back to original state
         move_file(self.target, self.source, verbose=0)
 
         move_file(self.source, self.target, verbose=1)
         wanted = ['moving %s -> %s' % (self.source, self.target)]
-        self.assertEquals(self._logs, wanted)
+        self.assertEqual(self._logs, wanted)
 
         # back to original state
         move_file(self.target, self.source, verbose=0)
@@ -53,7 +55,7 @@
         os.mkdir(self.target_dir)
         move_file(self.source, self.target_dir, verbose=1)
         wanted = ['moving %s -> %s' % (self.source, self.target_dir)]
-        self.assertEquals(self._logs, wanted)
+        self.assertEqual(self._logs, wanted)
 
     def test_write_file(self):
         lines = ['a', 'b', 'c']
@@ -61,7 +63,7 @@
         foo = os.path.join(dir, 'foo')
         write_file(foo, lines)
         content = [line.strip() for line in open(foo).readlines()]
-        self.assertEquals(content, lines)
+        self.assertEqual(content, lines)
 
     def test_copy_file(self):
         src_dir = self.mkdtemp()
diff --git a/lib-python/2.7.0/distutils/tests/test_filelist.py b/lib-python/2.7/distutils/tests/test_filelist.py
rename from lib-python/2.7.0/distutils/tests/test_filelist.py
rename to lib-python/2.7/distutils/tests/test_filelist.py
--- a/lib-python/2.7.0/distutils/tests/test_filelist.py
+++ b/lib-python/2.7/distutils/tests/test_filelist.py
@@ -24,15 +24,15 @@
 
     def test_glob_to_re(self):
         # simple cases
-        self.assertEquals(glob_to_re('foo*'), 'foo[^/]*\\Z(?ms)')
-        self.assertEquals(glob_to_re('foo?'), 'foo[^/]\\Z(?ms)')
-        self.assertEquals(glob_to_re('foo??'), 'foo[^/][^/]\\Z(?ms)')
+        self.assertEqual(glob_to_re('foo*'), 'foo[^/]*\\Z(?ms)')
+        self.assertEqual(glob_to_re('foo?'), 'foo[^/]\\Z(?ms)')
+        self.assertEqual(glob_to_re('foo??'), 'foo[^/][^/]\\Z(?ms)')
 
         # special cases
-        self.assertEquals(glob_to_re(r'foo\\*'), r'foo\\\\[^/]*\Z(?ms)')
-        self.assertEquals(glob_to_re(r'foo\\\*'), r'foo\\\\\\[^/]*\Z(?ms)')
-        self.assertEquals(glob_to_re('foo????'), r'foo[^/][^/][^/][^/]\Z(?ms)')
-        self.assertEquals(glob_to_re(r'foo\\??'), r'foo\\\\[^/][^/]\Z(?ms)')
+        self.assertEqual(glob_to_re(r'foo\\*'), r'foo\\\\[^/]*\Z(?ms)')
+        self.assertEqual(glob_to_re(r'foo\\\*'), r'foo\\\\\\[^/]*\Z(?ms)')
+        self.assertEqual(glob_to_re('foo????'), r'foo[^/][^/][^/][^/]\Z(?ms)')
+        self.assertEqual(glob_to_re(r'foo\\??'), r'foo\\\\[^/][^/]\Z(?ms)')
 
     def test_process_template_line(self):
         # testing  all MANIFEST.in template patterns
@@ -60,21 +60,21 @@
                   join('global', 'two.txt'), join('f', 'o', 'f.oo'),
                   join('dir', 'graft-one'), join('dir', 'dir2', 'graft2')]
 
-        self.assertEquals(file_list.files, wanted)
+        self.assertEqual(file_list.files, wanted)
 
     def test_debug_print(self):
         file_list = FileList()
         with captured_stdout() as stdout:
             file_list.debug_print('xxx')
         stdout.seek(0)
-        self.assertEquals(stdout.read(), '')
+        self.assertEqual(stdout.read(), '')
 
         debug.DEBUG = True
         try:
             with captured_stdout() as stdout:
                 file_list.debug_print('xxx')
             stdout.seek(0)
-            self.assertEquals(stdout.read(), 'xxx\n')
+            self.assertEqual(stdout.read(), 'xxx\n')
         finally:
             debug.DEBUG = False
 
diff --git a/lib-python/2.7.0/distutils/tests/test_install.py b/lib-python/2.7/distutils/tests/test_install.py
rename from lib-python/2.7.0/distutils/tests/test_install.py
rename to lib-python/2.7/distutils/tests/test_install.py
diff --git a/lib-python/2.7.0/distutils/tests/test_install_data.py b/lib-python/2.7/distutils/tests/test_install_data.py
rename from lib-python/2.7.0/distutils/tests/test_install_data.py
rename to lib-python/2.7/distutils/tests/test_install_data.py
--- a/lib-python/2.7.0/distutils/tests/test_install_data.py
+++ b/lib-python/2.7/distutils/tests/test_install_data.py
@@ -27,14 +27,14 @@
         self.write_file(two, 'xxx')
 
         cmd.data_files = [one, (inst2, [two])]
-        self.assertEquals(cmd.get_inputs(), [one, (inst2, [two])])
+        self.assertEqual(cmd.get_inputs(), [one, (inst2, [two])])
 
         # let's run the command
         cmd.ensure_finalized()
         cmd.run()
 
         # let's check the result
-        self.assertEquals(len(cmd.get_outputs()), 2)
+        self.assertEqual(len(cmd.get_outputs()), 2)
         rtwo = os.path.split(two)[-1]
         self.assertTrue(os.path.exists(os.path.join(inst2, rtwo)))
         rone = os.path.split(one)[-1]
@@ -47,7 +47,7 @@
         cmd.run()
 
         # let's check the result
-        self.assertEquals(len(cmd.get_outputs()), 2)
+        self.assertEqual(len(cmd.get_outputs()), 2)
         self.assertTrue(os.path.exists(os.path.join(inst2, rtwo)))
         self.assertTrue(os.path.exists(os.path.join(inst, rone)))
         cmd.outfiles = []
@@ -65,7 +65,7 @@
         cmd.run()
 
         # let's check the result
-        self.assertEquals(len(cmd.get_outputs()), 4)
+        self.assertEqual(len(cmd.get_outputs()), 4)
         self.assertTrue(os.path.exists(os.path.join(inst2, rtwo)))
         self.assertTrue(os.path.exists(os.path.join(inst, rone)))
 
diff --git a/lib-python/2.7.0/distutils/tests/test_install_headers.py b/lib-python/2.7/distutils/tests/test_install_headers.py
rename from lib-python/2.7.0/distutils/tests/test_install_headers.py
rename to lib-python/2.7/distutils/tests/test_install_headers.py
--- a/lib-python/2.7.0/distutils/tests/test_install_headers.py
+++ b/lib-python/2.7/distutils/tests/test_install_headers.py
@@ -23,7 +23,7 @@
 
         pkg_dir, dist = self.create_dist(headers=headers)
         cmd = install_headers(dist)
-        self.assertEquals(cmd.get_inputs(), headers)
+        self.assertEqual(cmd.get_inputs(), headers)
 
         # let's run the command
         cmd.install_dir = os.path.join(pkg_dir, 'inst')
@@ -31,7 +31,7 @@
         cmd.run()
 
         # let's check the results
-        self.assertEquals(len(cmd.get_outputs()), 2)
+        self.assertEqual(len(cmd.get_outputs()), 2)
 
 def test_suite():
     return unittest.makeSuite(InstallHeadersTestCase)
diff --git a/lib-python/2.7.0/distutils/tests/test_install_lib.py b/lib-python/2.7/distutils/tests/test_install_lib.py
rename from lib-python/2.7.0/distutils/tests/test_install_lib.py
rename to lib-python/2.7/distutils/tests/test_install_lib.py
--- a/lib-python/2.7.0/distutils/tests/test_install_lib.py
+++ b/lib-python/2.7/distutils/tests/test_install_lib.py
@@ -18,8 +18,8 @@
         cmd = install_lib(dist)
 
         cmd.finalize_options()
-        self.assertEquals(cmd.compile, 1)
-        self.assertEquals(cmd.optimize, 0)
+        self.assertEqual(cmd.compile, 1)
+        self.assertEqual(cmd.optimize, 0)
 
         # optimize must be 0, 1, or 2
         cmd.optimize = 'foo'
@@ -29,7 +29,7 @@
 
         cmd.optimize = '2'
         cmd.finalize_options()
-        self.assertEquals(cmd.optimize, 2)
+        self.assertEqual(cmd.optimize, 2)
 
     def _setup_byte_compile(self):
         pkg_dir, dist = self.create_dist()
@@ -81,7 +81,7 @@
         cmd.distribution.script_name = 'setup.py'
 
         # get_input should return 2 elements
-        self.assertEquals(len(cmd.get_inputs()), 2)
+        self.assertEqual(len(cmd.get_inputs()), 2)
 
     def test_dont_write_bytecode(self):
         # makes sure byte_compile is not used
diff --git a/lib-python/2.7.0/distutils/tests/test_install_scripts.py b/lib-python/2.7/distutils/tests/test_install_scripts.py
rename from lib-python/2.7.0/distutils/tests/test_install_scripts.py
rename to lib-python/2.7/distutils/tests/test_install_scripts.py
--- a/lib-python/2.7.0/distutils/tests/test_install_scripts.py
+++ b/lib-python/2.7/distutils/tests/test_install_scripts.py
@@ -42,8 +42,10 @@
         def write_script(name, text):
             expected.append(name)
             f = open(os.path.join(source, name), "w")
-            f.write(text)
-            f.close()
+            try:
+                f.write(text)
+            finally:
+                f.close()
 
         write_script("script1.py", ("#! /usr/bin/env python2.3\n"
                                     "# bogus script w/ Python sh-bang\n"
diff --git a/lib-python/2.7.0/distutils/tests/test_msvc9compiler.py b/lib-python/2.7/distutils/tests/test_msvc9compiler.py
rename from lib-python/2.7.0/distutils/tests/test_msvc9compiler.py
rename to lib-python/2.7/distutils/tests/test_msvc9compiler.py
--- a/lib-python/2.7.0/distutils/tests/test_msvc9compiler.py
+++ b/lib-python/2.7/distutils/tests/test_msvc9compiler.py
@@ -103,7 +103,7 @@
         import _winreg
         HKCU = _winreg.HKEY_CURRENT_USER
         keys = Reg.read_keys(HKCU, 'xxxx')
-        self.assertEquals(keys, None)
+        self.assertEqual(keys, None)
 
         keys = Reg.read_keys(HKCU, r'Control Panel')
         self.assertTrue('Desktop' in keys)
@@ -113,20 +113,24 @@
         tempdir = self.mkdtemp()
         manifest = os.path.join(tempdir, 'manifest')
         f = open(manifest, 'w')
-        f.write(_MANIFEST)
-        f.close()
+        try:
+            f.write(_MANIFEST)
+        finally:
+            f.close()
 
         compiler = MSVCCompiler()
         compiler._remove_visual_c_ref(manifest)
 
         # see what we got
         f = open(manifest)
-        # removing trailing spaces
-        content = '\n'.join([line.rstrip() for line in f.readlines()])
-        f.close()
+        try:
+            # removing trailing spaces
+            content = '\n'.join([line.rstrip() for line in f.readlines()])
+        finally:
+            f.close()
 
         # makes sure the manifest was properly cleaned
-        self.assertEquals(content, _CLEANED_MANIFEST)
+        self.assertEqual(content, _CLEANED_MANIFEST)
 
 
 def test_suite():
diff --git a/lib-python/2.7.0/distutils/tests/test_register.py b/lib-python/2.7/distutils/tests/test_register.py
rename from lib-python/2.7.0/distutils/tests/test_register.py
rename to lib-python/2.7/distutils/tests/test_register.py
--- a/lib-python/2.7.0/distutils/tests/test_register.py
+++ b/lib-python/2.7/distutils/tests/test_register.py
@@ -119,8 +119,12 @@
         self.assertTrue(os.path.exists(self.rc))
 
         # with the content similar to WANTED_PYPIRC
-        content = open(self.rc).read()
-        self.assertEquals(content, WANTED_PYPIRC)
+        f = open(self.rc)
+        try:
+            content = f.read()
+            self.assertEqual(content, WANTED_PYPIRC)
+        finally:
+            f.close()
 
         # now let's make sure the .pypirc file generated
         # really works : we shouldn't be asked anything
@@ -137,7 +141,7 @@
         self.assertTrue(self.conn.reqs, 2)
         req1 = dict(self.conn.reqs[0].headers)
         req2 = dict(self.conn.reqs[1].headers)
-        self.assertEquals(req2['Content-length'], req1['Content-length'])
+        self.assertEqual(req2['Content-length'], req1['Content-length'])
         self.assertTrue('xxx' in self.conn.reqs[1].data)
 
     def test_password_not_in_file(self):
@@ -150,7 +154,7 @@
 
         # dist.password should be set
         # therefore used afterwards by other commands
-        self.assertEquals(cmd.distribution.password, 'password')
+        self.assertEqual(cmd.distribution.password, 'password')
 
     def test_registering(self):
         # this test runs choice 2
@@ -167,7 +171,7 @@
         self.assertTrue(self.conn.reqs, 1)
         req = self.conn.reqs[0]
         headers = dict(req.headers)
-        self.assertEquals(headers['Content-length'], '608')
+        self.assertEqual(headers['Content-length'], '608')
         self.assertTrue('tarek' in req.data)
 
     def test_password_reset(self):
@@ -185,7 +189,7 @@
         self.assertTrue(self.conn.reqs, 1)
         req = self.conn.reqs[0]
         headers = dict(req.headers)
-        self.assertEquals(headers['Content-length'], '290')
+        self.assertEqual(headers['Content-length'], '290')
         self.assertTrue('tarek' in req.data)
 
     def test_strict(self):
@@ -248,7 +252,7 @@
         with check_warnings() as w:
             warnings.simplefilter("always")
             cmd.check_metadata()
-            self.assertEquals(len(w.warnings), 1)
+            self.assertEqual(len(w.warnings), 1)
 
 def test_suite():
     return unittest.makeSuite(RegisterTestCase)
diff --git a/lib-python/2.7.0/distutils/tests/test_sdist.py b/lib-python/2.7/distutils/tests/test_sdist.py
rename from lib-python/2.7.0/distutils/tests/test_sdist.py
rename to lib-python/2.7/distutils/tests/test_sdist.py
--- a/lib-python/2.7.0/distutils/tests/test_sdist.py
+++ b/lib-python/2.7/distutils/tests/test_sdist.py
@@ -127,7 +127,7 @@
         # now let's check what we have
         dist_folder = join(self.tmp_dir, 'dist')
         files = os.listdir(dist_folder)
-        self.assertEquals(files, ['fake-1.0.zip'])
+        self.assertEqual(files, ['fake-1.0.zip'])
 
         zip_file = zipfile.ZipFile(join(dist_folder, 'fake-1.0.zip'))
         try:
@@ -136,7 +136,7 @@
             zip_file.close()
 
         # making sure everything has been pruned correctly
-        self.assertEquals(len(content), 4)
+        self.assertEqual(len(content), 4)
 
     @unittest.skipUnless(zlib, "requires zlib")
     def test_make_distribution(self):
@@ -158,8 +158,7 @@
         dist_folder = join(self.tmp_dir, 'dist')
         result = os.listdir(dist_folder)
         result.sort()
-        self.assertEquals(result,
-                          ['fake-1.0.tar', 'fake-1.0.tar.gz'] )
+        self.assertEqual(result, ['fake-1.0.tar', 'fake-1.0.tar.gz'] )
 
         os.remove(join(dist_folder, 'fake-1.0.tar'))
         os.remove(join(dist_folder, 'fake-1.0.tar.gz'))
@@ -172,8 +171,7 @@
 
         result = os.listdir(dist_folder)
         result.sort()
-        self.assertEquals(result,
-                ['fake-1.0.tar', 'fake-1.0.tar.gz'])
+        self.assertEqual(result, ['fake-1.0.tar', 'fake-1.0.tar.gz'])
 
     @unittest.skipUnless(zlib, "requires zlib")
     def test_add_defaults(self):
@@ -222,7 +220,7 @@
         # now let's check what we have
         dist_folder = join(self.tmp_dir, 'dist')
         files = os.listdir(dist_folder)
-        self.assertEquals(files, ['fake-1.0.zip'])
+        self.assertEqual(files, ['fake-1.0.zip'])
 
         zip_file = zipfile.ZipFile(join(dist_folder, 'fake-1.0.zip'))
         try:
@@ -231,11 +229,15 @@
             zip_file.close()
 
         # making sure everything was added
-        self.assertEquals(len(content), 11)
+        self.assertEqual(len(content), 11)
 
         # checking the MANIFEST
-        manifest = open(join(self.tmp_dir, 'MANIFEST')).read()
-        self.assertEquals(manifest, MANIFEST % {'sep': os.sep})
+        f = open(join(self.tmp_dir, 'MANIFEST'))
+        try:
+            manifest = f.read()
+            self.assertEqual(manifest, MANIFEST % {'sep': os.sep})
+        finally:
+            f.close()
 
     @unittest.skipUnless(zlib, "requires zlib")
     def test_metadata_check_option(self):
@@ -247,7 +249,7 @@
         cmd.ensure_finalized()
         cmd.run()
         warnings = self.get_logs(WARN)
-        self.assertEquals(len(warnings), 2)
+        self.assertEqual(len(warnings), 2)
 
         # trying with a complete set of metadata
         self.clear_logs()
@@ -256,7 +258,7 @@
         cmd.metadata_check = 0
         cmd.run()
         warnings = self.get_logs(WARN)
-        self.assertEquals(len(warnings), 0)
+        self.assertEqual(len(warnings), 0)
 
     def test_check_metadata_deprecated(self):
         # makes sure make_metadata is deprecated
@@ -264,7 +266,7 @@
         with check_warnings() as w:
             warnings.simplefilter("always")
             cmd.check_metadata()
-            self.assertEquals(len(w.warnings), 1)
+            self.assertEqual(len(w.warnings), 1)
 
     def test_show_formats(self):
         with captured_stdout() as stdout:
@@ -274,7 +276,7 @@
         num_formats = len(ARCHIVE_FORMATS.keys())
         output = [line for line in stdout.getvalue().split('\n')
                   if line.strip().startswith('--formats=')]
-        self.assertEquals(len(output), num_formats)
+        self.assertEqual(len(output), num_formats)
 
     def test_finalize_options(self):
 
@@ -282,9 +284,9 @@
         cmd.finalize_options()
 
         # default options set by finalize
-        self.assertEquals(cmd.manifest, 'MANIFEST')
-        self.assertEquals(cmd.template, 'MANIFEST.in')
-        self.assertEquals(cmd.dist_dir, 'dist')
+        self.assertEqual(cmd.manifest, 'MANIFEST')
+        self.assertEqual(cmd.template, 'MANIFEST.in')
+        self.assertEqual(cmd.dist_dir, 'dist')
 
         # formats has to be a string splitable on (' ', ',') or
         # a stringlist
@@ -321,8 +323,8 @@
         archive = tarfile.open(archive_name)
         try:
             for member in archive.getmembers():
-                self.assertEquals(member.uid, 0)
-                self.assertEquals(member.gid, 0)
+                self.assertEqual(member.uid, 0)
+                self.assertEqual(member.gid, 0)
         finally:
             archive.close()
 
@@ -343,7 +345,7 @@
         # rights (see #7408)
         try:
             for member in archive.getmembers():
-                self.assertEquals(member.uid, os.getuid())
+                self.assertEqual(member.uid, os.getuid())
         finally:
             archive.close()
 
@@ -365,7 +367,7 @@
         finally:
             f.close()
 
-        self.assertEquals(len(manifest), 5)
+        self.assertEqual(len(manifest), 5)
 
         # adding a file
         self.write_file((self.tmp_dir, 'somecode', 'doc2.txt'), '#')
@@ -385,7 +387,7 @@
             f.close()
 
         # do we have the new file in MANIFEST ?
-        self.assertEquals(len(manifest2), 6)
+        self.assertEqual(len(manifest2), 6)
         self.assertIn('doc2.txt', manifest2[-1])
 
     def test_manifest_marker(self):
diff --git a/lib-python/2.7.0/distutils/tests/test_spawn.py b/lib-python/2.7/distutils/tests/test_spawn.py
rename from lib-python/2.7.0/distutils/tests/test_spawn.py
rename to lib-python/2.7/distutils/tests/test_spawn.py
--- a/lib-python/2.7.0/distutils/tests/test_spawn.py
+++ b/lib-python/2.7/distutils/tests/test_spawn.py
@@ -20,7 +20,7 @@
                                (['nochange', 'nospace'],
                                 ['nochange', 'nospace'])):
             res = _nt_quote_args(args)
-            self.assertEquals(res, wanted)
+            self.assertEqual(res, wanted)
 
 
     @unittest.skipUnless(os.name in ('nt', 'posix'),
diff --git a/lib-python/2.7.0/distutils/tests/test_sysconfig.py b/lib-python/2.7/distutils/tests/test_sysconfig.py
rename from lib-python/2.7.0/distutils/tests/test_sysconfig.py
rename to lib-python/2.7/distutils/tests/test_sysconfig.py
--- a/lib-python/2.7.0/distutils/tests/test_sysconfig.py
+++ b/lib-python/2.7/distutils/tests/test_sysconfig.py
@@ -36,7 +36,7 @@
                             sysconfig.get_python_lib(prefix=TESTFN))
         _sysconfig = __import__('sysconfig')
         res = sysconfig.get_python_lib(True, True)
-        self.assertEquals(_sysconfig.get_path('platstdlib'), res)
+        self.assertEqual(_sysconfig.get_path('platstdlib'), res)
 
     def test_get_python_inc(self):
         inc_dir = sysconfig.get_python_inc()
@@ -50,22 +50,26 @@
     def test_parse_makefile_base(self):
         self.makefile = test.test_support.TESTFN
         fd = open(self.makefile, 'w')
-        fd.write(r"CONFIG_ARGS=  '--arg1=optarg1' 'ENV=LIB'" '\n')
-        fd.write('VAR=$OTHER\nOTHER=foo')
-        fd.close()
+        try:
+            fd.write(r"CONFIG_ARGS=  '--arg1=optarg1' 'ENV=LIB'" '\n')
+            fd.write('VAR=$OTHER\nOTHER=foo')
+        finally:
+            fd.close()
         d = sysconfig.parse_makefile(self.makefile)
-        self.assertEquals(d, {'CONFIG_ARGS': "'--arg1=optarg1' 'ENV=LIB'",
-                              'OTHER': 'foo'})
+        self.assertEqual(d, {'CONFIG_ARGS': "'--arg1=optarg1' 'ENV=LIB'",
+                             'OTHER': 'foo'})
 
     def test_parse_makefile_literal_dollar(self):
         self.makefile = test.test_support.TESTFN
         fd = open(self.makefile, 'w')
-        fd.write(r"CONFIG_ARGS=  '--arg1=optarg1' 'ENV=\$$LIB'" '\n')
-        fd.write('VAR=$OTHER\nOTHER=foo')
-        fd.close()
+        try:
+            fd.write(r"CONFIG_ARGS=  '--arg1=optarg1' 'ENV=\$$LIB'" '\n')
+            fd.write('VAR=$OTHER\nOTHER=foo')
+        finally:
+            fd.close()
         d = sysconfig.parse_makefile(self.makefile)
-        self.assertEquals(d, {'CONFIG_ARGS': r"'--arg1=optarg1' 'ENV=\$LIB'",
-                              'OTHER': 'foo'})
+        self.assertEqual(d, {'CONFIG_ARGS': r"'--arg1=optarg1' 'ENV=\$LIB'",
+                             'OTHER': 'foo'})
 
 
 def test_suite():
diff --git a/lib-python/2.7.0/distutils/tests/test_text_file.py b/lib-python/2.7/distutils/tests/test_text_file.py
rename from lib-python/2.7.0/distutils/tests/test_text_file.py
rename to lib-python/2.7/distutils/tests/test_text_file.py
--- a/lib-python/2.7.0/distutils/tests/test_text_file.py
+++ b/lib-python/2.7/distutils/tests/test_text_file.py
@@ -48,7 +48,7 @@
 
         def test_input(count, description, file, expected_result):
             result = file.readlines()
-            self.assertEquals(result, expected_result)
+            self.assertEqual(result, expected_result)
 
         tmpdir = self.mkdtemp()
         filename = os.path.join(tmpdir, "test.txt")
@@ -58,28 +58,46 @@
         finally:
             out_file.close()
 
-        in_file = TextFile (filename, strip_comments=0, skip_blanks=0,
-                            lstrip_ws=0, rstrip_ws=0)
-        test_input (1, "no processing", in_file, result1)
+        in_file = TextFile(filename, strip_comments=0, skip_blanks=0,
+                           lstrip_ws=0, rstrip_ws=0)
+        try:
+            test_input(1, "no processing", in_file, result1)
+        finally:
+            in_file.close()
 
-        in_file = TextFile (filename, strip_comments=1, skip_blanks=0,
-                            lstrip_ws=0, rstrip_ws=0)
-        test_input (2, "strip comments", in_file, result2)
+        in_file = TextFile(filename, strip_comments=1, skip_blanks=0,
+                           lstrip_ws=0, rstrip_ws=0)
+        try:
+            test_input(2, "strip comments", in_file, result2)
+        finally:
+            in_file.close()
 
-        in_file = TextFile (filename, strip_comments=0, skip_blanks=1,
-                            lstrip_ws=0, rstrip_ws=0)
-        test_input (3, "strip blanks", in_file, result3)
+        in_file = TextFile(filename, strip_comments=0, skip_blanks=1,
+                           lstrip_ws=0, rstrip_ws=0)
+        try:
+            test_input(3, "strip blanks", in_file, result3)
+        finally:
+            in_file.close()
 
-        in_file = TextFile (filename)
-        test_input (4, "default processing", in_file, result4)
+        in_file = TextFile(filename)
+        try:
+            test_input(4, "default processing", in_file, result4)
+        finally:
+            in_file.close()
 
-        in_file = TextFile (filename, strip_comments=1, skip_blanks=1,
-                            join_lines=1, rstrip_ws=1)
-        test_input (5, "join lines without collapsing", in_file, result5)
+        in_file = TextFile(filename, strip_comments=1, skip_blanks=1,
+                           join_lines=1, rstrip_ws=1)
+        try:
+            test_input(5, "join lines without collapsing", in_file, result5)
+        finally:
+            in_file.close()
 
-        in_file = TextFile (filename, strip_comments=1, skip_blanks=1,
-                            join_lines=1, rstrip_ws=1, collapse_join=1)
-        test_input (6, "join lines with collapsing", in_file, result6)
+        in_file = TextFile(filename, strip_comments=1, skip_blanks=1,
+                           join_lines=1, rstrip_ws=1, collapse_join=1)
+        try:
+            test_input(6, "join lines with collapsing", in_file, result6)
+        finally:
+            in_file.close()
 
 def test_suite():
     return unittest.makeSuite(TextFileTestCase)
diff --git a/lib-python/2.7.0/distutils/tests/test_unixccompiler.py b/lib-python/2.7/distutils/tests/test_unixccompiler.py
rename from lib-python/2.7.0/distutils/tests/test_unixccompiler.py
rename to lib-python/2.7/distutils/tests/test_unixccompiler.py
diff --git a/lib-python/2.7.0/distutils/tests/test_upload.py b/lib-python/2.7/distutils/tests/test_upload.py
rename from lib-python/2.7.0/distutils/tests/test_upload.py
rename to lib-python/2.7/distutils/tests/test_upload.py
--- a/lib-python/2.7.0/distutils/tests/test_upload.py
+++ b/lib-python/2.7/distutils/tests/test_upload.py
@@ -80,7 +80,7 @@
         for attr, waited in (('username', 'me'), ('password', 'secret'),
                              ('realm', 'pypi'),
                              ('repository', 'http://pypi.python.org/pypi')):
-            self.assertEquals(getattr(cmd, attr), waited)
+            self.assertEqual(getattr(cmd, attr), waited)
 
     def test_saved_password(self):
         # file with no password
@@ -90,14 +90,14 @@
         dist = Distribution()
         cmd = upload(dist)
         cmd.finalize_options()
-        self.assertEquals(cmd.password, None)
+        self.assertEqual(cmd.password, None)
 
         # make sure we get it as well, if another command
         # initialized it at the dist level
         dist.password = 'xxx'
         cmd = upload(dist)
         cmd.finalize_options()
-        self.assertEquals(cmd.password, 'xxx')
+        self.assertEqual(cmd.password, 'xxx')
 
     def test_upload(self):
         tmp = self.mkdtemp()
@@ -116,11 +116,11 @@
         # what did we send ?
         self.assertIn('d&#233;d&#233;', self.last_open.req.data)
         headers = dict(self.last_open.req.headers)
-        self.assertEquals(headers['Content-length'], '2085')
+        self.assertEqual(headers['Content-length'], '2085')
         self.assertTrue(headers['Content-type'].startswith('multipart/form-data'))
-        self.assertEquals(self.last_open.req.get_method(), 'POST')
-        self.assertEquals(self.last_open.req.get_full_url(),
-                          'http://pypi.python.org/pypi')
+        self.assertEqual(self.last_open.req.get_method(), 'POST')
+        self.assertEqual(self.last_open.req.get_full_url(),
+                         'http://pypi.python.org/pypi')
         self.assertTrue('xxx' in self.last_open.req.data)
         auth = self.last_open.req.headers['Authorization']
         self.assertFalse('\n' in auth)
diff --git a/lib-python/2.7.0/distutils/tests/test_util.py b/lib-python/2.7/distutils/tests/test_util.py
rename from lib-python/2.7.0/distutils/tests/test_util.py
rename to lib-python/2.7/distutils/tests/test_util.py
diff --git a/lib-python/2.7.0/distutils/tests/test_version.py b/lib-python/2.7/distutils/tests/test_version.py
rename from lib-python/2.7.0/distutils/tests/test_version.py
rename to lib-python/2.7/distutils/tests/test_version.py
--- a/lib-python/2.7.0/distutils/tests/test_version.py
+++ b/lib-python/2.7/distutils/tests/test_version.py
@@ -7,12 +7,12 @@
 
     def test_prerelease(self):
         version = StrictVersion('1.2.3a1')
-        self.assertEquals(version.version, (1, 2, 3))
-        self.assertEquals(version.prerelease, ('a', 1))
-        self.assertEquals(str(version), '1.2.3a1')
+        self.assertEqual(version.version, (1, 2, 3))
+        self.assertEqual(version.prerelease, ('a', 1))
+        self.assertEqual(str(version), '1.2.3a1')
 
         version = StrictVersion('1.2.0')
-        self.assertEquals(str(version), '1.2')
+        self.assertEqual(str(version), '1.2')
 
     def test_cmp_strict(self):
         versions = (('1.5.1', '1.5.2b2', -1),
@@ -41,9 +41,9 @@
                     raise AssertionError(("cmp(%s, %s) "
                                           "shouldn't raise ValueError")
                                             % (v1, v2))
-            self.assertEquals(res, wanted,
-                              'cmp(%s, %s) should be %s, got %s' %
-                              (v1, v2, wanted, res))
+            self.assertEqual(res, wanted,
+                             'cmp(%s, %s) should be %s, got %s' %
+                             (v1, v2, wanted, res))
 
 
     def test_cmp(self):
@@ -59,9 +59,9 @@
 
         for v1, v2, wanted in versions:
             res = LooseVersion(v1).__cmp__(LooseVersion(v2))
-            self.assertEquals(res, wanted,
-                              'cmp(%s, %s) should be %s, got %s' %
-                              (v1, v2, wanted, res))
+            self.assertEqual(res, wanted,
+                             'cmp(%s, %s) should be %s, got %s' %
+                             (v1, v2, wanted, res))
 
 def test_suite():
     return unittest.makeSuite(VersionTestCase)
diff --git a/lib-python/2.7.0/distutils/tests/test_versionpredicate.py b/lib-python/2.7/distutils/tests/test_versionpredicate.py
rename from lib-python/2.7.0/distutils/tests/test_versionpredicate.py
rename to lib-python/2.7/distutils/tests/test_versionpredicate.py
diff --git a/lib-python/2.7.0/distutils/text_file.py b/lib-python/2.7/distutils/text_file.py
rename from lib-python/2.7.0/distutils/text_file.py
rename to lib-python/2.7/distutils/text_file.py
--- a/lib-python/2.7.0/distutils/text_file.py
+++ b/lib-python/2.7/distutils/text_file.py
@@ -4,7 +4,7 @@
 that (optionally) takes care of stripping comments, ignoring blank
 lines, and joining lines with backslashes."""
 
-__revision__ = "$Id: text_file.py 76956 2009-12-21 01:22:46Z tarek.ziade $"
+__revision__ = "$Id$"
 
 import sys
 
diff --git a/lib-python/2.7.0/distutils/unixccompiler.py b/lib-python/2.7/distutils/unixccompiler.py
rename from lib-python/2.7.0/distutils/unixccompiler.py
rename to lib-python/2.7/distutils/unixccompiler.py
--- a/lib-python/2.7.0/distutils/unixccompiler.py
+++ b/lib-python/2.7/distutils/unixccompiler.py
@@ -13,7 +13,7 @@
   * link shared library handled by 'cc -shared'
 """
 
-__revision__ = "$Id: unixccompiler.py 82272 2010-06-27 12:36:16Z ronald.oussoren $"
+__revision__ = "$Id$"
 
 import os, sys, re
 from types import StringType, NoneType
diff --git a/lib-python/2.7.0/distutils/util.py b/lib-python/2.7/distutils/util.py
rename from lib-python/2.7.0/distutils/util.py
rename to lib-python/2.7/distutils/util.py
--- a/lib-python/2.7.0/distutils/util.py
+++ b/lib-python/2.7/distutils/util.py
@@ -4,7 +4,7 @@
 one of the other *util.py modules.
 """
 
-__revision__ = "$Id: util.py 82791 2010-07-11 08:52:52Z ronald.oussoren $"
+__revision__ = "$Id$"
 
 import sys, os, string, re
 from distutils.errors import DistutilsPlatformError
@@ -116,13 +116,15 @@
                 # behaviour.
                 pass
             else:
-                m = re.search(
-                        r'<key>ProductUserVisibleVersion</key>\s*' +
-                        r'<string>(.*?)</string>', f.read())
-                f.close()
-                if m is not None:
-                    macrelease = '.'.join(m.group(1).split('.')[:2])
-                # else: fall back to the default behaviour
+                try:
+                    m = re.search(
+                            r'<key>ProductUserVisibleVersion</key>\s*' +
+                            r'<string>(.*?)</string>', f.read())
+                    if m is not None:
+                        macrelease = '.'.join(m.group(1).split('.')[:2])
+                    # else: fall back to the default behaviour
+                finally:
+                    f.close()
 
         if not macver:
             macver = macrelease
diff --git a/lib-python/2.7.0/distutils/version.py b/lib-python/2.7/distutils/version.py
rename from lib-python/2.7.0/distutils/version.py
rename to lib-python/2.7/distutils/version.py
--- a/lib-python/2.7.0/distutils/version.py
+++ b/lib-python/2.7/distutils/version.py
@@ -4,7 +4,7 @@
 # Implements multiple version numbering conventions for the
 # Python Module Distribution Utilities.
 #
-# $Id: version.py 70642 2009-03-28 00:48:48Z georg.brandl $
+# $Id$
 #
 
 """Provides classes to represent module version numbers (one class for
diff --git a/lib-python/2.7.0/distutils/versionpredicate.py b/lib-python/2.7/distutils/versionpredicate.py
rename from lib-python/2.7.0/distutils/versionpredicate.py
rename to lib-python/2.7/distutils/versionpredicate.py
diff --git a/lib-python/2.7.0/doctest.py b/lib-python/2.7/doctest.py
rename from lib-python/2.7.0/doctest.py
rename to lib-python/2.7/doctest.py
diff --git a/lib-python/2.7.0/dumbdbm.py b/lib-python/2.7/dumbdbm.py
rename from lib-python/2.7.0/dumbdbm.py
rename to lib-python/2.7/dumbdbm.py
diff --git a/lib-python/2.7.0/dummy_thread.py b/lib-python/2.7/dummy_thread.py
rename from lib-python/2.7.0/dummy_thread.py
rename to lib-python/2.7/dummy_thread.py
diff --git a/lib-python/2.7.0/dummy_threading.py b/lib-python/2.7/dummy_threading.py
rename from lib-python/2.7.0/dummy_threading.py
rename to lib-python/2.7/dummy_threading.py
diff --git a/lib-python/2.7.0/email/__init__.py b/lib-python/2.7/email/__init__.py
rename from lib-python/2.7.0/email/__init__.py
rename to lib-python/2.7/email/__init__.py
diff --git a/lib-python/2.7.0/email/_parseaddr.py b/lib-python/2.7/email/_parseaddr.py
rename from lib-python/2.7.0/email/_parseaddr.py
rename to lib-python/2.7/email/_parseaddr.py
diff --git a/lib-python/2.7.0/email/base64mime.py b/lib-python/2.7/email/base64mime.py
rename from lib-python/2.7.0/email/base64mime.py
rename to lib-python/2.7/email/base64mime.py
diff --git a/lib-python/2.7.0/email/charset.py b/lib-python/2.7/email/charset.py
rename from lib-python/2.7.0/email/charset.py
rename to lib-python/2.7/email/charset.py
diff --git a/lib-python/2.7.0/email/encoders.py b/lib-python/2.7/email/encoders.py
rename from lib-python/2.7.0/email/encoders.py
rename to lib-python/2.7/email/encoders.py
diff --git a/lib-python/2.7.0/email/errors.py b/lib-python/2.7/email/errors.py
rename from lib-python/2.7.0/email/errors.py
rename to lib-python/2.7/email/errors.py
diff --git a/lib-python/2.7.0/email/feedparser.py b/lib-python/2.7/email/feedparser.py
rename from lib-python/2.7.0/email/feedparser.py
rename to lib-python/2.7/email/feedparser.py
diff --git a/lib-python/2.7.0/email/generator.py b/lib-python/2.7/email/generator.py
rename from lib-python/2.7.0/email/generator.py
rename to lib-python/2.7/email/generator.py
diff --git a/lib-python/2.7.0/email/header.py b/lib-python/2.7/email/header.py
rename from lib-python/2.7.0/email/header.py
rename to lib-python/2.7/email/header.py
diff --git a/lib-python/2.7.0/email/iterators.py b/lib-python/2.7/email/iterators.py
rename from lib-python/2.7.0/email/iterators.py
rename to lib-python/2.7/email/iterators.py
diff --git a/lib-python/2.7.0/email/message.py b/lib-python/2.7/email/message.py
rename from lib-python/2.7.0/email/message.py
rename to lib-python/2.7/email/message.py
diff --git a/lib-python/2.7.0/email/mime/__init__.py b/lib-python/2.7/email/mime/__init__.py
rename from lib-python/2.7.0/email/mime/__init__.py
rename to lib-python/2.7/email/mime/__init__.py
diff --git a/lib-python/2.7.0/email/mime/application.py b/lib-python/2.7/email/mime/application.py
rename from lib-python/2.7.0/email/mime/application.py
rename to lib-python/2.7/email/mime/application.py
diff --git a/lib-python/2.7.0/email/mime/audio.py b/lib-python/2.7/email/mime/audio.py
rename from lib-python/2.7.0/email/mime/audio.py
rename to lib-python/2.7/email/mime/audio.py
diff --git a/lib-python/2.7.0/email/mime/base.py b/lib-python/2.7/email/mime/base.py
rename from lib-python/2.7.0/email/mime/base.py
rename to lib-python/2.7/email/mime/base.py
diff --git a/lib-python/2.7.0/email/mime/image.py b/lib-python/2.7/email/mime/image.py
rename from lib-python/2.7.0/email/mime/image.py
rename to lib-python/2.7/email/mime/image.py
diff --git a/lib-python/2.7.0/email/mime/message.py b/lib-python/2.7/email/mime/message.py
rename from lib-python/2.7.0/email/mime/message.py
rename to lib-python/2.7/email/mime/message.py
diff --git a/lib-python/2.7.0/email/mime/multipart.py b/lib-python/2.7/email/mime/multipart.py
rename from lib-python/2.7.0/email/mime/multipart.py
rename to lib-python/2.7/email/mime/multipart.py
diff --git a/lib-python/2.7.0/email/mime/nonmultipart.py b/lib-python/2.7/email/mime/nonmultipart.py
rename from lib-python/2.7.0/email/mime/nonmultipart.py
rename to lib-python/2.7/email/mime/nonmultipart.py
diff --git a/lib-python/2.7.0/email/mime/text.py b/lib-python/2.7/email/mime/text.py
rename from lib-python/2.7.0/email/mime/text.py
rename to lib-python/2.7/email/mime/text.py
diff --git a/lib-python/2.7.0/email/parser.py b/lib-python/2.7/email/parser.py
rename from lib-python/2.7.0/email/parser.py
rename to lib-python/2.7/email/parser.py
diff --git a/lib-python/2.7.0/email/quoprimime.py b/lib-python/2.7/email/quoprimime.py
rename from lib-python/2.7.0/email/quoprimime.py
rename to lib-python/2.7/email/quoprimime.py
diff --git a/lib-python/2.7.0/email/test/__init__.py b/lib-python/2.7/email/test/__init__.py
rename from lib-python/2.7.0/email/test/__init__.py
rename to lib-python/2.7/email/test/__init__.py
diff --git a/lib-python/2.7.0/email/test/data/PyBanner048.gif b/lib-python/2.7/email/test/data/PyBanner048.gif
rename from lib-python/2.7.0/email/test/data/PyBanner048.gif
rename to lib-python/2.7/email/test/data/PyBanner048.gif
diff --git a/lib-python/2.7.0/email/test/data/audiotest.au b/lib-python/2.7/email/test/data/audiotest.au
rename from lib-python/2.7.0/email/test/data/audiotest.au
rename to lib-python/2.7/email/test/data/audiotest.au
diff --git a/lib-python/2.7.0/email/test/data/msg_01.txt b/lib-python/2.7/email/test/data/msg_01.txt
rename from lib-python/2.7.0/email/test/data/msg_01.txt
rename to lib-python/2.7/email/test/data/msg_01.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_02.txt b/lib-python/2.7/email/test/data/msg_02.txt
rename from lib-python/2.7.0/email/test/data/msg_02.txt
rename to lib-python/2.7/email/test/data/msg_02.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_03.txt b/lib-python/2.7/email/test/data/msg_03.txt
rename from lib-python/2.7.0/email/test/data/msg_03.txt
rename to lib-python/2.7/email/test/data/msg_03.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_04.txt b/lib-python/2.7/email/test/data/msg_04.txt
rename from lib-python/2.7.0/email/test/data/msg_04.txt
rename to lib-python/2.7/email/test/data/msg_04.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_05.txt b/lib-python/2.7/email/test/data/msg_05.txt
rename from lib-python/2.7.0/email/test/data/msg_05.txt
rename to lib-python/2.7/email/test/data/msg_05.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_06.txt b/lib-python/2.7/email/test/data/msg_06.txt
rename from lib-python/2.7.0/email/test/data/msg_06.txt
rename to lib-python/2.7/email/test/data/msg_06.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_07.txt b/lib-python/2.7/email/test/data/msg_07.txt
rename from lib-python/2.7.0/email/test/data/msg_07.txt
rename to lib-python/2.7/email/test/data/msg_07.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_08.txt b/lib-python/2.7/email/test/data/msg_08.txt
rename from lib-python/2.7.0/email/test/data/msg_08.txt
rename to lib-python/2.7/email/test/data/msg_08.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_09.txt b/lib-python/2.7/email/test/data/msg_09.txt
rename from lib-python/2.7.0/email/test/data/msg_09.txt
rename to lib-python/2.7/email/test/data/msg_09.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_10.txt b/lib-python/2.7/email/test/data/msg_10.txt
rename from lib-python/2.7.0/email/test/data/msg_10.txt
rename to lib-python/2.7/email/test/data/msg_10.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_11.txt b/lib-python/2.7/email/test/data/msg_11.txt
rename from lib-python/2.7.0/email/test/data/msg_11.txt
rename to lib-python/2.7/email/test/data/msg_11.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_12.txt b/lib-python/2.7/email/test/data/msg_12.txt
rename from lib-python/2.7.0/email/test/data/msg_12.txt
rename to lib-python/2.7/email/test/data/msg_12.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_12a.txt b/lib-python/2.7/email/test/data/msg_12a.txt
rename from lib-python/2.7.0/email/test/data/msg_12a.txt
rename to lib-python/2.7/email/test/data/msg_12a.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_13.txt b/lib-python/2.7/email/test/data/msg_13.txt
rename from lib-python/2.7.0/email/test/data/msg_13.txt
rename to lib-python/2.7/email/test/data/msg_13.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_14.txt b/lib-python/2.7/email/test/data/msg_14.txt
rename from lib-python/2.7.0/email/test/data/msg_14.txt
rename to lib-python/2.7/email/test/data/msg_14.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_15.txt b/lib-python/2.7/email/test/data/msg_15.txt
rename from lib-python/2.7.0/email/test/data/msg_15.txt
rename to lib-python/2.7/email/test/data/msg_15.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_16.txt b/lib-python/2.7/email/test/data/msg_16.txt
rename from lib-python/2.7.0/email/test/data/msg_16.txt
rename to lib-python/2.7/email/test/data/msg_16.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_17.txt b/lib-python/2.7/email/test/data/msg_17.txt
rename from lib-python/2.7.0/email/test/data/msg_17.txt
rename to lib-python/2.7/email/test/data/msg_17.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_18.txt b/lib-python/2.7/email/test/data/msg_18.txt
rename from lib-python/2.7.0/email/test/data/msg_18.txt
rename to lib-python/2.7/email/test/data/msg_18.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_19.txt b/lib-python/2.7/email/test/data/msg_19.txt
rename from lib-python/2.7.0/email/test/data/msg_19.txt
rename to lib-python/2.7/email/test/data/msg_19.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_20.txt b/lib-python/2.7/email/test/data/msg_20.txt
rename from lib-python/2.7.0/email/test/data/msg_20.txt
rename to lib-python/2.7/email/test/data/msg_20.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_21.txt b/lib-python/2.7/email/test/data/msg_21.txt
rename from lib-python/2.7.0/email/test/data/msg_21.txt
rename to lib-python/2.7/email/test/data/msg_21.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_22.txt b/lib-python/2.7/email/test/data/msg_22.txt
rename from lib-python/2.7.0/email/test/data/msg_22.txt
rename to lib-python/2.7/email/test/data/msg_22.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_23.txt b/lib-python/2.7/email/test/data/msg_23.txt
rename from lib-python/2.7.0/email/test/data/msg_23.txt
rename to lib-python/2.7/email/test/data/msg_23.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_24.txt b/lib-python/2.7/email/test/data/msg_24.txt
rename from lib-python/2.7.0/email/test/data/msg_24.txt
rename to lib-python/2.7/email/test/data/msg_24.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_25.txt b/lib-python/2.7/email/test/data/msg_25.txt
rename from lib-python/2.7.0/email/test/data/msg_25.txt
rename to lib-python/2.7/email/test/data/msg_25.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_26.txt b/lib-python/2.7/email/test/data/msg_26.txt
rename from lib-python/2.7.0/email/test/data/msg_26.txt
rename to lib-python/2.7/email/test/data/msg_26.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_27.txt b/lib-python/2.7/email/test/data/msg_27.txt
rename from lib-python/2.7.0/email/test/data/msg_27.txt
rename to lib-python/2.7/email/test/data/msg_27.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_28.txt b/lib-python/2.7/email/test/data/msg_28.txt
rename from lib-python/2.7.0/email/test/data/msg_28.txt
rename to lib-python/2.7/email/test/data/msg_28.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_29.txt b/lib-python/2.7/email/test/data/msg_29.txt
rename from lib-python/2.7.0/email/test/data/msg_29.txt
rename to lib-python/2.7/email/test/data/msg_29.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_30.txt b/lib-python/2.7/email/test/data/msg_30.txt
rename from lib-python/2.7.0/email/test/data/msg_30.txt
rename to lib-python/2.7/email/test/data/msg_30.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_31.txt b/lib-python/2.7/email/test/data/msg_31.txt
rename from lib-python/2.7.0/email/test/data/msg_31.txt
rename to lib-python/2.7/email/test/data/msg_31.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_32.txt b/lib-python/2.7/email/test/data/msg_32.txt
rename from lib-python/2.7.0/email/test/data/msg_32.txt
rename to lib-python/2.7/email/test/data/msg_32.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_33.txt b/lib-python/2.7/email/test/data/msg_33.txt
rename from lib-python/2.7.0/email/test/data/msg_33.txt
rename to lib-python/2.7/email/test/data/msg_33.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_34.txt b/lib-python/2.7/email/test/data/msg_34.txt
rename from lib-python/2.7.0/email/test/data/msg_34.txt
rename to lib-python/2.7/email/test/data/msg_34.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_35.txt b/lib-python/2.7/email/test/data/msg_35.txt
rename from lib-python/2.7.0/email/test/data/msg_35.txt
rename to lib-python/2.7/email/test/data/msg_35.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_36.txt b/lib-python/2.7/email/test/data/msg_36.txt
rename from lib-python/2.7.0/email/test/data/msg_36.txt
rename to lib-python/2.7/email/test/data/msg_36.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_37.txt b/lib-python/2.7/email/test/data/msg_37.txt
rename from lib-python/2.7.0/email/test/data/msg_37.txt
rename to lib-python/2.7/email/test/data/msg_37.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_38.txt b/lib-python/2.7/email/test/data/msg_38.txt
rename from lib-python/2.7.0/email/test/data/msg_38.txt
rename to lib-python/2.7/email/test/data/msg_38.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_39.txt b/lib-python/2.7/email/test/data/msg_39.txt
rename from lib-python/2.7.0/email/test/data/msg_39.txt
rename to lib-python/2.7/email/test/data/msg_39.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_40.txt b/lib-python/2.7/email/test/data/msg_40.txt
rename from lib-python/2.7.0/email/test/data/msg_40.txt
rename to lib-python/2.7/email/test/data/msg_40.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_41.txt b/lib-python/2.7/email/test/data/msg_41.txt
rename from lib-python/2.7.0/email/test/data/msg_41.txt
rename to lib-python/2.7/email/test/data/msg_41.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_42.txt b/lib-python/2.7/email/test/data/msg_42.txt
rename from lib-python/2.7.0/email/test/data/msg_42.txt
rename to lib-python/2.7/email/test/data/msg_42.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_43.txt b/lib-python/2.7/email/test/data/msg_43.txt
rename from lib-python/2.7.0/email/test/data/msg_43.txt
rename to lib-python/2.7/email/test/data/msg_43.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_44.txt b/lib-python/2.7/email/test/data/msg_44.txt
rename from lib-python/2.7.0/email/test/data/msg_44.txt
rename to lib-python/2.7/email/test/data/msg_44.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_45.txt b/lib-python/2.7/email/test/data/msg_45.txt
rename from lib-python/2.7.0/email/test/data/msg_45.txt
rename to lib-python/2.7/email/test/data/msg_45.txt
diff --git a/lib-python/2.7.0/email/test/data/msg_46.txt b/lib-python/2.7/email/test/data/msg_46.txt
rename from lib-python/2.7.0/email/test/data/msg_46.txt
rename to lib-python/2.7/email/test/data/msg_46.txt
diff --git a/lib-python/2.7.0/email/test/test_email.py b/lib-python/2.7/email/test/test_email.py
rename from lib-python/2.7.0/email/test/test_email.py
rename to lib-python/2.7/email/test/test_email.py
--- a/lib-python/2.7.0/email/test/test_email.py
+++ b/lib-python/2.7/email/test/test_email.py
@@ -40,13 +40,13 @@
 SPACE = ' '
 
 
-
+
 def openfile(filename, mode='r'):
     path = os.path.join(os.path.dirname(landmark), 'data', filename)
     return open(path, mode)
 
 
-
+
 # Base test class
 class TestEmailBase(unittest.TestCase):
     def ndiffAssertEqual(self, first, second):
@@ -68,7 +68,7 @@
         return msg
 
 
-
+
 # Test various aspects of the Message class's API
 class TestMessageAPI(TestEmailBase):
     def test_get_all(self):
@@ -543,7 +543,7 @@
         self.assertEqual('us-ascii', msg.get_content_charset())
 
 
-
+
 # Test the email.Encoders module
 class TestEncoders(unittest.TestCase):
     def test_encode_empty_payload(self):
@@ -572,7 +572,7 @@
         msg = email.MIMEText.MIMEText('\xca\xb8', _charset='euc-jp')
         eq(msg['content-transfer-encoding'], '7bit')
 
-
+
 # Test long header wrapping
 class TestLongHeaders(TestEmailBase):
     def test_split_long_continuation(self):
@@ -893,7 +893,7 @@
 """)
 
 
-
+
 # Test mangling of "From " lines in the body of a message
 class TestFromMangling(unittest.TestCase):
     def setUp(self):
@@ -927,7 +927,7 @@
 """)
 
 
-
+
 # Test the basic MIMEAudio class
 class TestMIMEAudio(unittest.TestCase):
     def setUp(self):
@@ -976,7 +976,7 @@
                                   header='foobar') is missing)
 
 
-
+
 # Test the basic MIMEImage class
 class TestMIMEImage(unittest.TestCase):
     def setUp(self):
@@ -1019,7 +1019,7 @@
                                   header='foobar') is missing)
 
 
-
+
 # Test the basic MIMEText class
 class TestMIMEText(unittest.TestCase):
     def setUp(self):
@@ -1071,7 +1071,7 @@
         self.assertRaises(UnicodeEncodeError, MIMEText, teststr)
 
 
-
+
 # Test complicated multipart/* messages
 class TestMultipart(TestEmailBase):
     def setUp(self):
@@ -1447,10 +1447,10 @@
 
 YXNkZg==
 --===============0012394164==--""")
-        self.assertEquals(m.get_payload(0).get_payload(), 'YXNkZg==')
-
-
-
+        self.assertEqual(m.get_payload(0).get_payload(), 'YXNkZg==')
+
+
+
 # Test some badly formatted messages
 class TestNonConformant(TestEmailBase):
     def test_parse_missing_minor_type(self):
@@ -1565,7 +1565,7 @@
 
 
 
-
+
 # Test RFC 2047 header encoding and decoding
 class TestRFC2047(unittest.TestCase):
     def test_rfc2047_multiline(self):
@@ -1627,7 +1627,7 @@
         self.assertEqual(decode_header(s),
                         [(b'andr\xe9=zz', 'iso-8659-1')])
 
-
+
 # Test the MIMEMessage class
 class TestMIMEMessage(TestEmailBase):
     def setUp(self):
@@ -1940,7 +1940,7 @@
         msg = MIMEMultipart()
         self.assertTrue(msg.is_multipart())
 
-
+
 # A general test of parser->model->generator idempotency.  IOW, read a message
 # in, parse it into a message object tree, then without touching the tree,
 # regenerate the plain text.  The original text and the transformed text
@@ -1964,7 +1964,7 @@
         eq(text, s.getvalue())
 
     def test_parse_text_message(self):
-        eq = self.assertEquals
+        eq = self.assertEqual
         msg, text = self._msgobj('msg_01.txt')
         eq(msg.get_content_type(), 'text/plain')
         eq(msg.get_content_maintype(), 'text')
@@ -1976,7 +1976,7 @@
         self._idempotent(msg, text)
 
     def test_parse_untyped_message(self):
-        eq = self.assertEquals
+        eq = self.assertEqual
         msg, text = self._msgobj('msg_03.txt')
         eq(msg.get_content_type(), 'text/plain')
         eq(msg.get_params(), None)
@@ -2048,7 +2048,7 @@
         self._idempotent(msg, text)
 
     def test_content_type(self):
-        eq = self.assertEquals
+        eq = self.assertEqual
         unless = self.assertTrue
         # Get a message object and reset the seek pointer for other tests
         msg, text = self._msgobj('msg_05.txt')
@@ -2080,7 +2080,7 @@
         eq(msg4.get_payload(), 'Yadda yadda yadda\n')
 
     def test_parser(self):
-        eq = self.assertEquals
+        eq = self.assertEqual
         unless = self.assertTrue
         msg, text = self._msgobj('msg_06.txt')
         # Check some of the outer headers
@@ -2097,7 +2097,7 @@
         eq(msg1.get_payload(), '\n')
 
 
-
+
 # Test various other bits of the package's functionality
 class TestMiscellaneous(TestEmailBase):
     def test_message_from_string(self):
@@ -2452,7 +2452,7 @@
 """)
 
 
-
+
 # Test the iterator/generators
 class TestIterators(TestEmailBase):
     def test_body_line_iterator(self):
@@ -2545,7 +2545,7 @@
         self.assertTrue(''.join([il for il, n in imt]) == ''.join(om))
 
 
-
+
 class TestParsers(TestEmailBase):
     def test_header_parser(self):
         eq = self.assertEqual
@@ -2708,7 +2708,7 @@
         msg = email.message_from_string(m)
         self.assertTrue(msg.get_payload(0).get_payload().endswith('\r\n'))
 
-
+
 class TestBase64(unittest.TestCase):
     def test_len(self):
         eq = self.assertEqual
@@ -2780,7 +2780,7 @@
  =?iso-8859-1?b?eHh4eCB4eHh4IHh4eHgg?=""")
 
 
-
+
 class TestQuopri(unittest.TestCase):
     def setUp(self):
         self.hlit = [chr(x) for x in range(ord('a'), ord('z')+1)] + \
@@ -2890,7 +2890,7 @@
 two line""")
 
 
-
+
 # Test the Charset class
 class TestCharset(unittest.TestCase):
     def tearDown(self):
@@ -2951,7 +2951,7 @@
         charset = Charset('utf8')
         self.assertEqual(str(charset), 'utf-8')
 
-
+
 # Test multilingual MIME headers.
 class TestHeader(TestEmailBase):
     def test_simple(self):
@@ -3114,7 +3114,7 @@
         raises(Errors.HeaderParseError, decode_header, s)
 
 
-
+
 # Test RFC 2231 header parameters (en/de)coding
 class TestRFC2231(TestEmailBase):
     def test_get_param(self):
@@ -3426,7 +3426,7 @@
         eq(s, 'My Document For You')
 
 
-
+
 # Tests to ensure that signed parts of an email are completely preserved, as
 # required by RFC1847 section 2.1.  Note that these are incomplete, because the
 # email package does not currently always preserve the body.  See issue 1670765.
@@ -3462,7 +3462,7 @@
         self._signed_parts_eq(original, result)
 
 
-
+
 def _testclasses():
     mod = sys.modules[__name__]
     return [getattr(mod, name) for name in dir(mod) if name.startswith('Test')]
@@ -3480,6 +3480,6 @@
         run_unittest(testclass)
 
 
-
+
 if __name__ == '__main__':
     unittest.main(defaultTest='suite')
diff --git a/lib-python/2.7.0/email/test/test_email_codecs.py b/lib-python/2.7/email/test/test_email_codecs.py
rename from lib-python/2.7.0/email/test/test_email_codecs.py
rename to lib-python/2.7/email/test/test_email_codecs.py
diff --git a/lib-python/2.7.0/email/test/test_email_codecs_renamed.py b/lib-python/2.7/email/test/test_email_codecs_renamed.py
rename from lib-python/2.7.0/email/test/test_email_codecs_renamed.py
rename to lib-python/2.7/email/test/test_email_codecs_renamed.py
diff --git a/lib-python/2.7.0/email/test/test_email_renamed.py b/lib-python/2.7/email/test/test_email_renamed.py
rename from lib-python/2.7.0/email/test/test_email_renamed.py
rename to lib-python/2.7/email/test/test_email_renamed.py
--- a/lib-python/2.7.0/email/test/test_email_renamed.py
+++ b/lib-python/2.7/email/test/test_email_renamed.py
@@ -41,13 +41,13 @@
 SPACE = ' '
 
 
-
+
 def openfile(filename, mode='r'):
     path = os.path.join(os.path.dirname(landmark), 'data', filename)
     return open(path, mode)
 
 
-
+
 # Base test class
 class TestEmailBase(unittest.TestCase):
     def ndiffAssertEqual(self, first, second):
@@ -69,7 +69,7 @@
         return msg
 
 
-
+
 # Test various aspects of the Message class's API
 class TestMessageAPI(TestEmailBase):
     def test_get_all(self):
@@ -504,7 +504,7 @@
         self.assertEqual(msg.get_payload(decode=True), x)
 
 
-
+
 # Test the email.encoders module
 class TestEncoders(unittest.TestCase):
     def test_encode_empty_payload(self):
@@ -531,7 +531,7 @@
         eq(msg['content-transfer-encoding'], 'quoted-printable')
 
 
-
+
 # Test long header wrapping
 class TestLongHeaders(TestEmailBase):
     def test_split_long_continuation(self):
@@ -852,7 +852,7 @@
 """)
 
 
-
+
 # Test mangling of "From " lines in the body of a message
 class TestFromMangling(unittest.TestCase):
     def setUp(self):
@@ -886,7 +886,7 @@
 """)
 
 
-
+
 # Test the basic MIMEAudio class
 class TestMIMEAudio(unittest.TestCase):
     def setUp(self):
@@ -935,7 +935,7 @@
                                   header='foobar') is missing)
 
 
-
+
 # Test the basic MIMEImage class
 class TestMIMEImage(unittest.TestCase):
     def setUp(self):
@@ -978,7 +978,7 @@
                                   header='foobar') is missing)
 
 
-
+
 # Test the basic MIMEApplication class
 class TestMIMEApplication(unittest.TestCase):
     def test_headers(self):
@@ -995,7 +995,7 @@
         eq(msg.get_payload(decode=True), bytes)
 
 
-
+
 # Test the basic MIMEText class
 class TestMIMEText(unittest.TestCase):
     def setUp(self):
@@ -1022,7 +1022,7 @@
         eq(msg['content-type'], 'text/plain; charset="us-ascii"')
 
 
-
+
 # Test complicated multipart/* messages
 class TestMultipart(TestEmailBase):
     def setUp(self):
@@ -1398,10 +1398,10 @@
 
 YXNkZg==
 --===============0012394164==--""")
-        self.assertEquals(m.get_payload(0).get_payload(), 'YXNkZg==')
-
-
-
+        self.assertEqual(m.get_payload(0).get_payload(), 'YXNkZg==')
+
+
+
 # Test some badly formatted messages
 class TestNonConformant(TestEmailBase):
     def test_parse_missing_minor_type(self):
@@ -1515,7 +1515,7 @@
         eq(msg.defects[0].line, ' Line 1\n')
 
 
-
+
 # Test RFC 2047 header encoding and decoding
 class TestRFC2047(unittest.TestCase):
     def test_rfc2047_multiline(self):
@@ -1562,7 +1562,7 @@
                               ('sbord', None)])
 
 
-
+
 # Test the MIMEMessage class
 class TestMIMEMessage(TestEmailBase):
     def setUp(self):
@@ -1872,7 +1872,7 @@
         eq(msg.get_payload(1), text2)
 
 
-
+
 # A general test of parser->model->generator idempotency.  IOW, read a message
 # in, parse it into a message object tree, then without touching the tree,
 # regenerate the plain text.  The original text and the transformed text
@@ -1896,7 +1896,7 @@
         eq(text, s.getvalue())
 
     def test_parse_text_message(self):
-        eq = self.assertEquals
+        eq = self.assertEqual
         msg, text = self._msgobj('msg_01.txt')
         eq(msg.get_content_type(), 'text/plain')
         eq(msg.get_content_maintype(), 'text')
@@ -1908,7 +1908,7 @@
         self._idempotent(msg, text)
 
     def test_parse_untyped_message(self):
-        eq = self.assertEquals
+        eq = self.assertEqual
         msg, text = self._msgobj('msg_03.txt')
         eq(msg.get_content_type(), 'text/plain')
         eq(msg.get_params(), None)
@@ -1980,7 +1980,7 @@
         self._idempotent(msg, text)
 
     def test_content_type(self):
-        eq = self.assertEquals
+        eq = self.assertEqual
         unless = self.assertTrue
         # Get a message object and reset the seek pointer for other tests
         msg, text = self._msgobj('msg_05.txt')
@@ -2012,7 +2012,7 @@
         eq(msg4.get_payload(), 'Yadda yadda yadda\n')
 
     def test_parser(self):
-        eq = self.assertEquals
+        eq = self.assertEqual
         unless = self.assertTrue
         msg, text = self._msgobj('msg_06.txt')
         # Check some of the outer headers
@@ -2029,7 +2029,7 @@
         eq(msg1.get_payload(), '\n')
 
 
-
+
 # Test various other bits of the package's functionality
 class TestMiscellaneous(TestEmailBase):
     def test_message_from_string(self):
@@ -2354,7 +2354,7 @@
 """)
 
 
-
+
 # Test the iterator/generators
 class TestIterators(TestEmailBase):
     def test_body_line_iterator(self):
@@ -2414,7 +2414,7 @@
 """)
 
 
-
+
 class TestParsers(TestEmailBase):
     def test_header_parser(self):
         eq = self.assertEqual
@@ -2559,7 +2559,7 @@
         eq(msg.get_payload(), 'body')
 
 
-
+
 class TestBase64(unittest.TestCase):
     def test_len(self):
         eq = self.assertEqual
@@ -2631,7 +2631,7 @@
  =?iso-8859-1?b?eHh4eCB4eHh4IHh4eHgg?=""")
 
 
-
+
 class TestQuopri(unittest.TestCase):
     def setUp(self):
         self.hlit = [chr(x) for x in range(ord('a'), ord('z')+1)] + \
@@ -2741,7 +2741,7 @@
 two line""")
 
 
-
+
 # Test the Charset class
 class TestCharset(unittest.TestCase):
     def tearDown(self):
@@ -2799,7 +2799,7 @@
         self.assertRaises(errors.CharsetError, Charset, 'asc\xffii')
 
 
-
+
 # Test multilingual MIME headers.
 class TestHeader(TestEmailBase):
     def test_simple(self):
@@ -2962,7 +2962,7 @@
         raises(errors.HeaderParseError, decode_header, s)
 
 
-
+
 # Test RFC 2231 header parameters (en/de)coding
 class TestRFC2231(TestEmailBase):
     def test_get_param(self):
@@ -3274,7 +3274,7 @@
         eq(s, 'My Document For You')
 
 
-
+
 def _testclasses():
     mod = sys.modules[__name__]
     return [getattr(mod, name) for name in dir(mod) if name.startswith('Test')]
@@ -3292,6 +3292,6 @@
         run_unittest(testclass)
 
 
-
+
 if __name__ == '__main__':
     unittest.main(defaultTest='suite')
diff --git a/lib-python/2.7.0/email/test/test_email_torture.py b/lib-python/2.7/email/test/test_email_torture.py
rename from lib-python/2.7.0/email/test/test_email_torture.py
rename to lib-python/2.7/email/test/test_email_torture.py
diff --git a/lib-python/2.7.0/email/utils.py b/lib-python/2.7/email/utils.py
rename from lib-python/2.7.0/email/utils.py
rename to lib-python/2.7/email/utils.py
diff --git a/lib-python/2.7.0/encodings/__init__.py b/lib-python/2.7/encodings/__init__.py
rename from lib-python/2.7.0/encodings/__init__.py
rename to lib-python/2.7/encodings/__init__.py
diff --git a/lib-python/2.7.0/encodings/aliases.py b/lib-python/2.7/encodings/aliases.py
rename from lib-python/2.7.0/encodings/aliases.py
rename to lib-python/2.7/encodings/aliases.py
diff --git a/lib-python/2.7.0/encodings/ascii.py b/lib-python/2.7/encodings/ascii.py
rename from lib-python/2.7.0/encodings/ascii.py
rename to lib-python/2.7/encodings/ascii.py
diff --git a/lib-python/2.7.0/encodings/base64_codec.py b/lib-python/2.7/encodings/base64_codec.py
rename from lib-python/2.7.0/encodings/base64_codec.py
rename to lib-python/2.7/encodings/base64_codec.py
diff --git a/lib-python/2.7.0/encodings/big5.py b/lib-python/2.7/encodings/big5.py
rename from lib-python/2.7.0/encodings/big5.py
rename to lib-python/2.7/encodings/big5.py
diff --git a/lib-python/2.7.0/encodings/big5hkscs.py b/lib-python/2.7/encodings/big5hkscs.py
rename from lib-python/2.7.0/encodings/big5hkscs.py
rename to lib-python/2.7/encodings/big5hkscs.py
diff --git a/lib-python/2.7.0/encodings/bz2_codec.py b/lib-python/2.7/encodings/bz2_codec.py
rename from lib-python/2.7.0/encodings/bz2_codec.py
rename to lib-python/2.7/encodings/bz2_codec.py
diff --git a/lib-python/2.7.0/encodings/charmap.py b/lib-python/2.7/encodings/charmap.py
rename from lib-python/2.7.0/encodings/charmap.py
rename to lib-python/2.7/encodings/charmap.py
diff --git a/lib-python/2.7.0/encodings/cp037.py b/lib-python/2.7/encodings/cp037.py
rename from lib-python/2.7.0/encodings/cp037.py
rename to lib-python/2.7/encodings/cp037.py
diff --git a/lib-python/2.7.0/encodings/cp1006.py b/lib-python/2.7/encodings/cp1006.py
rename from lib-python/2.7.0/encodings/cp1006.py
rename to lib-python/2.7/encodings/cp1006.py
diff --git a/lib-python/2.7.0/encodings/cp1026.py b/lib-python/2.7/encodings/cp1026.py
rename from lib-python/2.7.0/encodings/cp1026.py
rename to lib-python/2.7/encodings/cp1026.py
diff --git a/lib-python/2.7.0/encodings/cp1140.py b/lib-python/2.7/encodings/cp1140.py
rename from lib-python/2.7.0/encodings/cp1140.py
rename to lib-python/2.7/encodings/cp1140.py
diff --git a/lib-python/2.7.0/encodings/cp1250.py b/lib-python/2.7/encodings/cp1250.py
rename from lib-python/2.7.0/encodings/cp1250.py
rename to lib-python/2.7/encodings/cp1250.py
diff --git a/lib-python/2.7.0/encodings/cp1251.py b/lib-python/2.7/encodings/cp1251.py
rename from lib-python/2.7.0/encodings/cp1251.py
rename to lib-python/2.7/encodings/cp1251.py
diff --git a/lib-python/2.7.0/encodings/cp1252.py b/lib-python/2.7/encodings/cp1252.py
rename from lib-python/2.7.0/encodings/cp1252.py
rename to lib-python/2.7/encodings/cp1252.py
diff --git a/lib-python/2.7.0/encodings/cp1253.py b/lib-python/2.7/encodings/cp1253.py
rename from lib-python/2.7.0/encodings/cp1253.py
rename to lib-python/2.7/encodings/cp1253.py
diff --git a/lib-python/2.7.0/encodings/cp1254.py b/lib-python/2.7/encodings/cp1254.py
rename from lib-python/2.7.0/encodings/cp1254.py
rename to lib-python/2.7/encodings/cp1254.py
diff --git a/lib-python/2.7.0/encodings/cp1255.py b/lib-python/2.7/encodings/cp1255.py
rename from lib-python/2.7.0/encodings/cp1255.py
rename to lib-python/2.7/encodings/cp1255.py
diff --git a/lib-python/2.7.0/encodings/cp1256.py b/lib-python/2.7/encodings/cp1256.py
rename from lib-python/2.7.0/encodings/cp1256.py
rename to lib-python/2.7/encodings/cp1256.py
diff --git a/lib-python/2.7.0/encodings/cp1257.py b/lib-python/2.7/encodings/cp1257.py
rename from lib-python/2.7.0/encodings/cp1257.py
rename to lib-python/2.7/encodings/cp1257.py
diff --git a/lib-python/2.7.0/encodings/cp1258.py b/lib-python/2.7/encodings/cp1258.py
rename from lib-python/2.7.0/encodings/cp1258.py
rename to lib-python/2.7/encodings/cp1258.py
diff --git a/lib-python/2.7.0/encodings/cp424.py b/lib-python/2.7/encodings/cp424.py
rename from lib-python/2.7.0/encodings/cp424.py
rename to lib-python/2.7/encodings/cp424.py
diff --git a/lib-python/2.7.0/encodings/cp437.py b/lib-python/2.7/encodings/cp437.py
rename from lib-python/2.7.0/encodings/cp437.py
rename to lib-python/2.7/encodings/cp437.py
diff --git a/lib-python/2.7.0/encodings/cp500.py b/lib-python/2.7/encodings/cp500.py
rename from lib-python/2.7.0/encodings/cp500.py
rename to lib-python/2.7/encodings/cp500.py
diff --git a/lib-python/2.7.0/encodings/cp720.py b/lib-python/2.7/encodings/cp720.py
rename from lib-python/2.7.0/encodings/cp720.py
rename to lib-python/2.7/encodings/cp720.py
diff --git a/lib-python/2.7.0/encodings/cp737.py b/lib-python/2.7/encodings/cp737.py
rename from lib-python/2.7.0/encodings/cp737.py
rename to lib-python/2.7/encodings/cp737.py
diff --git a/lib-python/2.7.0/encodings/cp775.py b/lib-python/2.7/encodings/cp775.py
rename from lib-python/2.7.0/encodings/cp775.py
rename to lib-python/2.7/encodings/cp775.py
diff --git a/lib-python/2.7.0/encodings/cp850.py b/lib-python/2.7/encodings/cp850.py
rename from lib-python/2.7.0/encodings/cp850.py
rename to lib-python/2.7/encodings/cp850.py
diff --git a/lib-python/2.7.0/encodings/cp852.py b/lib-python/2.7/encodings/cp852.py
rename from lib-python/2.7.0/encodings/cp852.py
rename to lib-python/2.7/encodings/cp852.py
diff --git a/lib-python/2.7.0/encodings/cp855.py b/lib-python/2.7/encodings/cp855.py
rename from lib-python/2.7.0/encodings/cp855.py
rename to lib-python/2.7/encodings/cp855.py
diff --git a/lib-python/2.7.0/encodings/cp856.py b/lib-python/2.7/encodings/cp856.py
rename from lib-python/2.7.0/encodings/cp856.py
rename to lib-python/2.7/encodings/cp856.py
diff --git a/lib-python/2.7.0/encodings/cp857.py b/lib-python/2.7/encodings/cp857.py
rename from lib-python/2.7.0/encodings/cp857.py
rename to lib-python/2.7/encodings/cp857.py
diff --git a/lib-python/2.7.0/encodings/cp858.py b/lib-python/2.7/encodings/cp858.py
rename from lib-python/2.7.0/encodings/cp858.py
rename to lib-python/2.7/encodings/cp858.py
diff --git a/lib-python/2.7.0/encodings/cp860.py b/lib-python/2.7/encodings/cp860.py
rename from lib-python/2.7.0/encodings/cp860.py
rename to lib-python/2.7/encodings/cp860.py
diff --git a/lib-python/2.7.0/encodings/cp861.py b/lib-python/2.7/encodings/cp861.py
rename from lib-python/2.7.0/encodings/cp861.py
rename to lib-python/2.7/encodings/cp861.py
diff --git a/lib-python/2.7.0/encodings/cp862.py b/lib-python/2.7/encodings/cp862.py
rename from lib-python/2.7.0/encodings/cp862.py
rename to lib-python/2.7/encodings/cp862.py
diff --git a/lib-python/2.7.0/encodings/cp863.py b/lib-python/2.7/encodings/cp863.py
rename from lib-python/2.7.0/encodings/cp863.py
rename to lib-python/2.7/encodings/cp863.py
diff --git a/lib-python/2.7.0/encodings/cp864.py b/lib-python/2.7/encodings/cp864.py
rename from lib-python/2.7.0/encodings/cp864.py
rename to lib-python/2.7/encodings/cp864.py
diff --git a/lib-python/2.7.0/encodings/cp865.py b/lib-python/2.7/encodings/cp865.py
rename from lib-python/2.7.0/encodings/cp865.py
rename to lib-python/2.7/encodings/cp865.py
diff --git a/lib-python/2.7.0/encodings/cp866.py b/lib-python/2.7/encodings/cp866.py
rename from lib-python/2.7.0/encodings/cp866.py
rename to lib-python/2.7/encodings/cp866.py
diff --git a/lib-python/2.7.0/encodings/cp869.py b/lib-python/2.7/encodings/cp869.py
rename from lib-python/2.7.0/encodings/cp869.py
rename to lib-python/2.7/encodings/cp869.py
diff --git a/lib-python/2.7.0/encodings/cp874.py b/lib-python/2.7/encodings/cp874.py
rename from lib-python/2.7.0/encodings/cp874.py
rename to lib-python/2.7/encodings/cp874.py
diff --git a/lib-python/2.7.0/encodings/cp875.py b/lib-python/2.7/encodings/cp875.py
rename from lib-python/2.7.0/encodings/cp875.py
rename to lib-python/2.7/encodings/cp875.py
diff --git a/lib-python/2.7.0/encodings/cp932.py b/lib-python/2.7/encodings/cp932.py
rename from lib-python/2.7.0/encodings/cp932.py
rename to lib-python/2.7/encodings/cp932.py
diff --git a/lib-python/2.7.0/encodings/cp949.py b/lib-python/2.7/encodings/cp949.py
rename from lib-python/2.7.0/encodings/cp949.py
rename to lib-python/2.7/encodings/cp949.py
diff --git a/lib-python/2.7.0/encodings/cp950.py b/lib-python/2.7/encodings/cp950.py
rename from lib-python/2.7.0/encodings/cp950.py
rename to lib-python/2.7/encodings/cp950.py
diff --git a/lib-python/2.7.0/encodings/euc_jis_2004.py b/lib-python/2.7/encodings/euc_jis_2004.py
rename from lib-python/2.7.0/encodings/euc_jis_2004.py
rename to lib-python/2.7/encodings/euc_jis_2004.py
diff --git a/lib-python/2.7.0/encodings/euc_jisx0213.py b/lib-python/2.7/encodings/euc_jisx0213.py
rename from lib-python/2.7.0/encodings/euc_jisx0213.py
rename to lib-python/2.7/encodings/euc_jisx0213.py
diff --git a/lib-python/2.7.0/encodings/euc_jp.py b/lib-python/2.7/encodings/euc_jp.py
rename from lib-python/2.7.0/encodings/euc_jp.py
rename to lib-python/2.7/encodings/euc_jp.py
diff --git a/lib-python/2.7.0/encodings/euc_kr.py b/lib-python/2.7/encodings/euc_kr.py
rename from lib-python/2.7.0/encodings/euc_kr.py
rename to lib-python/2.7/encodings/euc_kr.py
diff --git a/lib-python/2.7.0/encodings/gb18030.py b/lib-python/2.7/encodings/gb18030.py
rename from lib-python/2.7.0/encodings/gb18030.py
rename to lib-python/2.7/encodings/gb18030.py
diff --git a/lib-python/2.7.0/encodings/gb2312.py b/lib-python/2.7/encodings/gb2312.py
rename from lib-python/2.7.0/encodings/gb2312.py
rename to lib-python/2.7/encodings/gb2312.py
diff --git a/lib-python/2.7.0/encodings/gbk.py b/lib-python/2.7/encodings/gbk.py
rename from lib-python/2.7.0/encodings/gbk.py
rename to lib-python/2.7/encodings/gbk.py
diff --git a/lib-python/2.7.0/encodings/hex_codec.py b/lib-python/2.7/encodings/hex_codec.py
rename from lib-python/2.7.0/encodings/hex_codec.py
rename to lib-python/2.7/encodings/hex_codec.py
diff --git a/lib-python/2.7.0/encodings/hp_roman8.py b/lib-python/2.7/encodings/hp_roman8.py
rename from lib-python/2.7.0/encodings/hp_roman8.py
rename to lib-python/2.7/encodings/hp_roman8.py
diff --git a/lib-python/2.7.0/encodings/hz.py b/lib-python/2.7/encodings/hz.py
rename from lib-python/2.7.0/encodings/hz.py
rename to lib-python/2.7/encodings/hz.py
diff --git a/lib-python/2.7.0/encodings/idna.py b/lib-python/2.7/encodings/idna.py
rename from lib-python/2.7.0/encodings/idna.py
rename to lib-python/2.7/encodings/idna.py
diff --git a/lib-python/2.7.0/encodings/iso2022_jp.py b/lib-python/2.7/encodings/iso2022_jp.py
rename from lib-python/2.7.0/encodings/iso2022_jp.py
rename to lib-python/2.7/encodings/iso2022_jp.py
diff --git a/lib-python/2.7.0/encodings/iso2022_jp_1.py b/lib-python/2.7/encodings/iso2022_jp_1.py
rename from lib-python/2.7.0/encodings/iso2022_jp_1.py
rename to lib-python/2.7/encodings/iso2022_jp_1.py
diff --git a/lib-python/2.7.0/encodings/iso2022_jp_2.py b/lib-python/2.7/encodings/iso2022_jp_2.py
rename from lib-python/2.7.0/encodings/iso2022_jp_2.py
rename to lib-python/2.7/encodings/iso2022_jp_2.py
diff --git a/lib-python/2.7.0/encodings/iso2022_jp_2004.py b/lib-python/2.7/encodings/iso2022_jp_2004.py
rename from lib-python/2.7.0/encodings/iso2022_jp_2004.py
rename to lib-python/2.7/encodings/iso2022_jp_2004.py
diff --git a/lib-python/2.7.0/encodings/iso2022_jp_3.py b/lib-python/2.7/encodings/iso2022_jp_3.py
rename from lib-python/2.7.0/encodings/iso2022_jp_3.py
rename to lib-python/2.7/encodings/iso2022_jp_3.py
diff --git a/lib-python/2.7.0/encodings/iso2022_jp_ext.py b/lib-python/2.7/encodings/iso2022_jp_ext.py
rename from lib-python/2.7.0/encodings/iso2022_jp_ext.py
rename to lib-python/2.7/encodings/iso2022_jp_ext.py
diff --git a/lib-python/2.7.0/encodings/iso2022_kr.py b/lib-python/2.7/encodings/iso2022_kr.py
rename from lib-python/2.7.0/encodings/iso2022_kr.py
rename to lib-python/2.7/encodings/iso2022_kr.py
diff --git a/lib-python/2.7.0/encodings/iso8859_1.py b/lib-python/2.7/encodings/iso8859_1.py
rename from lib-python/2.7.0/encodings/iso8859_1.py
rename to lib-python/2.7/encodings/iso8859_1.py
diff --git a/lib-python/2.7.0/encodings/iso8859_10.py b/lib-python/2.7/encodings/iso8859_10.py
rename from lib-python/2.7.0/encodings/iso8859_10.py
rename to lib-python/2.7/encodings/iso8859_10.py
diff --git a/lib-python/2.7.0/encodings/iso8859_11.py b/lib-python/2.7/encodings/iso8859_11.py
rename from lib-python/2.7.0/encodings/iso8859_11.py
rename to lib-python/2.7/encodings/iso8859_11.py
diff --git a/lib-python/2.7.0/encodings/iso8859_13.py b/lib-python/2.7/encodings/iso8859_13.py
rename from lib-python/2.7.0/encodings/iso8859_13.py
rename to lib-python/2.7/encodings/iso8859_13.py
diff --git a/lib-python/2.7.0/encodings/iso8859_14.py b/lib-python/2.7/encodings/iso8859_14.py
rename from lib-python/2.7.0/encodings/iso8859_14.py
rename to lib-python/2.7/encodings/iso8859_14.py
diff --git a/lib-python/2.7.0/encodings/iso8859_15.py b/lib-python/2.7/encodings/iso8859_15.py
rename from lib-python/2.7.0/encodings/iso8859_15.py
rename to lib-python/2.7/encodings/iso8859_15.py
diff --git a/lib-python/2.7.0/encodings/iso8859_16.py b/lib-python/2.7/encodings/iso8859_16.py
rename from lib-python/2.7.0/encodings/iso8859_16.py
rename to lib-python/2.7/encodings/iso8859_16.py
diff --git a/lib-python/2.7.0/encodings/iso8859_2.py b/lib-python/2.7/encodings/iso8859_2.py
rename from lib-python/2.7.0/encodings/iso8859_2.py
rename to lib-python/2.7/encodings/iso8859_2.py
diff --git a/lib-python/2.7.0/encodings/iso8859_3.py b/lib-python/2.7/encodings/iso8859_3.py
rename from lib-python/2.7.0/encodings/iso8859_3.py
rename to lib-python/2.7/encodings/iso8859_3.py
diff --git a/lib-python/2.7.0/encodings/iso8859_4.py b/lib-python/2.7/encodings/iso8859_4.py
rename from lib-python/2.7.0/encodings/iso8859_4.py
rename to lib-python/2.7/encodings/iso8859_4.py
diff --git a/lib-python/2.7.0/encodings/iso8859_5.py b/lib-python/2.7/encodings/iso8859_5.py
rename from lib-python/2.7.0/encodings/iso8859_5.py
rename to lib-python/2.7/encodings/iso8859_5.py
diff --git a/lib-python/2.7.0/encodings/iso8859_6.py b/lib-python/2.7/encodings/iso8859_6.py
rename from lib-python/2.7.0/encodings/iso8859_6.py
rename to lib-python/2.7/encodings/iso8859_6.py
diff --git a/lib-python/2.7.0/encodings/iso8859_7.py b/lib-python/2.7/encodings/iso8859_7.py
rename from lib-python/2.7.0/encodings/iso8859_7.py
rename to lib-python/2.7/encodings/iso8859_7.py
diff --git a/lib-python/2.7.0/encodings/iso8859_8.py b/lib-python/2.7/encodings/iso8859_8.py
rename from lib-python/2.7.0/encodings/iso8859_8.py
rename to lib-python/2.7/encodings/iso8859_8.py
diff --git a/lib-python/2.7.0/encodings/iso8859_9.py b/lib-python/2.7/encodings/iso8859_9.py
rename from lib-python/2.7.0/encodings/iso8859_9.py
rename to lib-python/2.7/encodings/iso8859_9.py
diff --git a/lib-python/2.7.0/encodings/johab.py b/lib-python/2.7/encodings/johab.py
rename from lib-python/2.7.0/encodings/johab.py
rename to lib-python/2.7/encodings/johab.py
diff --git a/lib-python/2.7.0/encodings/koi8_r.py b/lib-python/2.7/encodings/koi8_r.py
rename from lib-python/2.7.0/encodings/koi8_r.py
rename to lib-python/2.7/encodings/koi8_r.py
diff --git a/lib-python/2.7.0/encodings/koi8_u.py b/lib-python/2.7/encodings/koi8_u.py
rename from lib-python/2.7.0/encodings/koi8_u.py
rename to lib-python/2.7/encodings/koi8_u.py
diff --git a/lib-python/2.7.0/encodings/latin_1.py b/lib-python/2.7/encodings/latin_1.py
rename from lib-python/2.7.0/encodings/latin_1.py
rename to lib-python/2.7/encodings/latin_1.py
diff --git a/lib-python/2.7.0/encodings/mac_arabic.py b/lib-python/2.7/encodings/mac_arabic.py
rename from lib-python/2.7.0/encodings/mac_arabic.py
rename to lib-python/2.7/encodings/mac_arabic.py
diff --git a/lib-python/2.7.0/encodings/mac_centeuro.py b/lib-python/2.7/encodings/mac_centeuro.py
rename from lib-python/2.7.0/encodings/mac_centeuro.py
rename to lib-python/2.7/encodings/mac_centeuro.py
diff --git a/lib-python/2.7.0/encodings/mac_croatian.py b/lib-python/2.7/encodings/mac_croatian.py
rename from lib-python/2.7.0/encodings/mac_croatian.py
rename to lib-python/2.7/encodings/mac_croatian.py
diff --git a/lib-python/2.7.0/encodings/mac_cyrillic.py b/lib-python/2.7/encodings/mac_cyrillic.py
rename from lib-python/2.7.0/encodings/mac_cyrillic.py
rename to lib-python/2.7/encodings/mac_cyrillic.py
diff --git a/lib-python/2.7.0/encodings/mac_farsi.py b/lib-python/2.7/encodings/mac_farsi.py
rename from lib-python/2.7.0/encodings/mac_farsi.py
rename to lib-python/2.7/encodings/mac_farsi.py
diff --git a/lib-python/2.7.0/encodings/mac_greek.py b/lib-python/2.7/encodings/mac_greek.py
rename from lib-python/2.7.0/encodings/mac_greek.py
rename to lib-python/2.7/encodings/mac_greek.py
diff --git a/lib-python/2.7.0/encodings/mac_iceland.py b/lib-python/2.7/encodings/mac_iceland.py
rename from lib-python/2.7.0/encodings/mac_iceland.py
rename to lib-python/2.7/encodings/mac_iceland.py
diff --git a/lib-python/2.7.0/encodings/mac_latin2.py b/lib-python/2.7/encodings/mac_latin2.py
rename from lib-python/2.7.0/encodings/mac_latin2.py
rename to lib-python/2.7/encodings/mac_latin2.py
diff --git a/lib-python/2.7.0/encodings/mac_roman.py b/lib-python/2.7/encodings/mac_roman.py
rename from lib-python/2.7.0/encodings/mac_roman.py
rename to lib-python/2.7/encodings/mac_roman.py
diff --git a/lib-python/2.7.0/encodings/mac_romanian.py b/lib-python/2.7/encodings/mac_romanian.py
rename from lib-python/2.7.0/encodings/mac_romanian.py
rename to lib-python/2.7/encodings/mac_romanian.py
diff --git a/lib-python/2.7.0/encodings/mac_turkish.py b/lib-python/2.7/encodings/mac_turkish.py
rename from lib-python/2.7.0/encodings/mac_turkish.py
rename to lib-python/2.7/encodings/mac_turkish.py
diff --git a/lib-python/2.7.0/encodings/mbcs.py b/lib-python/2.7/encodings/mbcs.py
rename from lib-python/2.7.0/encodings/mbcs.py
rename to lib-python/2.7/encodings/mbcs.py
diff --git a/lib-python/2.7.0/encodings/palmos.py b/lib-python/2.7/encodings/palmos.py
rename from lib-python/2.7.0/encodings/palmos.py
rename to lib-python/2.7/encodings/palmos.py
diff --git a/lib-python/2.7.0/encodings/ptcp154.py b/lib-python/2.7/encodings/ptcp154.py
rename from lib-python/2.7.0/encodings/ptcp154.py
rename to lib-python/2.7/encodings/ptcp154.py
diff --git a/lib-python/2.7.0/encodings/punycode.py b/lib-python/2.7/encodings/punycode.py
rename from lib-python/2.7.0/encodings/punycode.py
rename to lib-python/2.7/encodings/punycode.py
diff --git a/lib-python/2.7.0/encodings/quopri_codec.py b/lib-python/2.7/encodings/quopri_codec.py
rename from lib-python/2.7.0/encodings/quopri_codec.py
rename to lib-python/2.7/encodings/quopri_codec.py
diff --git a/lib-python/2.7.0/encodings/raw_unicode_escape.py b/lib-python/2.7/encodings/raw_unicode_escape.py
rename from lib-python/2.7.0/encodings/raw_unicode_escape.py
rename to lib-python/2.7/encodings/raw_unicode_escape.py
diff --git a/lib-python/2.7.0/encodings/rot_13.py b/lib-python/2.7/encodings/rot_13.py
rename from lib-python/2.7.0/encodings/rot_13.py
rename to lib-python/2.7/encodings/rot_13.py
diff --git a/lib-python/2.7.0/encodings/shift_jis.py b/lib-python/2.7/encodings/shift_jis.py
rename from lib-python/2.7.0/encodings/shift_jis.py
rename to lib-python/2.7/encodings/shift_jis.py
diff --git a/lib-python/2.7.0/encodings/shift_jis_2004.py b/lib-python/2.7/encodings/shift_jis_2004.py
rename from lib-python/2.7.0/encodings/shift_jis_2004.py
rename to lib-python/2.7/encodings/shift_jis_2004.py
diff --git a/lib-python/2.7.0/encodings/shift_jisx0213.py b/lib-python/2.7/encodings/shift_jisx0213.py
rename from lib-python/2.7.0/encodings/shift_jisx0213.py
rename to lib-python/2.7/encodings/shift_jisx0213.py
diff --git a/lib-python/2.7.0/encodings/string_escape.py b/lib-python/2.7/encodings/string_escape.py
rename from lib-python/2.7.0/encodings/string_escape.py
rename to lib-python/2.7/encodings/string_escape.py
diff --git a/lib-python/2.7.0/encodings/tis_620.py b/lib-python/2.7/encodings/tis_620.py
rename from lib-python/2.7.0/encodings/tis_620.py
rename to lib-python/2.7/encodings/tis_620.py
diff --git a/lib-python/2.7.0/encodings/undefined.py b/lib-python/2.7/encodings/undefined.py
rename from lib-python/2.7.0/encodings/undefined.py
rename to lib-python/2.7/encodings/undefined.py
diff --git a/lib-python/2.7.0/encodings/unicode_escape.py b/lib-python/2.7/encodings/unicode_escape.py
rename from lib-python/2.7.0/encodings/unicode_escape.py
rename to lib-python/2.7/encodings/unicode_escape.py
diff --git a/lib-python/2.7.0/encodings/unicode_internal.py b/lib-python/2.7/encodings/unicode_internal.py
rename from lib-python/2.7.0/encodings/unicode_internal.py
rename to lib-python/2.7/encodings/unicode_internal.py
diff --git a/lib-python/2.7.0/encodings/utf_16.py b/lib-python/2.7/encodings/utf_16.py
rename from lib-python/2.7.0/encodings/utf_16.py
rename to lib-python/2.7/encodings/utf_16.py
diff --git a/lib-python/2.7.0/encodings/utf_16_be.py b/lib-python/2.7/encodings/utf_16_be.py
rename from lib-python/2.7.0/encodings/utf_16_be.py
rename to lib-python/2.7/encodings/utf_16_be.py
diff --git a/lib-python/2.7.0/encodings/utf_16_le.py b/lib-python/2.7/encodings/utf_16_le.py
rename from lib-python/2.7.0/encodings/utf_16_le.py
rename to lib-python/2.7/encodings/utf_16_le.py
diff --git a/lib-python/2.7.0/encodings/utf_32.py b/lib-python/2.7/encodings/utf_32.py
rename from lib-python/2.7.0/encodings/utf_32.py
rename to lib-python/2.7/encodings/utf_32.py
diff --git a/lib-python/2.7.0/encodings/utf_32_be.py b/lib-python/2.7/encodings/utf_32_be.py
rename from lib-python/2.7.0/encodings/utf_32_be.py
rename to lib-python/2.7/encodings/utf_32_be.py
diff --git a/lib-python/2.7.0/encodings/utf_32_le.py b/lib-python/2.7/encodings/utf_32_le.py
rename from lib-python/2.7.0/encodings/utf_32_le.py
rename to lib-python/2.7/encodings/utf_32_le.py
diff --git a/lib-python/2.7.0/encodings/utf_7.py b/lib-python/2.7/encodings/utf_7.py
rename from lib-python/2.7.0/encodings/utf_7.py
rename to lib-python/2.7/encodings/utf_7.py
diff --git a/lib-python/2.7.0/encodings/utf_8.py b/lib-python/2.7/encodings/utf_8.py
rename from lib-python/2.7.0/encodings/utf_8.py
rename to lib-python/2.7/encodings/utf_8.py
diff --git a/lib-python/2.7.0/encodings/utf_8_sig.py b/lib-python/2.7/encodings/utf_8_sig.py
rename from lib-python/2.7.0/encodings/utf_8_sig.py
rename to lib-python/2.7/encodings/utf_8_sig.py
diff --git a/lib-python/2.7.0/encodings/uu_codec.py b/lib-python/2.7/encodings/uu_codec.py
rename from lib-python/2.7.0/encodings/uu_codec.py
rename to lib-python/2.7/encodings/uu_codec.py
diff --git a/lib-python/2.7.0/encodings/zlib_codec.py b/lib-python/2.7/encodings/zlib_codec.py
rename from lib-python/2.7.0/encodings/zlib_codec.py
rename to lib-python/2.7/encodings/zlib_codec.py
diff --git a/lib-python/2.7.0/filecmp.py b/lib-python/2.7/filecmp.py
rename from lib-python/2.7.0/filecmp.py
rename to lib-python/2.7/filecmp.py
diff --git a/lib-python/2.7.0/fileinput.py b/lib-python/2.7/fileinput.py
rename from lib-python/2.7.0/fileinput.py
rename to lib-python/2.7/fileinput.py
diff --git a/lib-python/2.7.0/fnmatch.py b/lib-python/2.7/fnmatch.py
rename from lib-python/2.7.0/fnmatch.py
rename to lib-python/2.7/fnmatch.py
diff --git a/lib-python/2.7.0/formatter.py b/lib-python/2.7/formatter.py
rename from lib-python/2.7.0/formatter.py
rename to lib-python/2.7/formatter.py
diff --git a/lib-python/2.7.0/fpformat.py b/lib-python/2.7/fpformat.py
rename from lib-python/2.7.0/fpformat.py
rename to lib-python/2.7/fpformat.py
diff --git a/lib-python/2.7.0/fractions.py b/lib-python/2.7/fractions.py
rename from lib-python/2.7.0/fractions.py
rename to lib-python/2.7/fractions.py
diff --git a/lib-python/2.7.0/ftplib.py b/lib-python/2.7/ftplib.py
rename from lib-python/2.7.0/ftplib.py
rename to lib-python/2.7/ftplib.py
diff --git a/lib-python/2.7.0/functools.py b/lib-python/2.7/functools.py
rename from lib-python/2.7.0/functools.py
rename to lib-python/2.7/functools.py
diff --git a/lib-python/2.7.0/genericpath.py b/lib-python/2.7/genericpath.py
rename from lib-python/2.7.0/genericpath.py
rename to lib-python/2.7/genericpath.py
diff --git a/lib-python/2.7.0/getopt.py b/lib-python/2.7/getopt.py
rename from lib-python/2.7.0/getopt.py
rename to lib-python/2.7/getopt.py
diff --git a/lib-python/2.7.0/getpass.py b/lib-python/2.7/getpass.py
rename from lib-python/2.7.0/getpass.py
rename to lib-python/2.7/getpass.py
diff --git a/lib-python/2.7.0/gettext.py b/lib-python/2.7/gettext.py
rename from lib-python/2.7.0/gettext.py
rename to lib-python/2.7/gettext.py
diff --git a/lib-python/2.7.0/glob.py b/lib-python/2.7/glob.py
rename from lib-python/2.7.0/glob.py
rename to lib-python/2.7/glob.py
diff --git a/lib-python/2.7.0/gzip.py b/lib-python/2.7/gzip.py
rename from lib-python/2.7.0/gzip.py
rename to lib-python/2.7/gzip.py
diff --git a/lib-python/2.7.0/hashlib.py b/lib-python/2.7/hashlib.py
rename from lib-python/2.7.0/hashlib.py
rename to lib-python/2.7/hashlib.py
--- a/lib-python/2.7.0/hashlib.py
+++ b/lib-python/2.7/hashlib.py
@@ -1,4 +1,4 @@
-# $Id: hashlib.py 78528 2010-03-01 02:01:47Z gregory.p.smith $
+# $Id$
 #
 #  Copyright (C) 2005   Gregory P. Smith (greg at krypto.org)
 #  Licensed to PSF under a Contributor Agreement.
diff --git a/lib-python/2.7.0/heapq.py b/lib-python/2.7/heapq.py
rename from lib-python/2.7.0/heapq.py
rename to lib-python/2.7/heapq.py
diff --git a/lib-python/2.7.0/hmac.py b/lib-python/2.7/hmac.py
rename from lib-python/2.7.0/hmac.py
rename to lib-python/2.7/hmac.py
diff --git a/lib-python/2.7.0/hotshot/__init__.py b/lib-python/2.7/hotshot/__init__.py
rename from lib-python/2.7.0/hotshot/__init__.py
rename to lib-python/2.7/hotshot/__init__.py
diff --git a/lib-python/2.7.0/hotshot/log.py b/lib-python/2.7/hotshot/log.py
rename from lib-python/2.7.0/hotshot/log.py
rename to lib-python/2.7/hotshot/log.py
diff --git a/lib-python/2.7.0/hotshot/stats.py b/lib-python/2.7/hotshot/stats.py
rename from lib-python/2.7.0/hotshot/stats.py
rename to lib-python/2.7/hotshot/stats.py
diff --git a/lib-python/2.7.0/hotshot/stones.py b/lib-python/2.7/hotshot/stones.py
rename from lib-python/2.7.0/hotshot/stones.py
rename to lib-python/2.7/hotshot/stones.py
diff --git a/lib-python/2.7.0/htmlentitydefs.py b/lib-python/2.7/htmlentitydefs.py
rename from lib-python/2.7.0/htmlentitydefs.py
rename to lib-python/2.7/htmlentitydefs.py
diff --git a/lib-python/2.7.0/htmllib.py b/lib-python/2.7/htmllib.py
rename from lib-python/2.7.0/htmllib.py
rename to lib-python/2.7/htmllib.py
diff --git a/lib-python/2.7.0/httplib.py b/lib-python/2.7/httplib.py
rename from lib-python/2.7.0/httplib.py
rename to lib-python/2.7/httplib.py
--- a/lib-python/2.7.0/httplib.py
+++ b/lib-python/2.7/httplib.py
@@ -879,6 +879,9 @@
                         host_enc = self.host.encode("ascii")
                     except UnicodeEncodeError:
                         host_enc = self.host.encode("idna")
+                    # Wrap the IPv6 Host Header with [] (RFC 2732)
+                    if host_enc.find(':') >= 0:
+                        host_enc = "[" + host_enc + "]"
                     if self.port == self.default_port:
                         self.putheader('Host', host_enc)
                     else:
diff --git a/lib-python/2.7.0/idlelib/AutoComplete.py b/lib-python/2.7/idlelib/AutoComplete.py
rename from lib-python/2.7.0/idlelib/AutoComplete.py
rename to lib-python/2.7/idlelib/AutoComplete.py
diff --git a/lib-python/2.7.0/idlelib/AutoCompleteWindow.py b/lib-python/2.7/idlelib/AutoCompleteWindow.py
rename from lib-python/2.7.0/idlelib/AutoCompleteWindow.py
rename to lib-python/2.7/idlelib/AutoCompleteWindow.py
diff --git a/lib-python/2.7.0/idlelib/AutoExpand.py b/lib-python/2.7/idlelib/AutoExpand.py
rename from lib-python/2.7.0/idlelib/AutoExpand.py
rename to lib-python/2.7/idlelib/AutoExpand.py
diff --git a/lib-python/2.7.0/idlelib/Bindings.py b/lib-python/2.7/idlelib/Bindings.py
rename from lib-python/2.7.0/idlelib/Bindings.py
rename to lib-python/2.7/idlelib/Bindings.py
diff --git a/lib-python/2.7.0/idlelib/CREDITS.txt b/lib-python/2.7/idlelib/CREDITS.txt
rename from lib-python/2.7.0/idlelib/CREDITS.txt
rename to lib-python/2.7/idlelib/CREDITS.txt
diff --git a/lib-python/2.7.0/idlelib/CallTipWindow.py b/lib-python/2.7/idlelib/CallTipWindow.py
rename from lib-python/2.7.0/idlelib/CallTipWindow.py
rename to lib-python/2.7/idlelib/CallTipWindow.py
diff --git a/lib-python/2.7.0/idlelib/CallTips.py b/lib-python/2.7/idlelib/CallTips.py
rename from lib-python/2.7.0/idlelib/CallTips.py
rename to lib-python/2.7/idlelib/CallTips.py
diff --git a/lib-python/2.7.0/idlelib/ChangeLog b/lib-python/2.7/idlelib/ChangeLog
rename from lib-python/2.7.0/idlelib/ChangeLog
rename to lib-python/2.7/idlelib/ChangeLog
diff --git a/lib-python/2.7.0/idlelib/ClassBrowser.py b/lib-python/2.7/idlelib/ClassBrowser.py
rename from lib-python/2.7.0/idlelib/ClassBrowser.py
rename to lib-python/2.7/idlelib/ClassBrowser.py
diff --git a/lib-python/2.7.0/idlelib/CodeContext.py b/lib-python/2.7/idlelib/CodeContext.py
rename from lib-python/2.7.0/idlelib/CodeContext.py
rename to lib-python/2.7/idlelib/CodeContext.py
diff --git a/lib-python/2.7.0/idlelib/ColorDelegator.py b/lib-python/2.7/idlelib/ColorDelegator.py
rename from lib-python/2.7.0/idlelib/ColorDelegator.py
rename to lib-python/2.7/idlelib/ColorDelegator.py
diff --git a/lib-python/2.7.0/idlelib/Debugger.py b/lib-python/2.7/idlelib/Debugger.py
rename from lib-python/2.7.0/idlelib/Debugger.py
rename to lib-python/2.7/idlelib/Debugger.py
diff --git a/lib-python/2.7.0/idlelib/Delegator.py b/lib-python/2.7/idlelib/Delegator.py
rename from lib-python/2.7.0/idlelib/Delegator.py
rename to lib-python/2.7/idlelib/Delegator.py
diff --git a/lib-python/2.7.0/idlelib/EditorWindow.py b/lib-python/2.7/idlelib/EditorWindow.py
rename from lib-python/2.7.0/idlelib/EditorWindow.py
rename to lib-python/2.7/idlelib/EditorWindow.py
diff --git a/lib-python/2.7.0/idlelib/FileList.py b/lib-python/2.7/idlelib/FileList.py
rename from lib-python/2.7.0/idlelib/FileList.py
rename to lib-python/2.7/idlelib/FileList.py
diff --git a/lib-python/2.7.0/idlelib/FormatParagraph.py b/lib-python/2.7/idlelib/FormatParagraph.py
rename from lib-python/2.7.0/idlelib/FormatParagraph.py
rename to lib-python/2.7/idlelib/FormatParagraph.py
diff --git a/lib-python/2.7.0/idlelib/GrepDialog.py b/lib-python/2.7/idlelib/GrepDialog.py
rename from lib-python/2.7.0/idlelib/GrepDialog.py
rename to lib-python/2.7/idlelib/GrepDialog.py
diff --git a/lib-python/2.7.0/idlelib/HISTORY.txt b/lib-python/2.7/idlelib/HISTORY.txt
rename from lib-python/2.7.0/idlelib/HISTORY.txt
rename to lib-python/2.7/idlelib/HISTORY.txt
diff --git a/lib-python/2.7.0/idlelib/HyperParser.py b/lib-python/2.7/idlelib/HyperParser.py
rename from lib-python/2.7.0/idlelib/HyperParser.py
rename to lib-python/2.7/idlelib/HyperParser.py
diff --git a/lib-python/2.7.0/idlelib/IOBinding.py b/lib-python/2.7/idlelib/IOBinding.py
rename from lib-python/2.7.0/idlelib/IOBinding.py
rename to lib-python/2.7/idlelib/IOBinding.py
--- a/lib-python/2.7.0/idlelib/IOBinding.py
+++ b/lib-python/2.7/idlelib/IOBinding.py
@@ -521,8 +521,8 @@
     savedialog = None
 
     filetypes = [
-        ("Python and text files", "*.py *.pyw *.txt", "TEXT"),
-        ("All text files", "*", "TEXT"),
+        ("Python files", "*.py *.pyw", "TEXT"),
+        ("Text files", "*.txt", "TEXT"),
         ("All files", "*"),
         ]
 
diff --git a/lib-python/2.7.0/idlelib/Icons/folder.gif b/lib-python/2.7/idlelib/Icons/folder.gif
rename from lib-python/2.7.0/idlelib/Icons/folder.gif
rename to lib-python/2.7/idlelib/Icons/folder.gif
diff --git a/lib-python/2.7.0/idlelib/Icons/idle.icns b/lib-python/2.7/idlelib/Icons/idle.icns
rename from lib-python/2.7.0/idlelib/Icons/idle.icns
rename to lib-python/2.7/idlelib/Icons/idle.icns
diff --git a/lib-python/2.7.0/idlelib/Icons/minusnode.gif b/lib-python/2.7/idlelib/Icons/minusnode.gif
rename from lib-python/2.7.0/idlelib/Icons/minusnode.gif
rename to lib-python/2.7/idlelib/Icons/minusnode.gif
diff --git a/lib-python/2.7.0/idlelib/Icons/openfolder.gif b/lib-python/2.7/idlelib/Icons/openfolder.gif
rename from lib-python/2.7.0/idlelib/Icons/openfolder.gif
rename to lib-python/2.7/idlelib/Icons/openfolder.gif
diff --git a/lib-python/2.7.0/idlelib/Icons/plusnode.gif b/lib-python/2.7/idlelib/Icons/plusnode.gif
rename from lib-python/2.7.0/idlelib/Icons/plusnode.gif
rename to lib-python/2.7/idlelib/Icons/plusnode.gif
diff --git a/lib-python/2.7.0/idlelib/Icons/python.gif b/lib-python/2.7/idlelib/Icons/python.gif
rename from lib-python/2.7.0/idlelib/Icons/python.gif
rename to lib-python/2.7/idlelib/Icons/python.gif
diff --git a/lib-python/2.7.0/idlelib/Icons/tk.gif b/lib-python/2.7/idlelib/Icons/tk.gif
rename from lib-python/2.7.0/idlelib/Icons/tk.gif
rename to lib-python/2.7/idlelib/Icons/tk.gif
diff --git a/lib-python/2.7.0/idlelib/IdleHistory.py b/lib-python/2.7/idlelib/IdleHistory.py
rename from lib-python/2.7.0/idlelib/IdleHistory.py
rename to lib-python/2.7/idlelib/IdleHistory.py
diff --git a/lib-python/2.7.0/idlelib/MultiCall.py b/lib-python/2.7/idlelib/MultiCall.py
rename from lib-python/2.7.0/idlelib/MultiCall.py
rename to lib-python/2.7/idlelib/MultiCall.py
diff --git a/lib-python/2.7.0/idlelib/MultiStatusBar.py b/lib-python/2.7/idlelib/MultiStatusBar.py
rename from lib-python/2.7.0/idlelib/MultiStatusBar.py
rename to lib-python/2.7/idlelib/MultiStatusBar.py
diff --git a/lib-python/2.7.0/idlelib/NEWS.txt b/lib-python/2.7/idlelib/NEWS.txt
rename from lib-python/2.7.0/idlelib/NEWS.txt
rename to lib-python/2.7/idlelib/NEWS.txt
diff --git a/lib-python/2.7.0/idlelib/ObjectBrowser.py b/lib-python/2.7/idlelib/ObjectBrowser.py
rename from lib-python/2.7.0/idlelib/ObjectBrowser.py
rename to lib-python/2.7/idlelib/ObjectBrowser.py
diff --git a/lib-python/2.7.0/idlelib/OutputWindow.py b/lib-python/2.7/idlelib/OutputWindow.py
rename from lib-python/2.7.0/idlelib/OutputWindow.py
rename to lib-python/2.7/idlelib/OutputWindow.py
diff --git a/lib-python/2.7.0/idlelib/ParenMatch.py b/lib-python/2.7/idlelib/ParenMatch.py
rename from lib-python/2.7.0/idlelib/ParenMatch.py
rename to lib-python/2.7/idlelib/ParenMatch.py
diff --git a/lib-python/2.7.0/idlelib/PathBrowser.py b/lib-python/2.7/idlelib/PathBrowser.py
rename from lib-python/2.7.0/idlelib/PathBrowser.py
rename to lib-python/2.7/idlelib/PathBrowser.py
diff --git a/lib-python/2.7.0/idlelib/Percolator.py b/lib-python/2.7/idlelib/Percolator.py
rename from lib-python/2.7.0/idlelib/Percolator.py
rename to lib-python/2.7/idlelib/Percolator.py
diff --git a/lib-python/2.7.0/idlelib/PyParse.py b/lib-python/2.7/idlelib/PyParse.py
rename from lib-python/2.7.0/idlelib/PyParse.py
rename to lib-python/2.7/idlelib/PyParse.py
diff --git a/lib-python/2.7.0/idlelib/PyShell.py b/lib-python/2.7/idlelib/PyShell.py
rename from lib-python/2.7.0/idlelib/PyShell.py
rename to lib-python/2.7/idlelib/PyShell.py
diff --git a/lib-python/2.7.0/idlelib/README.txt b/lib-python/2.7/idlelib/README.txt
rename from lib-python/2.7.0/idlelib/README.txt
rename to lib-python/2.7/idlelib/README.txt
diff --git a/lib-python/2.7.0/idlelib/RemoteDebugger.py b/lib-python/2.7/idlelib/RemoteDebugger.py
rename from lib-python/2.7.0/idlelib/RemoteDebugger.py
rename to lib-python/2.7/idlelib/RemoteDebugger.py
diff --git a/lib-python/2.7.0/idlelib/RemoteObjectBrowser.py b/lib-python/2.7/idlelib/RemoteObjectBrowser.py
rename from lib-python/2.7.0/idlelib/RemoteObjectBrowser.py
rename to lib-python/2.7/idlelib/RemoteObjectBrowser.py
diff --git a/lib-python/2.7.0/idlelib/ReplaceDialog.py b/lib-python/2.7/idlelib/ReplaceDialog.py
rename from lib-python/2.7.0/idlelib/ReplaceDialog.py
rename to lib-python/2.7/idlelib/ReplaceDialog.py
diff --git a/lib-python/2.7.0/idlelib/RstripExtension.py b/lib-python/2.7/idlelib/RstripExtension.py
rename from lib-python/2.7.0/idlelib/RstripExtension.py
rename to lib-python/2.7/idlelib/RstripExtension.py
diff --git a/lib-python/2.7.0/idlelib/ScriptBinding.py b/lib-python/2.7/idlelib/ScriptBinding.py
rename from lib-python/2.7.0/idlelib/ScriptBinding.py
rename to lib-python/2.7/idlelib/ScriptBinding.py
diff --git a/lib-python/2.7.0/idlelib/ScrolledList.py b/lib-python/2.7/idlelib/ScrolledList.py
rename from lib-python/2.7.0/idlelib/ScrolledList.py
rename to lib-python/2.7/idlelib/ScrolledList.py
diff --git a/lib-python/2.7.0/idlelib/SearchDialog.py b/lib-python/2.7/idlelib/SearchDialog.py
rename from lib-python/2.7.0/idlelib/SearchDialog.py
rename to lib-python/2.7/idlelib/SearchDialog.py
diff --git a/lib-python/2.7.0/idlelib/SearchDialogBase.py b/lib-python/2.7/idlelib/SearchDialogBase.py
rename from lib-python/2.7.0/idlelib/SearchDialogBase.py
rename to lib-python/2.7/idlelib/SearchDialogBase.py
diff --git a/lib-python/2.7.0/idlelib/SearchEngine.py b/lib-python/2.7/idlelib/SearchEngine.py
rename from lib-python/2.7.0/idlelib/SearchEngine.py
rename to lib-python/2.7/idlelib/SearchEngine.py
diff --git a/lib-python/2.7.0/idlelib/StackViewer.py b/lib-python/2.7/idlelib/StackViewer.py
rename from lib-python/2.7.0/idlelib/StackViewer.py
rename to lib-python/2.7/idlelib/StackViewer.py
diff --git a/lib-python/2.7.0/idlelib/TODO.txt b/lib-python/2.7/idlelib/TODO.txt
rename from lib-python/2.7.0/idlelib/TODO.txt
rename to lib-python/2.7/idlelib/TODO.txt
diff --git a/lib-python/2.7.0/idlelib/ToolTip.py b/lib-python/2.7/idlelib/ToolTip.py
rename from lib-python/2.7.0/idlelib/ToolTip.py
rename to lib-python/2.7/idlelib/ToolTip.py
diff --git a/lib-python/2.7.0/idlelib/TreeWidget.py b/lib-python/2.7/idlelib/TreeWidget.py
rename from lib-python/2.7.0/idlelib/TreeWidget.py
rename to lib-python/2.7/idlelib/TreeWidget.py
diff --git a/lib-python/2.7.0/idlelib/UndoDelegator.py b/lib-python/2.7/idlelib/UndoDelegator.py
rename from lib-python/2.7.0/idlelib/UndoDelegator.py
rename to lib-python/2.7/idlelib/UndoDelegator.py
diff --git a/lib-python/2.7.0/idlelib/WidgetRedirector.py b/lib-python/2.7/idlelib/WidgetRedirector.py
rename from lib-python/2.7.0/idlelib/WidgetRedirector.py
rename to lib-python/2.7/idlelib/WidgetRedirector.py
diff --git a/lib-python/2.7.0/idlelib/WindowList.py b/lib-python/2.7/idlelib/WindowList.py
rename from lib-python/2.7.0/idlelib/WindowList.py
rename to lib-python/2.7/idlelib/WindowList.py
diff --git a/lib-python/2.7.0/idlelib/ZoomHeight.py b/lib-python/2.7/idlelib/ZoomHeight.py
rename from lib-python/2.7.0/idlelib/ZoomHeight.py
rename to lib-python/2.7/idlelib/ZoomHeight.py
diff --git a/lib-python/2.7.0/idlelib/__init__.py b/lib-python/2.7/idlelib/__init__.py
rename from lib-python/2.7.0/idlelib/__init__.py
rename to lib-python/2.7/idlelib/__init__.py
diff --git a/lib-python/2.7.0/idlelib/aboutDialog.py b/lib-python/2.7/idlelib/aboutDialog.py
rename from lib-python/2.7.0/idlelib/aboutDialog.py
rename to lib-python/2.7/idlelib/aboutDialog.py
diff --git a/lib-python/2.7.0/idlelib/config-extensions.def b/lib-python/2.7/idlelib/config-extensions.def
rename from lib-python/2.7.0/idlelib/config-extensions.def
rename to lib-python/2.7/idlelib/config-extensions.def
diff --git a/lib-python/2.7.0/idlelib/config-highlight.def b/lib-python/2.7/idlelib/config-highlight.def
rename from lib-python/2.7.0/idlelib/config-highlight.def
rename to lib-python/2.7/idlelib/config-highlight.def
diff --git a/lib-python/2.7.0/idlelib/config-keys.def b/lib-python/2.7/idlelib/config-keys.def
rename from lib-python/2.7.0/idlelib/config-keys.def
rename to lib-python/2.7/idlelib/config-keys.def
diff --git a/lib-python/2.7.0/idlelib/config-main.def b/lib-python/2.7/idlelib/config-main.def
rename from lib-python/2.7.0/idlelib/config-main.def
rename to lib-python/2.7/idlelib/config-main.def
diff --git a/lib-python/2.7.0/idlelib/configDialog.py b/lib-python/2.7/idlelib/configDialog.py
rename from lib-python/2.7.0/idlelib/configDialog.py
rename to lib-python/2.7/idlelib/configDialog.py
diff --git a/lib-python/2.7.0/idlelib/configHandler.py b/lib-python/2.7/idlelib/configHandler.py
rename from lib-python/2.7.0/idlelib/configHandler.py
rename to lib-python/2.7/idlelib/configHandler.py
diff --git a/lib-python/2.7.0/idlelib/configHelpSourceEdit.py b/lib-python/2.7/idlelib/configHelpSourceEdit.py
rename from lib-python/2.7.0/idlelib/configHelpSourceEdit.py
rename to lib-python/2.7/idlelib/configHelpSourceEdit.py
diff --git a/lib-python/2.7.0/idlelib/configSectionNameDialog.py b/lib-python/2.7/idlelib/configSectionNameDialog.py
rename from lib-python/2.7.0/idlelib/configSectionNameDialog.py
rename to lib-python/2.7/idlelib/configSectionNameDialog.py
diff --git a/lib-python/2.7.0/idlelib/dynOptionMenuWidget.py b/lib-python/2.7/idlelib/dynOptionMenuWidget.py
rename from lib-python/2.7.0/idlelib/dynOptionMenuWidget.py
rename to lib-python/2.7/idlelib/dynOptionMenuWidget.py
diff --git a/lib-python/2.7.0/idlelib/extend.txt b/lib-python/2.7/idlelib/extend.txt
rename from lib-python/2.7.0/idlelib/extend.txt
rename to lib-python/2.7/idlelib/extend.txt
diff --git a/lib-python/2.7.0/idlelib/help.txt b/lib-python/2.7/idlelib/help.txt
rename from lib-python/2.7.0/idlelib/help.txt
rename to lib-python/2.7/idlelib/help.txt
diff --git a/lib-python/2.7.0/idlelib/idle.bat b/lib-python/2.7/idlelib/idle.bat
rename from lib-python/2.7.0/idlelib/idle.bat
rename to lib-python/2.7/idlelib/idle.bat
--- a/lib-python/2.7.0/idlelib/idle.bat
+++ b/lib-python/2.7/idlelib/idle.bat
@@ -1,3 +1,4 @@
 @echo off
-rem Working IDLE bat for Windows - uses start instead of absolute pathname
-start idle.pyw %1 %2 %3 %4 %5 %6 %7 %8 %9
+rem Start IDLE using the appropriate Python interpreter
+set CURRDIR=%~dp0
+start "%CURRDIR%..\..\pythonw.exe" "%CURRDIR%idle.pyw" %1 %2 %3 %4 %5 %6 %7 %8 %9
diff --git a/lib-python/2.7.0/idlelib/idle.py b/lib-python/2.7/idlelib/idle.py
rename from lib-python/2.7.0/idlelib/idle.py
rename to lib-python/2.7/idlelib/idle.py
diff --git a/lib-python/2.7.0/idlelib/idle.pyw b/lib-python/2.7/idlelib/idle.pyw
rename from lib-python/2.7.0/idlelib/idle.pyw
rename to lib-python/2.7/idlelib/idle.pyw
diff --git a/lib-python/2.7.0/idlelib/idlever.py b/lib-python/2.7/idlelib/idlever.py
rename from lib-python/2.7.0/idlelib/idlever.py
rename to lib-python/2.7/idlelib/idlever.py
--- a/lib-python/2.7.0/idlelib/idlever.py
+++ b/lib-python/2.7/idlelib/idlever.py
@@ -1,1 +1,1 @@
-IDLE_VERSION = "2.7.1a0"
+IDLE_VERSION = "2.7.1"
diff --git a/lib-python/2.7.0/idlelib/keybindingDialog.py b/lib-python/2.7/idlelib/keybindingDialog.py
rename from lib-python/2.7.0/idlelib/keybindingDialog.py
rename to lib-python/2.7/idlelib/keybindingDialog.py
diff --git a/lib-python/2.7.0/idlelib/macosxSupport.py b/lib-python/2.7/idlelib/macosxSupport.py
rename from lib-python/2.7.0/idlelib/macosxSupport.py
rename to lib-python/2.7/idlelib/macosxSupport.py
diff --git a/lib-python/2.7.0/idlelib/rpc.py b/lib-python/2.7/idlelib/rpc.py
rename from lib-python/2.7.0/idlelib/rpc.py
rename to lib-python/2.7/idlelib/rpc.py
diff --git a/lib-python/2.7.0/idlelib/run.py b/lib-python/2.7/idlelib/run.py
rename from lib-python/2.7.0/idlelib/run.py
rename to lib-python/2.7/idlelib/run.py
diff --git a/lib-python/2.7.0/idlelib/tabbedpages.py b/lib-python/2.7/idlelib/tabbedpages.py
rename from lib-python/2.7.0/idlelib/tabbedpages.py
rename to lib-python/2.7/idlelib/tabbedpages.py
diff --git a/lib-python/2.7.0/idlelib/testcode.py b/lib-python/2.7/idlelib/testcode.py
rename from lib-python/2.7.0/idlelib/testcode.py
rename to lib-python/2.7/idlelib/testcode.py
diff --git a/lib-python/2.7.0/idlelib/textView.py b/lib-python/2.7/idlelib/textView.py
rename from lib-python/2.7.0/idlelib/textView.py
rename to lib-python/2.7/idlelib/textView.py
diff --git a/lib-python/2.7.0/ihooks.py b/lib-python/2.7/ihooks.py
rename from lib-python/2.7.0/ihooks.py
rename to lib-python/2.7/ihooks.py
diff --git a/lib-python/2.7.0/imaplib.py b/lib-python/2.7/imaplib.py
rename from lib-python/2.7.0/imaplib.py
rename to lib-python/2.7/imaplib.py
--- a/lib-python/2.7.0/imaplib.py
+++ b/lib-python/2.7/imaplib.py
@@ -22,7 +22,7 @@
 
 __version__ = "2.58"
 
-import binascii, random, re, socket, subprocess, sys, time
+import binascii, errno, random, re, socket, subprocess, sys, time
 
 __all__ = ["IMAP4", "IMAP4_stream", "Internaldate2tuple",
            "Int2AP", "ParseFlags", "Time2Internaldate"]
@@ -248,7 +248,14 @@
     def shutdown(self):
         """Close I/O established in "open"."""
         self.file.close()
-        self.sock.close()
+        try:
+            self.sock.shutdown(socket.SHUT_RDWR)
+        except socket.error as e:
+            # The server might already have closed the connection
+            if e.errno != errno.ENOTCONN:
+                raise
+        finally:
+            self.sock.close()
 
 
     def socket(self):
@@ -883,14 +890,17 @@
 
 
     def _command_complete(self, name, tag):
-        self._check_bye()
+        # BYE is expected after LOGOUT
+        if name != 'LOGOUT':
+            self._check_bye()
         try:
             typ, data = self._get_tagged_response(tag)
         except self.abort, val:
             raise self.abort('command: %s => %s' % (name, val))
         except self.error, val:
             raise self.error('command: %s => %s' % (name, val))
-        self._check_bye()
+        if name != 'LOGOUT':
+            self._check_bye()
         if typ == 'BAD':
             raise self.error('%s command error: %s %s' % (name, typ, data))
         return typ, data
diff --git a/lib-python/2.7.0/imghdr.py b/lib-python/2.7/imghdr.py
rename from lib-python/2.7.0/imghdr.py
rename to lib-python/2.7/imghdr.py
diff --git a/lib-python/2.7.0/importlib/__init__.py b/lib-python/2.7/importlib/__init__.py
rename from lib-python/2.7.0/importlib/__init__.py
rename to lib-python/2.7/importlib/__init__.py
diff --git a/lib-python/2.7.0/imputil.py b/lib-python/2.7/imputil.py
rename from lib-python/2.7.0/imputil.py
rename to lib-python/2.7/imputil.py
diff --git a/lib-python/2.7.0/inspect.py b/lib-python/2.7/inspect.py
rename from lib-python/2.7.0/inspect.py
rename to lib-python/2.7/inspect.py
diff --git a/lib-python/2.7.0/io.py b/lib-python/2.7/io.py
rename from lib-python/2.7.0/io.py
rename to lib-python/2.7/io.py
diff --git a/lib-python/2.7.0/json/__init__.py b/lib-python/2.7/json/__init__.py
rename from lib-python/2.7.0/json/__init__.py
rename to lib-python/2.7/json/__init__.py
diff --git a/lib-python/2.7.0/json/decoder.py b/lib-python/2.7/json/decoder.py
rename from lib-python/2.7.0/json/decoder.py
rename to lib-python/2.7/json/decoder.py
diff --git a/lib-python/2.7.0/json/encoder.py b/lib-python/2.7/json/encoder.py
rename from lib-python/2.7.0/json/encoder.py
rename to lib-python/2.7/json/encoder.py
diff --git a/lib-python/2.7.0/json/scanner.py b/lib-python/2.7/json/scanner.py
rename from lib-python/2.7.0/json/scanner.py
rename to lib-python/2.7/json/scanner.py
diff --git a/lib-python/2.7.0/json/tests/__init__.py b/lib-python/2.7/json/tests/__init__.py
rename from lib-python/2.7.0/json/tests/__init__.py
rename to lib-python/2.7/json/tests/__init__.py
diff --git a/lib-python/2.7.0/json/tests/test_check_circular.py b/lib-python/2.7/json/tests/test_check_circular.py
rename from lib-python/2.7.0/json/tests/test_check_circular.py
rename to lib-python/2.7/json/tests/test_check_circular.py
diff --git a/lib-python/2.7.0/json/tests/test_decode.py b/lib-python/2.7/json/tests/test_decode.py
rename from lib-python/2.7.0/json/tests/test_decode.py
rename to lib-python/2.7/json/tests/test_decode.py
--- a/lib-python/2.7.0/json/tests/test_decode.py
+++ b/lib-python/2.7/json/tests/test_decode.py
@@ -9,19 +9,19 @@
     def test_decimal(self):
         rval = json.loads('1.1', parse_float=decimal.Decimal)
         self.assertTrue(isinstance(rval, decimal.Decimal))
-        self.assertEquals(rval, decimal.Decimal('1.1'))
+        self.assertEqual(rval, decimal.Decimal('1.1'))
 
     def test_float(self):
         rval = json.loads('1', parse_int=float)
         self.assertTrue(isinstance(rval, float))
-        self.assertEquals(rval, 1.0)
+        self.assertEqual(rval, 1.0)
 
     def test_decoder_optimizations(self):
         # Several optimizations were made that skip over calls to
         # the whitespace regex, so this test is designed to try and
         # exercise the uncommon cases. The array cases are already covered.
         rval = json.loads('{   "key"    :    "value"    ,  "k":"v"    }')
-        self.assertEquals(rval, {"key":"value", "k":"v"})
+        self.assertEqual(rval, {"key":"value", "k":"v"})
 
     def test_object_pairs_hook(self):
         s = '{"xkd":1, "kcw":2, "art":3, "hxm":4, "qrt":5, "pad":6, "hoy":7}'
diff --git a/lib-python/2.7.0/json/tests/test_default.py b/lib-python/2.7/json/tests/test_default.py
rename from lib-python/2.7.0/json/tests/test_default.py
rename to lib-python/2.7/json/tests/test_default.py
--- a/lib-python/2.7.0/json/tests/test_default.py
+++ b/lib-python/2.7/json/tests/test_default.py
@@ -4,6 +4,6 @@
 
 class TestDefault(TestCase):
     def test_default(self):
-        self.assertEquals(
+        self.assertEqual(
             json.dumps(type, default=repr),
             json.dumps(repr(type)))
diff --git a/lib-python/2.7.0/json/tests/test_dump.py b/lib-python/2.7/json/tests/test_dump.py
rename from lib-python/2.7.0/json/tests/test_dump.py
rename to lib-python/2.7/json/tests/test_dump.py
--- a/lib-python/2.7.0/json/tests/test_dump.py
+++ b/lib-python/2.7/json/tests/test_dump.py
@@ -7,15 +7,15 @@
     def test_dump(self):
         sio = StringIO()
         json.dump({}, sio)
-        self.assertEquals(sio.getvalue(), '{}')
+        self.assertEqual(sio.getvalue(), '{}')
 
     def test_dumps(self):
-        self.assertEquals(json.dumps({}), '{}')
+        self.assertEqual(json.dumps({}), '{}')
 
     def test_encode_truefalse(self):
-        self.assertEquals(json.dumps(
+        self.assertEqual(json.dumps(
                  {True: False, False: True}, sort_keys=True),
                  '{"false": true, "true": false}')
-        self.assertEquals(json.dumps(
+        self.assertEqual(json.dumps(
                 {2: 3.0, 4.0: 5L, False: 1, 6L: True}, sort_keys=True),
                 '{"false": 1, "2": 3.0, "4.0": 5, "6": true}')
diff --git a/lib-python/2.7.0/json/tests/test_encode_basestring_ascii.py b/lib-python/2.7/json/tests/test_encode_basestring_ascii.py
rename from lib-python/2.7.0/json/tests/test_encode_basestring_ascii.py
rename to lib-python/2.7/json/tests/test_encode_basestring_ascii.py
--- a/lib-python/2.7.0/json/tests/test_encode_basestring_ascii.py
+++ b/lib-python/2.7/json/tests/test_encode_basestring_ascii.py
@@ -36,7 +36,7 @@
         fname = encode_basestring_ascii.__name__
         for input_string, expect in CASES:
             result = encode_basestring_ascii(input_string)
-            self.assertEquals(result, expect,
+            self.assertEqual(result, expect,
                 '{0!r} != {1!r} for {2}({3!r})'.format(
                     result, expect, fname, input_string))
 
diff --git a/lib-python/2.7.0/json/tests/test_fail.py b/lib-python/2.7/json/tests/test_fail.py
rename from lib-python/2.7.0/json/tests/test_fail.py
rename to lib-python/2.7/json/tests/test_fail.py
diff --git a/lib-python/2.7.0/json/tests/test_float.py b/lib-python/2.7/json/tests/test_float.py
rename from lib-python/2.7.0/json/tests/test_float.py
rename to lib-python/2.7/json/tests/test_float.py
--- a/lib-python/2.7.0/json/tests/test_float.py
+++ b/lib-python/2.7/json/tests/test_float.py
@@ -7,13 +7,13 @@
     def test_floats(self):
         for num in [1617161771.7650001, math.pi, math.pi**100,
                     math.pi**-100, 3.1]:
-            self.assertEquals(float(json.dumps(num)), num)
-            self.assertEquals(json.loads(json.dumps(num)), num)
-            self.assertEquals(json.loads(unicode(json.dumps(num))), num)
+            self.assertEqual(float(json.dumps(num)), num)
+            self.assertEqual(json.loads(json.dumps(num)), num)
+            self.assertEqual(json.loads(unicode(json.dumps(num))), num)
 
     def test_ints(self):
         for num in [1, 1L, 1<<32, 1<<64]:
-            self.assertEquals(json.dumps(num), str(num))
-            self.assertEquals(int(json.dumps(num)), num)
-            self.assertEquals(json.loads(json.dumps(num)), num)
-            self.assertEquals(json.loads(unicode(json.dumps(num))), num)
+            self.assertEqual(json.dumps(num), str(num))
+            self.assertEqual(int(json.dumps(num)), num)
+            self.assertEqual(json.loads(json.dumps(num)), num)
+            self.assertEqual(json.loads(unicode(json.dumps(num))), num)
diff --git a/lib-python/2.7.0/json/tests/test_indent.py b/lib-python/2.7/json/tests/test_indent.py
rename from lib-python/2.7.0/json/tests/test_indent.py
rename to lib-python/2.7/json/tests/test_indent.py
--- a/lib-python/2.7.0/json/tests/test_indent.py
+++ b/lib-python/2.7/json/tests/test_indent.py
@@ -36,6 +36,6 @@
         h1 = json.loads(d1)
         h2 = json.loads(d2)
 
-        self.assertEquals(h1, h)
-        self.assertEquals(h2, h)
-        self.assertEquals(d2, expect)
+        self.assertEqual(h1, h)
+        self.assertEqual(h2, h)
+        self.assertEqual(d2, expect)
diff --git a/lib-python/2.7.0/json/tests/test_pass1.py b/lib-python/2.7/json/tests/test_pass1.py
rename from lib-python/2.7.0/json/tests/test_pass1.py
rename to lib-python/2.7/json/tests/test_pass1.py
--- a/lib-python/2.7.0/json/tests/test_pass1.py
+++ b/lib-python/2.7/json/tests/test_pass1.py
@@ -67,7 +67,7 @@
         # test in/out equivalence and parsing
         res = json.loads(JSON)
         out = json.dumps(res)
-        self.assertEquals(res, json.loads(out))
+        self.assertEqual(res, json.loads(out))
         try:
             json.dumps(res, allow_nan=False)
         except ValueError:
diff --git a/lib-python/2.7.0/json/tests/test_pass2.py b/lib-python/2.7/json/tests/test_pass2.py
rename from lib-python/2.7.0/json/tests/test_pass2.py
rename to lib-python/2.7/json/tests/test_pass2.py
--- a/lib-python/2.7.0/json/tests/test_pass2.py
+++ b/lib-python/2.7/json/tests/test_pass2.py
@@ -11,4 +11,4 @@
         # test in/out equivalence and parsing
         res = json.loads(JSON)
         out = json.dumps(res)
-        self.assertEquals(res, json.loads(out))
+        self.assertEqual(res, json.loads(out))
diff --git a/lib-python/2.7.0/json/tests/test_pass3.py b/lib-python/2.7/json/tests/test_pass3.py
rename from lib-python/2.7.0/json/tests/test_pass3.py
rename to lib-python/2.7/json/tests/test_pass3.py
--- a/lib-python/2.7.0/json/tests/test_pass3.py
+++ b/lib-python/2.7/json/tests/test_pass3.py
@@ -17,4 +17,4 @@
         # test in/out equivalence and parsing
         res = json.loads(JSON)
         out = json.dumps(res)
-        self.assertEquals(res, json.loads(out))
+        self.assertEqual(res, json.loads(out))
diff --git a/lib-python/2.7.0/json/tests/test_recursion.py b/lib-python/2.7/json/tests/test_recursion.py
rename from lib-python/2.7.0/json/tests/test_recursion.py
rename to lib-python/2.7/json/tests/test_recursion.py
--- a/lib-python/2.7.0/json/tests/test_recursion.py
+++ b/lib-python/2.7/json/tests/test_recursion.py
@@ -57,7 +57,7 @@
 
     def test_defaultrecursion(self):
         enc = RecursiveJSONEncoder()
-        self.assertEquals(enc.encode(JSONTestObject), '"JSONTestObject"')
+        self.assertEqual(enc.encode(JSONTestObject), '"JSONTestObject"')
         enc.recurse = True
         try:
             enc.encode(JSONTestObject)
diff --git a/lib-python/2.7.0/json/tests/test_scanstring.py b/lib-python/2.7/json/tests/test_scanstring.py
rename from lib-python/2.7.0/json/tests/test_scanstring.py
rename to lib-python/2.7/json/tests/test_scanstring.py
--- a/lib-python/2.7.0/json/tests/test_scanstring.py
+++ b/lib-python/2.7/json/tests/test_scanstring.py
@@ -13,92 +13,92 @@
         self._test_scanstring(json.decoder.c_scanstring)
 
     def _test_scanstring(self, scanstring):
-        self.assertEquals(
+        self.assertEqual(
             scanstring('"z\\ud834\\udd20x"', 1, None, True),
             (u'z\U0001d120x', 16))
 
         if sys.maxunicode == 65535:
-            self.assertEquals(
+            self.assertEqual(
                 scanstring(u'"z\U0001d120x"', 1, None, True),
                 (u'z\U0001d120x', 6))
         else:
-            self.assertEquals(
+            self.assertEqual(
                 scanstring(u'"z\U0001d120x"', 1, None, True),
                 (u'z\U0001d120x', 5))
 
-        self.assertEquals(
+        self.assertEqual(
             scanstring('"\\u007b"', 1, None, True),
             (u'{', 8))
 
-        self.assertEquals(
+        self.assertEqual(
             scanstring('"A JSON payload should be an object or array, not a string."', 1, None, True),
             (u'A JSON payload should be an object or array, not a string.', 60))
 
-        self.assertEquals(
+        self.assertEqual(
             scanstring('["Unclosed array"', 2, None, True),
             (u'Unclosed array', 17))
 
-        self.assertEquals(
+        self.assertEqual(
             scanstring('["extra comma",]', 2, None, True),
             (u'extra comma', 14))
 
-        self.assertEquals(
+        self.assertEqual(
             scanstring('["double extra comma",,]', 2, None, True),
             (u'double extra comma', 21))
 
-        self.assertEquals(
+        self.assertEqual(
             scanstring('["Comma after the close"],', 2, None, True),
             (u'Comma after the close', 24))
 
-        self.assertEquals(
+        self.assertEqual(
             scanstring('["Extra close"]]', 2, None, True),
             (u'Extra close', 14))
 
-        self.assertEquals(
+        self.assertEqual(
             scanstring('{"Extra comma": true,}', 2, None, True),
             (u'Extra comma', 14))
 
-        self.assertEquals(
+        self.assertEqual(
             scanstring('{"Extra value after close": true} "misplaced quoted value"', 2, None, True),
             (u'Extra value after close', 26))
 
-        self.assertEquals(
+        self.assertEqual(
             scanstring('{"Illegal expression": 1 + 2}', 2, None, True),
             (u'Illegal expression', 21))
 
-        self.assertEquals(
+        self.assertEqual(
             scanstring('{"Illegal invocation": alert()}', 2, None, True),
             (u'Illegal invocation', 21))
 
-        self.assertEquals(
+        self.assertEqual(
             scanstring('{"Numbers cannot have leading zeroes": 013}', 2, None, True),
             (u'Numbers cannot have leading zeroes', 37))
 
-        self.assertEquals(
+        self.assertEqual(
             scanstring('{"Numbers cannot be hex": 0x14}', 2, None, True),
             (u'Numbers cannot be hex', 24))
 
-        self.assertEquals(
+        self.assertEqual(
             scanstring('[[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]]', 21, None, True),
             (u'Too deep', 30))
 
-        self.assertEquals(
+        self.assertEqual(
             scanstring('{"Missing colon" null}', 2, None, True),
             (u'Missing colon', 16))
 
-        self.assertEquals(
+        self.assertEqual(
             scanstring('{"Double colon":: null}', 2, None, True),
             (u'Double colon', 15))
 
-        self.assertEquals(
+        self.assertEqual(
             scanstring('{"Comma instead of colon", null}', 2, None, True),
             (u'Comma instead of colon', 25))
 
-        self.assertEquals(
+        self.assertEqual(
             scanstring('["Colon instead of comma": false]', 2, None, True),
             (u'Colon instead of comma', 25))
 
-        self.assertEquals(
+        self.assertEqual(
             scanstring('["Bad value", truth]', 2, None, True),
             (u'Bad value', 12))
 
diff --git a/lib-python/2.7.0/json/tests/test_separators.py b/lib-python/2.7/json/tests/test_separators.py
rename from lib-python/2.7.0/json/tests/test_separators.py
rename to lib-python/2.7/json/tests/test_separators.py
--- a/lib-python/2.7.0/json/tests/test_separators.py
+++ b/lib-python/2.7/json/tests/test_separators.py
@@ -37,6 +37,6 @@
         h1 = json.loads(d1)
         h2 = json.loads(d2)
 
-        self.assertEquals(h1, h)
-        self.assertEquals(h2, h)
-        self.assertEquals(d2, expect)
+        self.assertEqual(h1, h)
+        self.assertEqual(h2, h)
+        self.assertEqual(d2, expect)
diff --git a/lib-python/2.7.0/json/tests/test_speedups.py b/lib-python/2.7/json/tests/test_speedups.py
rename from lib-python/2.7.0/json/tests/test_speedups.py
rename to lib-python/2.7/json/tests/test_speedups.py
--- a/lib-python/2.7.0/json/tests/test_speedups.py
+++ b/lib-python/2.7/json/tests/test_speedups.py
@@ -5,11 +5,11 @@
 
 class TestSpeedups(TestCase):
     def test_scanstring(self):
-        self.assertEquals(decoder.scanstring.__module__, "_json")
+        self.assertEqual(decoder.scanstring.__module__, "_json")
         self.assertTrue(decoder.scanstring is decoder.c_scanstring)
 
     def test_encode_basestring_ascii(self):
-        self.assertEquals(encoder.encode_basestring_ascii.__module__, "_json")
+        self.assertEqual(encoder.encode_basestring_ascii.__module__, "_json")
         self.assertTrue(encoder.encode_basestring_ascii is
                           encoder.c_encode_basestring_ascii)
 
diff --git a/lib-python/2.7.0/json/tests/test_unicode.py b/lib-python/2.7/json/tests/test_unicode.py
rename from lib-python/2.7.0/json/tests/test_unicode.py
rename to lib-python/2.7/json/tests/test_unicode.py
--- a/lib-python/2.7.0/json/tests/test_unicode.py
+++ b/lib-python/2.7/json/tests/test_unicode.py
@@ -10,50 +10,50 @@
         s = u.encode('utf-8')
         ju = encoder.encode(u)
         js = encoder.encode(s)
-        self.assertEquals(ju, js)
+        self.assertEqual(ju, js)
 
     def test_encoding2(self):
         u = u'\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}'
         s = u.encode('utf-8')
         ju = json.dumps(u, encoding='utf-8')
         js = json.dumps(s, encoding='utf-8')
-        self.assertEquals(ju, js)
+        self.assertEqual(ju, js)
 
     def test_encoding3(self):
         u = u'\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}'
         j = json.dumps(u)
-        self.assertEquals(j, '"\\u03b1\\u03a9"')
+        self.assertEqual(j, '"\\u03b1\\u03a9"')
 
     def test_encoding4(self):
         u = u'\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}'
         j = json.dumps([u])
-        self.assertEquals(j, '["\\u03b1\\u03a9"]')
+        self.assertEqual(j, '["\\u03b1\\u03a9"]')
 
     def test_encoding5(self):
         u = u'\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}'
         j = json.dumps(u, ensure_ascii=False)
-        self.assertEquals(j, u'"{0}"'.format(u))
+        self.assertEqual(j, u'"{0}"'.format(u))
 
     def test_encoding6(self):
         u = u'\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}'
         j = json.dumps([u], ensure_ascii=False)
-        self.assertEquals(j, u'["{0}"]'.format(u))
+        self.assertEqual(j, u'["{0}"]'.format(u))
 
     def test_big_unicode_encode(self):
         u = u'\U0001d120'
-        self.assertEquals(json.dumps(u), '"\\ud834\\udd20"')
-        self.assertEquals(json.dumps(u, ensure_ascii=False), u'"\U0001d120"')
+        self.assertEqual(json.dumps(u), '"\\ud834\\udd20"')
+        self.assertEqual(json.dumps(u, ensure_ascii=False), u'"\U0001d120"')
 
     def test_big_unicode_decode(self):
         u = u'z\U0001d120x'
-        self.assertEquals(json.loads('"' + u + '"'), u)
-        self.assertEquals(json.loads('"z\\ud834\\udd20x"'), u)
+        self.assertEqual(json.loads('"' + u + '"'), u)
+        self.assertEqual(json.loads('"z\\ud834\\udd20x"'), u)
 
     def test_unicode_decode(self):
         for i in range(0, 0xd7ff):
             u = unichr(i)
             s = '"\\u{0:04x}"'.format(i)
-            self.assertEquals(json.loads(s), u)
+            self.assertEqual(json.loads(s), u)
 
     def test_object_pairs_hook_with_unicode(self):
         s = u'{"xkd":1, "kcw":2, "art":3, "hxm":4, "qrt":5, "pad":6, "hoy":7}'
@@ -71,12 +71,12 @@
                          OrderedDict(p))
 
     def test_default_encoding(self):
-        self.assertEquals(json.loads(u'{"a": "\xe9"}'.encode('utf-8')),
+        self.assertEqual(json.loads(u'{"a": "\xe9"}'.encode('utf-8')),
             {'a': u'\xe9'})
 
     def test_unicode_preservation(self):
-        self.assertEquals(type(json.loads(u'""')), unicode)
-        self.assertEquals(type(json.loads(u'"a"')), unicode)
-        self.assertEquals(type(json.loads(u'["a"]')[0]), unicode)
+        self.assertEqual(type(json.loads(u'""')), unicode)
+        self.assertEqual(type(json.loads(u'"a"')), unicode)
+        self.assertEqual(type(json.loads(u'["a"]')[0]), unicode)
         # Issue 10038.
-        self.assertEquals(type(json.loads('"foo"')), unicode)
+        self.assertEqual(type(json.loads('"foo"')), unicode)
diff --git a/lib-python/2.7.0/json/tool.py b/lib-python/2.7/json/tool.py
rename from lib-python/2.7.0/json/tool.py
rename to lib-python/2.7/json/tool.py
diff --git a/lib-python/2.7.0/keyword.py b/lib-python/2.7/keyword.py
rename from lib-python/2.7.0/keyword.py
rename to lib-python/2.7/keyword.py
diff --git a/lib-python/2.7.0/lib-tk/Canvas.py b/lib-python/2.7/lib-tk/Canvas.py
rename from lib-python/2.7.0/lib-tk/Canvas.py
rename to lib-python/2.7/lib-tk/Canvas.py
diff --git a/lib-python/2.7.0/lib-tk/Dialog.py b/lib-python/2.7/lib-tk/Dialog.py
rename from lib-python/2.7.0/lib-tk/Dialog.py
rename to lib-python/2.7/lib-tk/Dialog.py
diff --git a/lib-python/2.7.0/lib-tk/FileDialog.py b/lib-python/2.7/lib-tk/FileDialog.py
rename from lib-python/2.7.0/lib-tk/FileDialog.py
rename to lib-python/2.7/lib-tk/FileDialog.py
diff --git a/lib-python/2.7.0/lib-tk/FixTk.py b/lib-python/2.7/lib-tk/FixTk.py
rename from lib-python/2.7.0/lib-tk/FixTk.py
rename to lib-python/2.7/lib-tk/FixTk.py
diff --git a/lib-python/2.7.0/lib-tk/ScrolledText.py b/lib-python/2.7/lib-tk/ScrolledText.py
rename from lib-python/2.7.0/lib-tk/ScrolledText.py
rename to lib-python/2.7/lib-tk/ScrolledText.py
diff --git a/lib-python/2.7.0/lib-tk/SimpleDialog.py b/lib-python/2.7/lib-tk/SimpleDialog.py
rename from lib-python/2.7.0/lib-tk/SimpleDialog.py
rename to lib-python/2.7/lib-tk/SimpleDialog.py
diff --git a/lib-python/2.7.0/lib-tk/Tix.py b/lib-python/2.7/lib-tk/Tix.py
rename from lib-python/2.7.0/lib-tk/Tix.py
rename to lib-python/2.7/lib-tk/Tix.py
--- a/lib-python/2.7.0/lib-tk/Tix.py
+++ b/lib-python/2.7/lib-tk/Tix.py
@@ -1,6 +1,6 @@
 # -*-mode: python; fill-column: 75; tab-width: 8; coding: iso-latin-1-unix -*-
 #
-# $Id: Tix.py 81008 2010-05-08 20:59:42Z benjamin.peterson $
+# $Id$
 #
 # Tix.py -- Tix widget wrappers.
 #
diff --git a/lib-python/2.7.0/lib-tk/Tkconstants.py b/lib-python/2.7/lib-tk/Tkconstants.py
rename from lib-python/2.7.0/lib-tk/Tkconstants.py
rename to lib-python/2.7/lib-tk/Tkconstants.py
diff --git a/lib-python/2.7.0/lib-tk/Tkdnd.py b/lib-python/2.7/lib-tk/Tkdnd.py
rename from lib-python/2.7.0/lib-tk/Tkdnd.py
rename to lib-python/2.7/lib-tk/Tkdnd.py
diff --git a/lib-python/2.7.0/lib-tk/Tkinter.py b/lib-python/2.7/lib-tk/Tkinter.py
rename from lib-python/2.7.0/lib-tk/Tkinter.py
rename to lib-python/2.7/lib-tk/Tkinter.py
--- a/lib-python/2.7.0/lib-tk/Tkinter.py
+++ b/lib-python/2.7/lib-tk/Tkinter.py
@@ -30,7 +30,7 @@
 tk.mainloop()
 """
 
-__version__ = "$Revision: 81008 $"
+__version__ = "$Revision$"
 
 import sys
 if sys.platform == "win32":
diff --git a/lib-python/2.7.0/lib-tk/test/README b/lib-python/2.7/lib-tk/test/README
rename from lib-python/2.7.0/lib-tk/test/README
rename to lib-python/2.7/lib-tk/test/README
diff --git a/lib-python/2.7.0/lib-tk/test/runtktests.py b/lib-python/2.7/lib-tk/test/runtktests.py
rename from lib-python/2.7.0/lib-tk/test/runtktests.py
rename to lib-python/2.7/lib-tk/test/runtktests.py
diff --git a/lib-python/2.7.0/lib-tk/test/test_tkinter/__init__.py b/lib-python/2.7/lib-tk/test/test_tkinter/__init__.py
rename from lib-python/2.7.0/lib-tk/test/test_tkinter/__init__.py
rename to lib-python/2.7/lib-tk/test/test_tkinter/__init__.py
diff --git a/lib-python/2.7.0/lib-tk/test/test_tkinter/test_loadtk.py b/lib-python/2.7/lib-tk/test/test_tkinter/test_loadtk.py
rename from lib-python/2.7.0/lib-tk/test/test_tkinter/test_loadtk.py
rename to lib-python/2.7/lib-tk/test/test_tkinter/test_loadtk.py
diff --git a/lib-python/2.7.0/lib-tk/test/test_tkinter/test_text.py b/lib-python/2.7/lib-tk/test/test_tkinter/test_text.py
rename from lib-python/2.7.0/lib-tk/test/test_tkinter/test_text.py
rename to lib-python/2.7/lib-tk/test/test_tkinter/test_text.py
diff --git a/lib-python/2.7.0/lib-tk/test/test_ttk/__init__.py b/lib-python/2.7/lib-tk/test/test_ttk/__init__.py
rename from lib-python/2.7.0/lib-tk/test/test_ttk/__init__.py
rename to lib-python/2.7/lib-tk/test/test_ttk/__init__.py
diff --git a/lib-python/2.7.0/lib-tk/test/test_ttk/support.py b/lib-python/2.7/lib-tk/test/test_ttk/support.py
rename from lib-python/2.7.0/lib-tk/test/test_ttk/support.py
rename to lib-python/2.7/lib-tk/test/test_ttk/support.py
diff --git a/lib-python/2.7.0/lib-tk/test/test_ttk/test_extensions.py b/lib-python/2.7/lib-tk/test/test_ttk/test_extensions.py
rename from lib-python/2.7.0/lib-tk/test/test_ttk/test_extensions.py
rename to lib-python/2.7/lib-tk/test/test_ttk/test_extensions.py
diff --git a/lib-python/2.7.0/lib-tk/test/test_ttk/test_functions.py b/lib-python/2.7/lib-tk/test/test_ttk/test_functions.py
rename from lib-python/2.7.0/lib-tk/test/test_ttk/test_functions.py
rename to lib-python/2.7/lib-tk/test/test_ttk/test_functions.py
diff --git a/lib-python/2.7.0/lib-tk/test/test_ttk/test_style.py b/lib-python/2.7/lib-tk/test/test_ttk/test_style.py
rename from lib-python/2.7.0/lib-tk/test/test_ttk/test_style.py
rename to lib-python/2.7/lib-tk/test/test_ttk/test_style.py
diff --git a/lib-python/2.7.0/lib-tk/test/test_ttk/test_widgets.py b/lib-python/2.7/lib-tk/test/test_ttk/test_widgets.py
rename from lib-python/2.7.0/lib-tk/test/test_ttk/test_widgets.py
rename to lib-python/2.7/lib-tk/test/test_ttk/test_widgets.py
diff --git a/lib-python/2.7.0/lib-tk/tkColorChooser.py b/lib-python/2.7/lib-tk/tkColorChooser.py
rename from lib-python/2.7.0/lib-tk/tkColorChooser.py
rename to lib-python/2.7/lib-tk/tkColorChooser.py
diff --git a/lib-python/2.7.0/lib-tk/tkCommonDialog.py b/lib-python/2.7/lib-tk/tkCommonDialog.py
rename from lib-python/2.7.0/lib-tk/tkCommonDialog.py
rename to lib-python/2.7/lib-tk/tkCommonDialog.py
diff --git a/lib-python/2.7.0/lib-tk/tkFileDialog.py b/lib-python/2.7/lib-tk/tkFileDialog.py
rename from lib-python/2.7.0/lib-tk/tkFileDialog.py
rename to lib-python/2.7/lib-tk/tkFileDialog.py
diff --git a/lib-python/2.7.0/lib-tk/tkFont.py b/lib-python/2.7/lib-tk/tkFont.py
rename from lib-python/2.7.0/lib-tk/tkFont.py
rename to lib-python/2.7/lib-tk/tkFont.py
diff --git a/lib-python/2.7.0/lib-tk/tkMessageBox.py b/lib-python/2.7/lib-tk/tkMessageBox.py
rename from lib-python/2.7.0/lib-tk/tkMessageBox.py
rename to lib-python/2.7/lib-tk/tkMessageBox.py
diff --git a/lib-python/2.7.0/lib-tk/tkSimpleDialog.py b/lib-python/2.7/lib-tk/tkSimpleDialog.py
rename from lib-python/2.7.0/lib-tk/tkSimpleDialog.py
rename to lib-python/2.7/lib-tk/tkSimpleDialog.py
diff --git a/lib-python/2.7.0/lib-tk/ttk.py b/lib-python/2.7/lib-tk/ttk.py
rename from lib-python/2.7.0/lib-tk/ttk.py
rename to lib-python/2.7/lib-tk/ttk.py
diff --git a/lib-python/2.7.0/lib-tk/turtle.py b/lib-python/2.7/lib-tk/turtle.py
rename from lib-python/2.7.0/lib-tk/turtle.py
rename to lib-python/2.7/lib-tk/turtle.py
diff --git a/lib-python/2.7.0/lib2to3/Grammar.txt b/lib-python/2.7/lib2to3/Grammar.txt
rename from lib-python/2.7.0/lib2to3/Grammar.txt
rename to lib-python/2.7/lib2to3/Grammar.txt
diff --git a/lib-python/2.7.0/lib2to3/PatternGrammar.txt b/lib-python/2.7/lib2to3/PatternGrammar.txt
rename from lib-python/2.7.0/lib2to3/PatternGrammar.txt
rename to lib-python/2.7/lib2to3/PatternGrammar.txt
diff --git a/lib-python/2.7.0/lib2to3/__init__.py b/lib-python/2.7/lib2to3/__init__.py
rename from lib-python/2.7.0/lib2to3/__init__.py
rename to lib-python/2.7/lib2to3/__init__.py
diff --git a/lib-python/2.7.0/lib2to3/btm_matcher.py b/lib-python/2.7/lib2to3/btm_matcher.py
rename from lib-python/2.7.0/lib2to3/btm_matcher.py
rename to lib-python/2.7/lib2to3/btm_matcher.py
diff --git a/lib-python/2.7.0/lib2to3/btm_utils.py b/lib-python/2.7/lib2to3/btm_utils.py
rename from lib-python/2.7.0/lib2to3/btm_utils.py
rename to lib-python/2.7/lib2to3/btm_utils.py
diff --git a/lib-python/2.7.0/lib2to3/fixer_base.py b/lib-python/2.7/lib2to3/fixer_base.py
rename from lib-python/2.7.0/lib2to3/fixer_base.py
rename to lib-python/2.7/lib2to3/fixer_base.py
diff --git a/lib-python/2.7.0/lib2to3/fixer_util.py b/lib-python/2.7/lib2to3/fixer_util.py
rename from lib-python/2.7.0/lib2to3/fixer_util.py
rename to lib-python/2.7/lib2to3/fixer_util.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/__init__.py b/lib-python/2.7/lib2to3/fixes/__init__.py
rename from lib-python/2.7.0/lib2to3/fixes/__init__.py
rename to lib-python/2.7/lib2to3/fixes/__init__.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_apply.py b/lib-python/2.7/lib2to3/fixes/fix_apply.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_apply.py
rename to lib-python/2.7/lib2to3/fixes/fix_apply.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_basestring.py b/lib-python/2.7/lib2to3/fixes/fix_basestring.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_basestring.py
rename to lib-python/2.7/lib2to3/fixes/fix_basestring.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_buffer.py b/lib-python/2.7/lib2to3/fixes/fix_buffer.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_buffer.py
rename to lib-python/2.7/lib2to3/fixes/fix_buffer.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_callable.py b/lib-python/2.7/lib2to3/fixes/fix_callable.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_callable.py
rename to lib-python/2.7/lib2to3/fixes/fix_callable.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_dict.py b/lib-python/2.7/lib2to3/fixes/fix_dict.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_dict.py
rename to lib-python/2.7/lib2to3/fixes/fix_dict.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_except.py b/lib-python/2.7/lib2to3/fixes/fix_except.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_except.py
rename to lib-python/2.7/lib2to3/fixes/fix_except.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_exec.py b/lib-python/2.7/lib2to3/fixes/fix_exec.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_exec.py
rename to lib-python/2.7/lib2to3/fixes/fix_exec.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_execfile.py b/lib-python/2.7/lib2to3/fixes/fix_execfile.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_execfile.py
rename to lib-python/2.7/lib2to3/fixes/fix_execfile.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_exitfunc.py b/lib-python/2.7/lib2to3/fixes/fix_exitfunc.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_exitfunc.py
rename to lib-python/2.7/lib2to3/fixes/fix_exitfunc.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_filter.py b/lib-python/2.7/lib2to3/fixes/fix_filter.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_filter.py
rename to lib-python/2.7/lib2to3/fixes/fix_filter.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_funcattrs.py b/lib-python/2.7/lib2to3/fixes/fix_funcattrs.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_funcattrs.py
rename to lib-python/2.7/lib2to3/fixes/fix_funcattrs.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_future.py b/lib-python/2.7/lib2to3/fixes/fix_future.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_future.py
rename to lib-python/2.7/lib2to3/fixes/fix_future.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_getcwdu.py b/lib-python/2.7/lib2to3/fixes/fix_getcwdu.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_getcwdu.py
rename to lib-python/2.7/lib2to3/fixes/fix_getcwdu.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_has_key.py b/lib-python/2.7/lib2to3/fixes/fix_has_key.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_has_key.py
rename to lib-python/2.7/lib2to3/fixes/fix_has_key.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_idioms.py b/lib-python/2.7/lib2to3/fixes/fix_idioms.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_idioms.py
rename to lib-python/2.7/lib2to3/fixes/fix_idioms.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_import.py b/lib-python/2.7/lib2to3/fixes/fix_import.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_import.py
rename to lib-python/2.7/lib2to3/fixes/fix_import.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_imports.py b/lib-python/2.7/lib2to3/fixes/fix_imports.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_imports.py
rename to lib-python/2.7/lib2to3/fixes/fix_imports.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_imports2.py b/lib-python/2.7/lib2to3/fixes/fix_imports2.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_imports2.py
rename to lib-python/2.7/lib2to3/fixes/fix_imports2.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_input.py b/lib-python/2.7/lib2to3/fixes/fix_input.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_input.py
rename to lib-python/2.7/lib2to3/fixes/fix_input.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_intern.py b/lib-python/2.7/lib2to3/fixes/fix_intern.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_intern.py
rename to lib-python/2.7/lib2to3/fixes/fix_intern.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_isinstance.py b/lib-python/2.7/lib2to3/fixes/fix_isinstance.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_isinstance.py
rename to lib-python/2.7/lib2to3/fixes/fix_isinstance.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_itertools.py b/lib-python/2.7/lib2to3/fixes/fix_itertools.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_itertools.py
rename to lib-python/2.7/lib2to3/fixes/fix_itertools.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_itertools_imports.py b/lib-python/2.7/lib2to3/fixes/fix_itertools_imports.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_itertools_imports.py
rename to lib-python/2.7/lib2to3/fixes/fix_itertools_imports.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_long.py b/lib-python/2.7/lib2to3/fixes/fix_long.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_long.py
rename to lib-python/2.7/lib2to3/fixes/fix_long.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_map.py b/lib-python/2.7/lib2to3/fixes/fix_map.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_map.py
rename to lib-python/2.7/lib2to3/fixes/fix_map.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_metaclass.py b/lib-python/2.7/lib2to3/fixes/fix_metaclass.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_metaclass.py
rename to lib-python/2.7/lib2to3/fixes/fix_metaclass.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_methodattrs.py b/lib-python/2.7/lib2to3/fixes/fix_methodattrs.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_methodattrs.py
rename to lib-python/2.7/lib2to3/fixes/fix_methodattrs.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_ne.py b/lib-python/2.7/lib2to3/fixes/fix_ne.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_ne.py
rename to lib-python/2.7/lib2to3/fixes/fix_ne.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_next.py b/lib-python/2.7/lib2to3/fixes/fix_next.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_next.py
rename to lib-python/2.7/lib2to3/fixes/fix_next.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_nonzero.py b/lib-python/2.7/lib2to3/fixes/fix_nonzero.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_nonzero.py
rename to lib-python/2.7/lib2to3/fixes/fix_nonzero.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_numliterals.py b/lib-python/2.7/lib2to3/fixes/fix_numliterals.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_numliterals.py
rename to lib-python/2.7/lib2to3/fixes/fix_numliterals.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_operator.py b/lib-python/2.7/lib2to3/fixes/fix_operator.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_operator.py
rename to lib-python/2.7/lib2to3/fixes/fix_operator.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_paren.py b/lib-python/2.7/lib2to3/fixes/fix_paren.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_paren.py
rename to lib-python/2.7/lib2to3/fixes/fix_paren.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_print.py b/lib-python/2.7/lib2to3/fixes/fix_print.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_print.py
rename to lib-python/2.7/lib2to3/fixes/fix_print.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_raise.py b/lib-python/2.7/lib2to3/fixes/fix_raise.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_raise.py
rename to lib-python/2.7/lib2to3/fixes/fix_raise.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_raw_input.py b/lib-python/2.7/lib2to3/fixes/fix_raw_input.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_raw_input.py
rename to lib-python/2.7/lib2to3/fixes/fix_raw_input.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_reduce.py b/lib-python/2.7/lib2to3/fixes/fix_reduce.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_reduce.py
rename to lib-python/2.7/lib2to3/fixes/fix_reduce.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_renames.py b/lib-python/2.7/lib2to3/fixes/fix_renames.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_renames.py
rename to lib-python/2.7/lib2to3/fixes/fix_renames.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_repr.py b/lib-python/2.7/lib2to3/fixes/fix_repr.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_repr.py
rename to lib-python/2.7/lib2to3/fixes/fix_repr.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_set_literal.py b/lib-python/2.7/lib2to3/fixes/fix_set_literal.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_set_literal.py
rename to lib-python/2.7/lib2to3/fixes/fix_set_literal.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_standarderror.py b/lib-python/2.7/lib2to3/fixes/fix_standarderror.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_standarderror.py
rename to lib-python/2.7/lib2to3/fixes/fix_standarderror.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_sys_exc.py b/lib-python/2.7/lib2to3/fixes/fix_sys_exc.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_sys_exc.py
rename to lib-python/2.7/lib2to3/fixes/fix_sys_exc.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_throw.py b/lib-python/2.7/lib2to3/fixes/fix_throw.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_throw.py
rename to lib-python/2.7/lib2to3/fixes/fix_throw.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_tuple_params.py b/lib-python/2.7/lib2to3/fixes/fix_tuple_params.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_tuple_params.py
rename to lib-python/2.7/lib2to3/fixes/fix_tuple_params.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_types.py b/lib-python/2.7/lib2to3/fixes/fix_types.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_types.py
rename to lib-python/2.7/lib2to3/fixes/fix_types.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_unicode.py b/lib-python/2.7/lib2to3/fixes/fix_unicode.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_unicode.py
rename to lib-python/2.7/lib2to3/fixes/fix_unicode.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_urllib.py b/lib-python/2.7/lib2to3/fixes/fix_urllib.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_urllib.py
rename to lib-python/2.7/lib2to3/fixes/fix_urllib.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_ws_comma.py b/lib-python/2.7/lib2to3/fixes/fix_ws_comma.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_ws_comma.py
rename to lib-python/2.7/lib2to3/fixes/fix_ws_comma.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_xrange.py b/lib-python/2.7/lib2to3/fixes/fix_xrange.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_xrange.py
rename to lib-python/2.7/lib2to3/fixes/fix_xrange.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_xreadlines.py b/lib-python/2.7/lib2to3/fixes/fix_xreadlines.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_xreadlines.py
rename to lib-python/2.7/lib2to3/fixes/fix_xreadlines.py
diff --git a/lib-python/2.7.0/lib2to3/fixes/fix_zip.py b/lib-python/2.7/lib2to3/fixes/fix_zip.py
rename from lib-python/2.7.0/lib2to3/fixes/fix_zip.py
rename to lib-python/2.7/lib2to3/fixes/fix_zip.py
diff --git a/lib-python/2.7.0/lib2to3/main.py b/lib-python/2.7/lib2to3/main.py
rename from lib-python/2.7.0/lib2to3/main.py
rename to lib-python/2.7/lib2to3/main.py
diff --git a/lib-python/2.7.0/lib2to3/patcomp.py b/lib-python/2.7/lib2to3/patcomp.py
rename from lib-python/2.7.0/lib2to3/patcomp.py
rename to lib-python/2.7/lib2to3/patcomp.py
diff --git a/lib-python/2.7.0/lib2to3/pgen2/__init__.py b/lib-python/2.7/lib2to3/pgen2/__init__.py
rename from lib-python/2.7.0/lib2to3/pgen2/__init__.py
rename to lib-python/2.7/lib2to3/pgen2/__init__.py
diff --git a/lib-python/2.7.0/lib2to3/pgen2/conv.py b/lib-python/2.7/lib2to3/pgen2/conv.py
rename from lib-python/2.7.0/lib2to3/pgen2/conv.py
rename to lib-python/2.7/lib2to3/pgen2/conv.py
diff --git a/lib-python/2.7.0/lib2to3/pgen2/driver.py b/lib-python/2.7/lib2to3/pgen2/driver.py
rename from lib-python/2.7.0/lib2to3/pgen2/driver.py
rename to lib-python/2.7/lib2to3/pgen2/driver.py
diff --git a/lib-python/2.7.0/lib2to3/pgen2/grammar.py b/lib-python/2.7/lib2to3/pgen2/grammar.py
rename from lib-python/2.7.0/lib2to3/pgen2/grammar.py
rename to lib-python/2.7/lib2to3/pgen2/grammar.py
diff --git a/lib-python/2.7.0/lib2to3/pgen2/literals.py b/lib-python/2.7/lib2to3/pgen2/literals.py
rename from lib-python/2.7.0/lib2to3/pgen2/literals.py
rename to lib-python/2.7/lib2to3/pgen2/literals.py
diff --git a/lib-python/2.7.0/lib2to3/pgen2/parse.py b/lib-python/2.7/lib2to3/pgen2/parse.py
rename from lib-python/2.7.0/lib2to3/pgen2/parse.py
rename to lib-python/2.7/lib2to3/pgen2/parse.py
diff --git a/lib-python/2.7.0/lib2to3/pgen2/pgen.py b/lib-python/2.7/lib2to3/pgen2/pgen.py
rename from lib-python/2.7.0/lib2to3/pgen2/pgen.py
rename to lib-python/2.7/lib2to3/pgen2/pgen.py
diff --git a/lib-python/2.7.0/lib2to3/pgen2/token.py b/lib-python/2.7/lib2to3/pgen2/token.py
rename from lib-python/2.7.0/lib2to3/pgen2/token.py
rename to lib-python/2.7/lib2to3/pgen2/token.py
diff --git a/lib-python/2.7.0/lib2to3/pgen2/tokenize.py b/lib-python/2.7/lib2to3/pgen2/tokenize.py
rename from lib-python/2.7.0/lib2to3/pgen2/tokenize.py
rename to lib-python/2.7/lib2to3/pgen2/tokenize.py
diff --git a/lib-python/2.7.0/lib2to3/pygram.py b/lib-python/2.7/lib2to3/pygram.py
rename from lib-python/2.7.0/lib2to3/pygram.py
rename to lib-python/2.7/lib2to3/pygram.py
diff --git a/lib-python/2.7.0/lib2to3/pytree.py b/lib-python/2.7/lib2to3/pytree.py
rename from lib-python/2.7.0/lib2to3/pytree.py
rename to lib-python/2.7/lib2to3/pytree.py
diff --git a/lib-python/2.7.0/lib2to3/refactor.py b/lib-python/2.7/lib2to3/refactor.py
rename from lib-python/2.7.0/lib2to3/refactor.py
rename to lib-python/2.7/lib2to3/refactor.py
diff --git a/lib-python/2.7.0/lib2to3/tests/__init__.py b/lib-python/2.7/lib2to3/tests/__init__.py
rename from lib-python/2.7.0/lib2to3/tests/__init__.py
rename to lib-python/2.7/lib2to3/tests/__init__.py
diff --git a/lib-python/2.7.0/lib2to3/tests/data/README b/lib-python/2.7/lib2to3/tests/data/README
rename from lib-python/2.7.0/lib2to3/tests/data/README
rename to lib-python/2.7/lib2to3/tests/data/README
diff --git a/lib-python/2.7.0/lib2to3/tests/data/bom.py b/lib-python/2.7/lib2to3/tests/data/bom.py
rename from lib-python/2.7.0/lib2to3/tests/data/bom.py
rename to lib-python/2.7/lib2to3/tests/data/bom.py
diff --git a/lib-python/2.7.0/lib2to3/tests/data/crlf.py b/lib-python/2.7/lib2to3/tests/data/crlf.py
rename from lib-python/2.7.0/lib2to3/tests/data/crlf.py
rename to lib-python/2.7/lib2to3/tests/data/crlf.py
diff --git a/lib-python/2.7.0/lib2to3/tests/data/different_encoding.py b/lib-python/2.7/lib2to3/tests/data/different_encoding.py
rename from lib-python/2.7.0/lib2to3/tests/data/different_encoding.py
rename to lib-python/2.7/lib2to3/tests/data/different_encoding.py
diff --git a/lib-python/2.7.0/lib2to3/tests/data/fixers/bad_order.py b/lib-python/2.7/lib2to3/tests/data/fixers/bad_order.py
rename from lib-python/2.7.0/lib2to3/tests/data/fixers/bad_order.py
rename to lib-python/2.7/lib2to3/tests/data/fixers/bad_order.py
diff --git a/lib-python/2.7.0/lib2to3/tests/data/fixers/myfixes/__init__.py b/lib-python/2.7/lib2to3/tests/data/fixers/myfixes/__init__.py
rename from lib-python/2.7.0/lib2to3/tests/data/fixers/myfixes/__init__.py
rename to lib-python/2.7/lib2to3/tests/data/fixers/myfixes/__init__.py
diff --git a/lib-python/2.7.0/lib2to3/tests/data/fixers/myfixes/fix_explicit.py b/lib-python/2.7/lib2to3/tests/data/fixers/myfixes/fix_explicit.py
rename from lib-python/2.7.0/lib2to3/tests/data/fixers/myfixes/fix_explicit.py
rename to lib-python/2.7/lib2to3/tests/data/fixers/myfixes/fix_explicit.py
diff --git a/lib-python/2.7.0/lib2to3/tests/data/fixers/myfixes/fix_first.py b/lib-python/2.7/lib2to3/tests/data/fixers/myfixes/fix_first.py
rename from lib-python/2.7.0/lib2to3/tests/data/fixers/myfixes/fix_first.py
rename to lib-python/2.7/lib2to3/tests/data/fixers/myfixes/fix_first.py
diff --git a/lib-python/2.7.0/lib2to3/tests/data/fixers/myfixes/fix_last.py b/lib-python/2.7/lib2to3/tests/data/fixers/myfixes/fix_last.py
rename from lib-python/2.7.0/lib2to3/tests/data/fixers/myfixes/fix_last.py
rename to lib-python/2.7/lib2to3/tests/data/fixers/myfixes/fix_last.py
diff --git a/lib-python/2.7.0/lib2to3/tests/data/fixers/myfixes/fix_parrot.py b/lib-python/2.7/lib2to3/tests/data/fixers/myfixes/fix_parrot.py
rename from lib-python/2.7.0/lib2to3/tests/data/fixers/myfixes/fix_parrot.py
rename to lib-python/2.7/lib2to3/tests/data/fixers/myfixes/fix_parrot.py
diff --git a/lib-python/2.7.0/lib2to3/tests/data/fixers/myfixes/fix_preorder.py b/lib-python/2.7/lib2to3/tests/data/fixers/myfixes/fix_preorder.py
rename from lib-python/2.7.0/lib2to3/tests/data/fixers/myfixes/fix_preorder.py
rename to lib-python/2.7/lib2to3/tests/data/fixers/myfixes/fix_preorder.py
diff --git a/lib-python/2.7.0/lib2to3/tests/data/fixers/no_fixer_cls.py b/lib-python/2.7/lib2to3/tests/data/fixers/no_fixer_cls.py
rename from lib-python/2.7.0/lib2to3/tests/data/fixers/no_fixer_cls.py
rename to lib-python/2.7/lib2to3/tests/data/fixers/no_fixer_cls.py
diff --git a/lib-python/2.7.0/lib2to3/tests/data/fixers/parrot_example.py b/lib-python/2.7/lib2to3/tests/data/fixers/parrot_example.py
rename from lib-python/2.7.0/lib2to3/tests/data/fixers/parrot_example.py
rename to lib-python/2.7/lib2to3/tests/data/fixers/parrot_example.py
diff --git a/lib-python/2.7.0/lib2to3/tests/data/infinite_recursion.py b/lib-python/2.7/lib2to3/tests/data/infinite_recursion.py
rename from lib-python/2.7.0/lib2to3/tests/data/infinite_recursion.py
rename to lib-python/2.7/lib2to3/tests/data/infinite_recursion.py
diff --git a/lib-python/2.7.0/lib2to3/tests/data/py2_test_grammar.py b/lib-python/2.7/lib2to3/tests/data/py2_test_grammar.py
rename from lib-python/2.7.0/lib2to3/tests/data/py2_test_grammar.py
rename to lib-python/2.7/lib2to3/tests/data/py2_test_grammar.py
diff --git a/lib-python/2.7.0/lib2to3/tests/data/py3_test_grammar.py b/lib-python/2.7/lib2to3/tests/data/py3_test_grammar.py
rename from lib-python/2.7.0/lib2to3/tests/data/py3_test_grammar.py
rename to lib-python/2.7/lib2to3/tests/data/py3_test_grammar.py
diff --git a/lib-python/2.7.0/lib2to3/tests/pytree_idempotency.py b/lib-python/2.7/lib2to3/tests/pytree_idempotency.py
rename from lib-python/2.7.0/lib2to3/tests/pytree_idempotency.py
rename to lib-python/2.7/lib2to3/tests/pytree_idempotency.py
diff --git a/lib-python/2.7.0/lib2to3/tests/support.py b/lib-python/2.7/lib2to3/tests/support.py
rename from lib-python/2.7.0/lib2to3/tests/support.py
rename to lib-python/2.7/lib2to3/tests/support.py
diff --git a/lib-python/2.7.0/lib2to3/tests/test_all_fixers.py b/lib-python/2.7/lib2to3/tests/test_all_fixers.py
rename from lib-python/2.7.0/lib2to3/tests/test_all_fixers.py
rename to lib-python/2.7/lib2to3/tests/test_all_fixers.py
diff --git a/lib-python/2.7.0/lib2to3/tests/test_fixers.py b/lib-python/2.7/lib2to3/tests/test_fixers.py
rename from lib-python/2.7.0/lib2to3/tests/test_fixers.py
rename to lib-python/2.7/lib2to3/tests/test_fixers.py
diff --git a/lib-python/2.7.0/lib2to3/tests/test_main.py b/lib-python/2.7/lib2to3/tests/test_main.py
rename from lib-python/2.7.0/lib2to3/tests/test_main.py
rename to lib-python/2.7/lib2to3/tests/test_main.py
diff --git a/lib-python/2.7.0/lib2to3/tests/test_parser.py b/lib-python/2.7/lib2to3/tests/test_parser.py
rename from lib-python/2.7.0/lib2to3/tests/test_parser.py
rename to lib-python/2.7/lib2to3/tests/test_parser.py
diff --git a/lib-python/2.7.0/lib2to3/tests/test_pytree.py b/lib-python/2.7/lib2to3/tests/test_pytree.py
rename from lib-python/2.7.0/lib2to3/tests/test_pytree.py
rename to lib-python/2.7/lib2to3/tests/test_pytree.py
diff --git a/lib-python/2.7.0/lib2to3/tests/test_refactor.py b/lib-python/2.7/lib2to3/tests/test_refactor.py
rename from lib-python/2.7.0/lib2to3/tests/test_refactor.py
rename to lib-python/2.7/lib2to3/tests/test_refactor.py
diff --git a/lib-python/2.7.0/lib2to3/tests/test_util.py b/lib-python/2.7/lib2to3/tests/test_util.py
rename from lib-python/2.7.0/lib2to3/tests/test_util.py
rename to lib-python/2.7/lib2to3/tests/test_util.py
diff --git a/lib-python/2.7.0/linecache.py b/lib-python/2.7/linecache.py
rename from lib-python/2.7.0/linecache.py
rename to lib-python/2.7/linecache.py
diff --git a/lib-python/2.7.0/locale.py b/lib-python/2.7/locale.py
rename from lib-python/2.7.0/locale.py
rename to lib-python/2.7/locale.py
diff --git a/lib-python/2.7.0/logging/__init__.py b/lib-python/2.7/logging/__init__.py
rename from lib-python/2.7.0/logging/__init__.py
rename to lib-python/2.7/logging/__init__.py
diff --git a/lib-python/2.7.0/logging/config.py b/lib-python/2.7/logging/config.py
rename from lib-python/2.7.0/logging/config.py
rename to lib-python/2.7/logging/config.py
diff --git a/lib-python/2.7.0/logging/handlers.py b/lib-python/2.7/logging/handlers.py
rename from lib-python/2.7.0/logging/handlers.py
rename to lib-python/2.7/logging/handlers.py
diff --git a/lib-python/2.7.0/macpath.py b/lib-python/2.7/macpath.py
rename from lib-python/2.7.0/macpath.py
rename to lib-python/2.7/macpath.py
diff --git a/lib-python/2.7.0/macurl2path.py b/lib-python/2.7/macurl2path.py
rename from lib-python/2.7.0/macurl2path.py
rename to lib-python/2.7/macurl2path.py
diff --git a/lib-python/2.7.0/mailbox.py b/lib-python/2.7/mailbox.py
rename from lib-python/2.7.0/mailbox.py
rename to lib-python/2.7/mailbox.py
diff --git a/lib-python/2.7.0/mailcap.py b/lib-python/2.7/mailcap.py
rename from lib-python/2.7.0/mailcap.py
rename to lib-python/2.7/mailcap.py
diff --git a/lib-python/2.7.0/markupbase.py b/lib-python/2.7/markupbase.py
rename from lib-python/2.7.0/markupbase.py
rename to lib-python/2.7/markupbase.py
diff --git a/lib-python/2.7.0/md5.py b/lib-python/2.7/md5.py
rename from lib-python/2.7.0/md5.py
rename to lib-python/2.7/md5.py
--- a/lib-python/2.7.0/md5.py
+++ b/lib-python/2.7/md5.py
@@ -1,4 +1,4 @@
-# $Id: md5.py 58064 2007-09-09 20:25:00Z gregory.p.smith $
+# $Id$
 #
 #  Copyright (C) 2005   Gregory P. Smith (greg at krypto.org)
 #  Licensed to PSF under a Contributor Agreement.
diff --git a/lib-python/2.7.0/mhlib.py b/lib-python/2.7/mhlib.py
rename from lib-python/2.7.0/mhlib.py
rename to lib-python/2.7/mhlib.py
diff --git a/lib-python/2.7.0/mimetools.py b/lib-python/2.7/mimetools.py
rename from lib-python/2.7.0/mimetools.py
rename to lib-python/2.7/mimetools.py
diff --git a/lib-python/2.7.0/mimetypes.py b/lib-python/2.7/mimetypes.py
rename from lib-python/2.7.0/mimetypes.py
rename to lib-python/2.7/mimetypes.py
diff --git a/lib-python/2.7.0/mimify.py b/lib-python/2.7/mimify.py
rename from lib-python/2.7.0/mimify.py
rename to lib-python/2.7/mimify.py
diff --git a/lib-python/2.7.0/modulefinder.py b/lib-python/2.7/modulefinder.py
rename from lib-python/2.7.0/modulefinder.py
rename to lib-python/2.7/modulefinder.py
diff --git a/lib-python/2.7.0/msilib/__init__.py b/lib-python/2.7/msilib/__init__.py
rename from lib-python/2.7.0/msilib/__init__.py
rename to lib-python/2.7/msilib/__init__.py
diff --git a/lib-python/2.7.0/msilib/schema.py b/lib-python/2.7/msilib/schema.py
rename from lib-python/2.7.0/msilib/schema.py
rename to lib-python/2.7/msilib/schema.py
diff --git a/lib-python/2.7.0/msilib/sequence.py b/lib-python/2.7/msilib/sequence.py
rename from lib-python/2.7.0/msilib/sequence.py
rename to lib-python/2.7/msilib/sequence.py
diff --git a/lib-python/2.7.0/msilib/text.py b/lib-python/2.7/msilib/text.py
rename from lib-python/2.7.0/msilib/text.py
rename to lib-python/2.7/msilib/text.py
diff --git a/lib-python/2.7.0/multifile.py b/lib-python/2.7/multifile.py
rename from lib-python/2.7.0/multifile.py
rename to lib-python/2.7/multifile.py
diff --git a/lib-python/2.7.0/multiprocessing/__init__.py b/lib-python/2.7/multiprocessing/__init__.py
rename from lib-python/2.7.0/multiprocessing/__init__.py
rename to lib-python/2.7/multiprocessing/__init__.py
diff --git a/lib-python/2.7.0/multiprocessing/connection.py b/lib-python/2.7/multiprocessing/connection.py
rename from lib-python/2.7.0/multiprocessing/connection.py
rename to lib-python/2.7/multiprocessing/connection.py
diff --git a/lib-python/2.7.0/multiprocessing/dummy/__init__.py b/lib-python/2.7/multiprocessing/dummy/__init__.py
rename from lib-python/2.7.0/multiprocessing/dummy/__init__.py
rename to lib-python/2.7/multiprocessing/dummy/__init__.py
diff --git a/lib-python/2.7.0/multiprocessing/dummy/connection.py b/lib-python/2.7/multiprocessing/dummy/connection.py
rename from lib-python/2.7.0/multiprocessing/dummy/connection.py
rename to lib-python/2.7/multiprocessing/dummy/connection.py
diff --git a/lib-python/2.7.0/multiprocessing/forking.py b/lib-python/2.7/multiprocessing/forking.py
rename from lib-python/2.7.0/multiprocessing/forking.py
rename to lib-python/2.7/multiprocessing/forking.py
diff --git a/lib-python/2.7.0/multiprocessing/heap.py b/lib-python/2.7/multiprocessing/heap.py
rename from lib-python/2.7.0/multiprocessing/heap.py
rename to lib-python/2.7/multiprocessing/heap.py
diff --git a/lib-python/2.7.0/multiprocessing/managers.py b/lib-python/2.7/multiprocessing/managers.py
rename from lib-python/2.7.0/multiprocessing/managers.py
rename to lib-python/2.7/multiprocessing/managers.py
diff --git a/lib-python/2.7.0/multiprocessing/pool.py b/lib-python/2.7/multiprocessing/pool.py
rename from lib-python/2.7.0/multiprocessing/pool.py
rename to lib-python/2.7/multiprocessing/pool.py
diff --git a/lib-python/2.7.0/multiprocessing/process.py b/lib-python/2.7/multiprocessing/process.py
rename from lib-python/2.7.0/multiprocessing/process.py
rename to lib-python/2.7/multiprocessing/process.py
diff --git a/lib-python/2.7.0/multiprocessing/queues.py b/lib-python/2.7/multiprocessing/queues.py
rename from lib-python/2.7.0/multiprocessing/queues.py
rename to lib-python/2.7/multiprocessing/queues.py
diff --git a/lib-python/2.7.0/multiprocessing/reduction.py b/lib-python/2.7/multiprocessing/reduction.py
rename from lib-python/2.7.0/multiprocessing/reduction.py
rename to lib-python/2.7/multiprocessing/reduction.py
diff --git a/lib-python/2.7.0/multiprocessing/sharedctypes.py b/lib-python/2.7/multiprocessing/sharedctypes.py
rename from lib-python/2.7.0/multiprocessing/sharedctypes.py
rename to lib-python/2.7/multiprocessing/sharedctypes.py
diff --git a/lib-python/2.7.0/multiprocessing/synchronize.py b/lib-python/2.7/multiprocessing/synchronize.py
rename from lib-python/2.7.0/multiprocessing/synchronize.py
rename to lib-python/2.7/multiprocessing/synchronize.py
diff --git a/lib-python/2.7.0/multiprocessing/util.py b/lib-python/2.7/multiprocessing/util.py
rename from lib-python/2.7.0/multiprocessing/util.py
rename to lib-python/2.7/multiprocessing/util.py
diff --git a/lib-python/2.7.0/mutex.py b/lib-python/2.7/mutex.py
rename from lib-python/2.7.0/mutex.py
rename to lib-python/2.7/mutex.py
diff --git a/lib-python/2.7.0/netrc.py b/lib-python/2.7/netrc.py
rename from lib-python/2.7.0/netrc.py
rename to lib-python/2.7/netrc.py
diff --git a/lib-python/2.7.0/new.py b/lib-python/2.7/new.py
rename from lib-python/2.7.0/new.py
rename to lib-python/2.7/new.py
diff --git a/lib-python/2.7.0/nntplib.py b/lib-python/2.7/nntplib.py
rename from lib-python/2.7.0/nntplib.py
rename to lib-python/2.7/nntplib.py
diff --git a/lib-python/2.7.0/ntpath.py b/lib-python/2.7/ntpath.py
rename from lib-python/2.7.0/ntpath.py
rename to lib-python/2.7/ntpath.py
diff --git a/lib-python/2.7.0/nturl2path.py b/lib-python/2.7/nturl2path.py
rename from lib-python/2.7.0/nturl2path.py
rename to lib-python/2.7/nturl2path.py
diff --git a/lib-python/2.7.0/numbers.py b/lib-python/2.7/numbers.py
rename from lib-python/2.7.0/numbers.py
rename to lib-python/2.7/numbers.py
diff --git a/lib-python/2.7.0/opcode.py b/lib-python/2.7/opcode.py
rename from lib-python/2.7.0/opcode.py
rename to lib-python/2.7/opcode.py
diff --git a/lib-python/2.7.0/optparse.py b/lib-python/2.7/optparse.py
rename from lib-python/2.7.0/optparse.py
rename to lib-python/2.7/optparse.py
diff --git a/lib-python/2.7.0/os.py b/lib-python/2.7/os.py
rename from lib-python/2.7.0/os.py
rename to lib-python/2.7/os.py
diff --git a/lib-python/2.7.0/os2emxpath.py b/lib-python/2.7/os2emxpath.py
rename from lib-python/2.7.0/os2emxpath.py
rename to lib-python/2.7/os2emxpath.py
diff --git a/lib-python/2.7.0/pdb.doc b/lib-python/2.7/pdb.doc
rename from lib-python/2.7.0/pdb.doc
rename to lib-python/2.7/pdb.doc
diff --git a/lib-python/2.7.0/pdb.py b/lib-python/2.7/pdb.py
rename from lib-python/2.7.0/pdb.py
rename to lib-python/2.7/pdb.py
diff --git a/lib-python/2.7.0/pickle.py b/lib-python/2.7/pickle.py
rename from lib-python/2.7.0/pickle.py
rename to lib-python/2.7/pickle.py
--- a/lib-python/2.7.0/pickle.py
+++ b/lib-python/2.7/pickle.py
@@ -24,7 +24,7 @@
 
 """
 
-__version__ = "$Revision: 72223 $"       # Code version
+__version__ = "$Revision$"       # Code version
 
 from types import *
 from copy_reg import dispatch_table
diff --git a/lib-python/2.7.0/pickletools.py b/lib-python/2.7/pickletools.py
rename from lib-python/2.7.0/pickletools.py
rename to lib-python/2.7/pickletools.py
diff --git a/lib-python/2.7.0/pipes.py b/lib-python/2.7/pipes.py
rename from lib-python/2.7.0/pipes.py
rename to lib-python/2.7/pipes.py
diff --git a/lib-python/2.7.0/pkgutil.py b/lib-python/2.7/pkgutil.py
rename from lib-python/2.7.0/pkgutil.py
rename to lib-python/2.7/pkgutil.py
diff --git a/lib-python/2.7.0/plat-aix3/IN.py b/lib-python/2.7/plat-aix3/IN.py
rename from lib-python/2.7.0/plat-aix3/IN.py
rename to lib-python/2.7/plat-aix3/IN.py
diff --git a/lib-python/2.7.0/plat-aix3/regen b/lib-python/2.7/plat-aix3/regen
rename from lib-python/2.7.0/plat-aix3/regen
rename to lib-python/2.7/plat-aix3/regen
diff --git a/lib-python/2.7.0/plat-aix4/IN.py b/lib-python/2.7/plat-aix4/IN.py
rename from lib-python/2.7.0/plat-aix4/IN.py
rename to lib-python/2.7/plat-aix4/IN.py
diff --git a/lib-python/2.7.0/plat-aix4/regen b/lib-python/2.7/plat-aix4/regen
rename from lib-python/2.7.0/plat-aix4/regen
rename to lib-python/2.7/plat-aix4/regen
diff --git a/lib-python/2.7.0/plat-atheos/IN.py b/lib-python/2.7/plat-atheos/IN.py
rename from lib-python/2.7.0/plat-atheos/IN.py
rename to lib-python/2.7/plat-atheos/IN.py
diff --git a/lib-python/2.7.0/plat-atheos/TYPES.py b/lib-python/2.7/plat-atheos/TYPES.py
rename from lib-python/2.7.0/plat-atheos/TYPES.py
rename to lib-python/2.7/plat-atheos/TYPES.py
diff --git a/lib-python/2.7.0/plat-atheos/regen b/lib-python/2.7/plat-atheos/regen
rename from lib-python/2.7.0/plat-atheos/regen
rename to lib-python/2.7/plat-atheos/regen
diff --git a/lib-python/2.7.0/plat-beos5/IN.py b/lib-python/2.7/plat-beos5/IN.py
rename from lib-python/2.7.0/plat-beos5/IN.py
rename to lib-python/2.7/plat-beos5/IN.py
diff --git a/lib-python/2.7.0/plat-beos5/regen b/lib-python/2.7/plat-beos5/regen
rename from lib-python/2.7.0/plat-beos5/regen
rename to lib-python/2.7/plat-beos5/regen
diff --git a/lib-python/2.7.0/plat-darwin/IN.py b/lib-python/2.7/plat-darwin/IN.py
rename from lib-python/2.7.0/plat-darwin/IN.py
rename to lib-python/2.7/plat-darwin/IN.py
diff --git a/lib-python/2.7.0/plat-darwin/regen b/lib-python/2.7/plat-darwin/regen
rename from lib-python/2.7.0/plat-darwin/regen
rename to lib-python/2.7/plat-darwin/regen
diff --git a/lib-python/2.7.0/plat-freebsd4/IN.py b/lib-python/2.7/plat-freebsd4/IN.py
rename from lib-python/2.7.0/plat-freebsd4/IN.py
rename to lib-python/2.7/plat-freebsd4/IN.py
diff --git a/lib-python/2.7.0/plat-freebsd4/regen b/lib-python/2.7/plat-freebsd4/regen
rename from lib-python/2.7.0/plat-freebsd4/regen
rename to lib-python/2.7/plat-freebsd4/regen
diff --git a/lib-python/2.7.0/plat-freebsd5/IN.py b/lib-python/2.7/plat-freebsd5/IN.py
rename from lib-python/2.7.0/plat-freebsd5/IN.py
rename to lib-python/2.7/plat-freebsd5/IN.py
diff --git a/lib-python/2.7.0/plat-freebsd5/regen b/lib-python/2.7/plat-freebsd5/regen
rename from lib-python/2.7.0/plat-freebsd5/regen
rename to lib-python/2.7/plat-freebsd5/regen
diff --git a/lib-python/2.7.0/plat-freebsd6/IN.py b/lib-python/2.7/plat-freebsd6/IN.py
rename from lib-python/2.7.0/plat-freebsd6/IN.py
rename to lib-python/2.7/plat-freebsd6/IN.py
diff --git a/lib-python/2.7.0/plat-freebsd6/regen b/lib-python/2.7/plat-freebsd6/regen
rename from lib-python/2.7.0/plat-freebsd6/regen
rename to lib-python/2.7/plat-freebsd6/regen
diff --git a/lib-python/2.7.0/plat-freebsd7/IN.py b/lib-python/2.7/plat-freebsd7/IN.py
rename from lib-python/2.7.0/plat-freebsd7/IN.py
rename to lib-python/2.7/plat-freebsd7/IN.py
diff --git a/lib-python/2.7.0/plat-freebsd7/regen b/lib-python/2.7/plat-freebsd7/regen
rename from lib-python/2.7.0/plat-freebsd7/regen
rename to lib-python/2.7/plat-freebsd7/regen
diff --git a/lib-python/2.7.0/plat-freebsd8/IN.py b/lib-python/2.7/plat-freebsd8/IN.py
rename from lib-python/2.7.0/plat-freebsd8/IN.py
rename to lib-python/2.7/plat-freebsd8/IN.py
diff --git a/lib-python/2.7.0/plat-freebsd8/regen b/lib-python/2.7/plat-freebsd8/regen
rename from lib-python/2.7.0/plat-freebsd8/regen
rename to lib-python/2.7/plat-freebsd8/regen
diff --git a/lib-python/2.7.0/plat-generic/regen b/lib-python/2.7/plat-generic/regen
rename from lib-python/2.7.0/plat-generic/regen
rename to lib-python/2.7/plat-generic/regen
diff --git a/lib-python/2.7.0/plat-irix5/AL.py b/lib-python/2.7/plat-irix5/AL.py
rename from lib-python/2.7.0/plat-irix5/AL.py
rename to lib-python/2.7/plat-irix5/AL.py
diff --git a/lib-python/2.7.0/plat-irix5/CD.py b/lib-python/2.7/plat-irix5/CD.py
rename from lib-python/2.7.0/plat-irix5/CD.py
rename to lib-python/2.7/plat-irix5/CD.py
diff --git a/lib-python/2.7.0/plat-irix5/CL.py b/lib-python/2.7/plat-irix5/CL.py
rename from lib-python/2.7.0/plat-irix5/CL.py
rename to lib-python/2.7/plat-irix5/CL.py
diff --git a/lib-python/2.7.0/plat-irix5/CL_old.py b/lib-python/2.7/plat-irix5/CL_old.py
rename from lib-python/2.7.0/plat-irix5/CL_old.py
rename to lib-python/2.7/plat-irix5/CL_old.py
diff --git a/lib-python/2.7.0/plat-irix5/DEVICE.py b/lib-python/2.7/plat-irix5/DEVICE.py
rename from lib-python/2.7.0/plat-irix5/DEVICE.py
rename to lib-python/2.7/plat-irix5/DEVICE.py
diff --git a/lib-python/2.7.0/plat-irix5/ERRNO.py b/lib-python/2.7/plat-irix5/ERRNO.py
rename from lib-python/2.7.0/plat-irix5/ERRNO.py
rename to lib-python/2.7/plat-irix5/ERRNO.py
diff --git a/lib-python/2.7.0/plat-irix5/FILE.py b/lib-python/2.7/plat-irix5/FILE.py
rename from lib-python/2.7.0/plat-irix5/FILE.py
rename to lib-python/2.7/plat-irix5/FILE.py
diff --git a/lib-python/2.7.0/plat-irix5/FL.py b/lib-python/2.7/plat-irix5/FL.py
rename from lib-python/2.7.0/plat-irix5/FL.py
rename to lib-python/2.7/plat-irix5/FL.py
diff --git a/lib-python/2.7.0/plat-irix5/GET.py b/lib-python/2.7/plat-irix5/GET.py
rename from lib-python/2.7.0/plat-irix5/GET.py
rename to lib-python/2.7/plat-irix5/GET.py
diff --git a/lib-python/2.7.0/plat-irix5/GL.py b/lib-python/2.7/plat-irix5/GL.py
rename from lib-python/2.7.0/plat-irix5/GL.py
rename to lib-python/2.7/plat-irix5/GL.py
diff --git a/lib-python/2.7.0/plat-irix5/GLWS.py b/lib-python/2.7/plat-irix5/GLWS.py
rename from lib-python/2.7.0/plat-irix5/GLWS.py
rename to lib-python/2.7/plat-irix5/GLWS.py
diff --git a/lib-python/2.7.0/plat-irix5/IN.py b/lib-python/2.7/plat-irix5/IN.py
rename from lib-python/2.7.0/plat-irix5/IN.py
rename to lib-python/2.7/plat-irix5/IN.py
diff --git a/lib-python/2.7.0/plat-irix5/IOCTL.py b/lib-python/2.7/plat-irix5/IOCTL.py
rename from lib-python/2.7.0/plat-irix5/IOCTL.py
rename to lib-python/2.7/plat-irix5/IOCTL.py
diff --git a/lib-python/2.7.0/plat-irix5/SV.py b/lib-python/2.7/plat-irix5/SV.py
rename from lib-python/2.7.0/plat-irix5/SV.py
rename to lib-python/2.7/plat-irix5/SV.py
diff --git a/lib-python/2.7.0/plat-irix5/WAIT.py b/lib-python/2.7/plat-irix5/WAIT.py
rename from lib-python/2.7.0/plat-irix5/WAIT.py
rename to lib-python/2.7/plat-irix5/WAIT.py
diff --git a/lib-python/2.7.0/plat-irix5/cddb.py b/lib-python/2.7/plat-irix5/cddb.py
rename from lib-python/2.7.0/plat-irix5/cddb.py
rename to lib-python/2.7/plat-irix5/cddb.py
diff --git a/lib-python/2.7.0/plat-irix5/cdplayer.py b/lib-python/2.7/plat-irix5/cdplayer.py
rename from lib-python/2.7.0/plat-irix5/cdplayer.py
rename to lib-python/2.7/plat-irix5/cdplayer.py
diff --git a/lib-python/2.7.0/plat-irix5/flp.doc b/lib-python/2.7/plat-irix5/flp.doc
rename from lib-python/2.7.0/plat-irix5/flp.doc
rename to lib-python/2.7/plat-irix5/flp.doc
diff --git a/lib-python/2.7.0/plat-irix5/flp.py b/lib-python/2.7/plat-irix5/flp.py
rename from lib-python/2.7.0/plat-irix5/flp.py
rename to lib-python/2.7/plat-irix5/flp.py
diff --git a/lib-python/2.7.0/plat-irix5/jpeg.py b/lib-python/2.7/plat-irix5/jpeg.py
rename from lib-python/2.7.0/plat-irix5/jpeg.py
rename to lib-python/2.7/plat-irix5/jpeg.py
diff --git a/lib-python/2.7.0/plat-irix5/panel.py b/lib-python/2.7/plat-irix5/panel.py
rename from lib-python/2.7.0/plat-irix5/panel.py
rename to lib-python/2.7/plat-irix5/panel.py
diff --git a/lib-python/2.7.0/plat-irix5/panelparser.py b/lib-python/2.7/plat-irix5/panelparser.py
rename from lib-python/2.7.0/plat-irix5/panelparser.py
rename to lib-python/2.7/plat-irix5/panelparser.py
diff --git a/lib-python/2.7.0/plat-irix5/readcd.doc b/lib-python/2.7/plat-irix5/readcd.doc
rename from lib-python/2.7.0/plat-irix5/readcd.doc
rename to lib-python/2.7/plat-irix5/readcd.doc
diff --git a/lib-python/2.7.0/plat-irix5/readcd.py b/lib-python/2.7/plat-irix5/readcd.py
rename from lib-python/2.7.0/plat-irix5/readcd.py
rename to lib-python/2.7/plat-irix5/readcd.py
diff --git a/lib-python/2.7.0/plat-irix5/regen b/lib-python/2.7/plat-irix5/regen
rename from lib-python/2.7.0/plat-irix5/regen
rename to lib-python/2.7/plat-irix5/regen
diff --git a/lib-python/2.7.0/plat-irix5/torgb.py b/lib-python/2.7/plat-irix5/torgb.py
rename from lib-python/2.7.0/plat-irix5/torgb.py
rename to lib-python/2.7/plat-irix5/torgb.py
diff --git a/lib-python/2.7.0/plat-irix6/AL.py b/lib-python/2.7/plat-irix6/AL.py
rename from lib-python/2.7.0/plat-irix6/AL.py
rename to lib-python/2.7/plat-irix6/AL.py
diff --git a/lib-python/2.7.0/plat-irix6/CD.py b/lib-python/2.7/plat-irix6/CD.py
rename from lib-python/2.7.0/plat-irix6/CD.py
rename to lib-python/2.7/plat-irix6/CD.py
diff --git a/lib-python/2.7.0/plat-irix6/CL.py b/lib-python/2.7/plat-irix6/CL.py
rename from lib-python/2.7.0/plat-irix6/CL.py
rename to lib-python/2.7/plat-irix6/CL.py
diff --git a/lib-python/2.7.0/plat-irix6/DEVICE.py b/lib-python/2.7/plat-irix6/DEVICE.py
rename from lib-python/2.7.0/plat-irix6/DEVICE.py
rename to lib-python/2.7/plat-irix6/DEVICE.py
diff --git a/lib-python/2.7.0/plat-irix6/ERRNO.py b/lib-python/2.7/plat-irix6/ERRNO.py
rename from lib-python/2.7.0/plat-irix6/ERRNO.py
rename to lib-python/2.7/plat-irix6/ERRNO.py
diff --git a/lib-python/2.7.0/plat-irix6/FILE.py b/lib-python/2.7/plat-irix6/FILE.py
rename from lib-python/2.7.0/plat-irix6/FILE.py
rename to lib-python/2.7/plat-irix6/FILE.py
diff --git a/lib-python/2.7.0/plat-irix6/FL.py b/lib-python/2.7/plat-irix6/FL.py
rename from lib-python/2.7.0/plat-irix6/FL.py
rename to lib-python/2.7/plat-irix6/FL.py
diff --git a/lib-python/2.7.0/plat-irix6/GET.py b/lib-python/2.7/plat-irix6/GET.py
rename from lib-python/2.7.0/plat-irix6/GET.py
rename to lib-python/2.7/plat-irix6/GET.py
diff --git a/lib-python/2.7.0/plat-irix6/GL.py b/lib-python/2.7/plat-irix6/GL.py
rename from lib-python/2.7.0/plat-irix6/GL.py
rename to lib-python/2.7/plat-irix6/GL.py
diff --git a/lib-python/2.7.0/plat-irix6/GLWS.py b/lib-python/2.7/plat-irix6/GLWS.py
rename from lib-python/2.7.0/plat-irix6/GLWS.py
rename to lib-python/2.7/plat-irix6/GLWS.py
diff --git a/lib-python/2.7.0/plat-irix6/IN.py b/lib-python/2.7/plat-irix6/IN.py
rename from lib-python/2.7.0/plat-irix6/IN.py
rename to lib-python/2.7/plat-irix6/IN.py
diff --git a/lib-python/2.7.0/plat-irix6/IOCTL.py b/lib-python/2.7/plat-irix6/IOCTL.py
rename from lib-python/2.7.0/plat-irix6/IOCTL.py
rename to lib-python/2.7/plat-irix6/IOCTL.py
diff --git a/lib-python/2.7.0/plat-irix6/SV.py b/lib-python/2.7/plat-irix6/SV.py
rename from lib-python/2.7.0/plat-irix6/SV.py
rename to lib-python/2.7/plat-irix6/SV.py
diff --git a/lib-python/2.7.0/plat-irix6/WAIT.py b/lib-python/2.7/plat-irix6/WAIT.py
rename from lib-python/2.7.0/plat-irix6/WAIT.py
rename to lib-python/2.7/plat-irix6/WAIT.py
diff --git a/lib-python/2.7.0/plat-irix6/cddb.py b/lib-python/2.7/plat-irix6/cddb.py
rename from lib-python/2.7.0/plat-irix6/cddb.py
rename to lib-python/2.7/plat-irix6/cddb.py
diff --git a/lib-python/2.7.0/plat-irix6/cdplayer.py b/lib-python/2.7/plat-irix6/cdplayer.py
rename from lib-python/2.7.0/plat-irix6/cdplayer.py
rename to lib-python/2.7/plat-irix6/cdplayer.py
diff --git a/lib-python/2.7.0/plat-irix6/flp.doc b/lib-python/2.7/plat-irix6/flp.doc
rename from lib-python/2.7.0/plat-irix6/flp.doc
rename to lib-python/2.7/plat-irix6/flp.doc
diff --git a/lib-python/2.7.0/plat-irix6/flp.py b/lib-python/2.7/plat-irix6/flp.py
rename from lib-python/2.7.0/plat-irix6/flp.py
rename to lib-python/2.7/plat-irix6/flp.py
diff --git a/lib-python/2.7.0/plat-irix6/jpeg.py b/lib-python/2.7/plat-irix6/jpeg.py
rename from lib-python/2.7.0/plat-irix6/jpeg.py
rename to lib-python/2.7/plat-irix6/jpeg.py
diff --git a/lib-python/2.7.0/plat-irix6/panel.py b/lib-python/2.7/plat-irix6/panel.py
rename from lib-python/2.7.0/plat-irix6/panel.py
rename to lib-python/2.7/plat-irix6/panel.py
diff --git a/lib-python/2.7.0/plat-irix6/panelparser.py b/lib-python/2.7/plat-irix6/panelparser.py
rename from lib-python/2.7.0/plat-irix6/panelparser.py
rename to lib-python/2.7/plat-irix6/panelparser.py
diff --git a/lib-python/2.7.0/plat-irix6/readcd.doc b/lib-python/2.7/plat-irix6/readcd.doc
rename from lib-python/2.7.0/plat-irix6/readcd.doc
rename to lib-python/2.7/plat-irix6/readcd.doc
diff --git a/lib-python/2.7.0/plat-irix6/readcd.py b/lib-python/2.7/plat-irix6/readcd.py
rename from lib-python/2.7.0/plat-irix6/readcd.py
rename to lib-python/2.7/plat-irix6/readcd.py
diff --git a/lib-python/2.7.0/plat-irix6/regen b/lib-python/2.7/plat-irix6/regen
rename from lib-python/2.7.0/plat-irix6/regen
rename to lib-python/2.7/plat-irix6/regen
diff --git a/lib-python/2.7.0/plat-irix6/torgb.py b/lib-python/2.7/plat-irix6/torgb.py
rename from lib-python/2.7.0/plat-irix6/torgb.py
rename to lib-python/2.7/plat-irix6/torgb.py
diff --git a/lib-python/2.7.0/plat-linux2/CDROM.py b/lib-python/2.7/plat-linux2/CDROM.py
rename from lib-python/2.7.0/plat-linux2/CDROM.py
rename to lib-python/2.7/plat-linux2/CDROM.py
diff --git a/lib-python/2.7.0/plat-linux2/DLFCN.py b/lib-python/2.7/plat-linux2/DLFCN.py
rename from lib-python/2.7.0/plat-linux2/DLFCN.py
rename to lib-python/2.7/plat-linux2/DLFCN.py
diff --git a/lib-python/2.7.0/plat-linux2/IN.py b/lib-python/2.7/plat-linux2/IN.py
rename from lib-python/2.7.0/plat-linux2/IN.py
rename to lib-python/2.7/plat-linux2/IN.py
diff --git a/lib-python/2.7.0/plat-linux2/TYPES.py b/lib-python/2.7/plat-linux2/TYPES.py
rename from lib-python/2.7.0/plat-linux2/TYPES.py
rename to lib-python/2.7/plat-linux2/TYPES.py
diff --git a/lib-python/2.7.0/plat-linux2/regen b/lib-python/2.7/plat-linux2/regen
rename from lib-python/2.7.0/plat-linux2/regen
rename to lib-python/2.7/plat-linux2/regen
diff --git a/lib-python/2.7.0/plat-mac/Audio_mac.py b/lib-python/2.7/plat-mac/Audio_mac.py
rename from lib-python/2.7.0/plat-mac/Audio_mac.py
rename to lib-python/2.7/plat-mac/Audio_mac.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/AE.py b/lib-python/2.7/plat-mac/Carbon/AE.py
rename from lib-python/2.7.0/plat-mac/Carbon/AE.py
rename to lib-python/2.7/plat-mac/Carbon/AE.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/AH.py b/lib-python/2.7/plat-mac/Carbon/AH.py
rename from lib-python/2.7.0/plat-mac/Carbon/AH.py
rename to lib-python/2.7/plat-mac/Carbon/AH.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/Alias.py b/lib-python/2.7/plat-mac/Carbon/Alias.py
rename from lib-python/2.7.0/plat-mac/Carbon/Alias.py
rename to lib-python/2.7/plat-mac/Carbon/Alias.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/Aliases.py b/lib-python/2.7/plat-mac/Carbon/Aliases.py
rename from lib-python/2.7.0/plat-mac/Carbon/Aliases.py
rename to lib-python/2.7/plat-mac/Carbon/Aliases.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/App.py b/lib-python/2.7/plat-mac/Carbon/App.py
rename from lib-python/2.7.0/plat-mac/Carbon/App.py
rename to lib-python/2.7/plat-mac/Carbon/App.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/Appearance.py b/lib-python/2.7/plat-mac/Carbon/Appearance.py
rename from lib-python/2.7.0/plat-mac/Carbon/Appearance.py
rename to lib-python/2.7/plat-mac/Carbon/Appearance.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/AppleEvents.py b/lib-python/2.7/plat-mac/Carbon/AppleEvents.py
rename from lib-python/2.7.0/plat-mac/Carbon/AppleEvents.py
rename to lib-python/2.7/plat-mac/Carbon/AppleEvents.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/AppleHelp.py b/lib-python/2.7/plat-mac/Carbon/AppleHelp.py
rename from lib-python/2.7.0/plat-mac/Carbon/AppleHelp.py
rename to lib-python/2.7/plat-mac/Carbon/AppleHelp.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/CF.py b/lib-python/2.7/plat-mac/Carbon/CF.py
rename from lib-python/2.7.0/plat-mac/Carbon/CF.py
rename to lib-python/2.7/plat-mac/Carbon/CF.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/CG.py b/lib-python/2.7/plat-mac/Carbon/CG.py
rename from lib-python/2.7.0/plat-mac/Carbon/CG.py
rename to lib-python/2.7/plat-mac/Carbon/CG.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/CarbonEvents.py b/lib-python/2.7/plat-mac/Carbon/CarbonEvents.py
rename from lib-python/2.7.0/plat-mac/Carbon/CarbonEvents.py
rename to lib-python/2.7/plat-mac/Carbon/CarbonEvents.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/CarbonEvt.py b/lib-python/2.7/plat-mac/Carbon/CarbonEvt.py
rename from lib-python/2.7.0/plat-mac/Carbon/CarbonEvt.py
rename to lib-python/2.7/plat-mac/Carbon/CarbonEvt.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/Cm.py b/lib-python/2.7/plat-mac/Carbon/Cm.py
rename from lib-python/2.7.0/plat-mac/Carbon/Cm.py
rename to lib-python/2.7/plat-mac/Carbon/Cm.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/Components.py b/lib-python/2.7/plat-mac/Carbon/Components.py
rename from lib-python/2.7.0/plat-mac/Carbon/Components.py
rename to lib-python/2.7/plat-mac/Carbon/Components.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/ControlAccessor.py b/lib-python/2.7/plat-mac/Carbon/ControlAccessor.py
rename from lib-python/2.7.0/plat-mac/Carbon/ControlAccessor.py
rename to lib-python/2.7/plat-mac/Carbon/ControlAccessor.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/Controls.py b/lib-python/2.7/plat-mac/Carbon/Controls.py
rename from lib-python/2.7.0/plat-mac/Carbon/Controls.py
rename to lib-python/2.7/plat-mac/Carbon/Controls.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/CoreFoundation.py b/lib-python/2.7/plat-mac/Carbon/CoreFoundation.py
rename from lib-python/2.7.0/plat-mac/Carbon/CoreFoundation.py
rename to lib-python/2.7/plat-mac/Carbon/CoreFoundation.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/CoreGraphics.py b/lib-python/2.7/plat-mac/Carbon/CoreGraphics.py
rename from lib-python/2.7.0/plat-mac/Carbon/CoreGraphics.py
rename to lib-python/2.7/plat-mac/Carbon/CoreGraphics.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/Ctl.py b/lib-python/2.7/plat-mac/Carbon/Ctl.py
rename from lib-python/2.7.0/plat-mac/Carbon/Ctl.py
rename to lib-python/2.7/plat-mac/Carbon/Ctl.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/Dialogs.py b/lib-python/2.7/plat-mac/Carbon/Dialogs.py
rename from lib-python/2.7.0/plat-mac/Carbon/Dialogs.py
rename to lib-python/2.7/plat-mac/Carbon/Dialogs.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/Dlg.py b/lib-python/2.7/plat-mac/Carbon/Dlg.py
rename from lib-python/2.7.0/plat-mac/Carbon/Dlg.py
rename to lib-python/2.7/plat-mac/Carbon/Dlg.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/Drag.py b/lib-python/2.7/plat-mac/Carbon/Drag.py
rename from lib-python/2.7.0/plat-mac/Carbon/Drag.py
rename to lib-python/2.7/plat-mac/Carbon/Drag.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/Dragconst.py b/lib-python/2.7/plat-mac/Carbon/Dragconst.py
rename from lib-python/2.7.0/plat-mac/Carbon/Dragconst.py
rename to lib-python/2.7/plat-mac/Carbon/Dragconst.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/Events.py b/lib-python/2.7/plat-mac/Carbon/Events.py
rename from lib-python/2.7.0/plat-mac/Carbon/Events.py
rename to lib-python/2.7/plat-mac/Carbon/Events.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/Evt.py b/lib-python/2.7/plat-mac/Carbon/Evt.py
rename from lib-python/2.7.0/plat-mac/Carbon/Evt.py
rename to lib-python/2.7/plat-mac/Carbon/Evt.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/File.py b/lib-python/2.7/plat-mac/Carbon/File.py
rename from lib-python/2.7.0/plat-mac/Carbon/File.py
rename to lib-python/2.7/plat-mac/Carbon/File.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/Files.py b/lib-python/2.7/plat-mac/Carbon/Files.py
rename from lib-python/2.7.0/plat-mac/Carbon/Files.py
rename to lib-python/2.7/plat-mac/Carbon/Files.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/Fm.py b/lib-python/2.7/plat-mac/Carbon/Fm.py
rename from lib-python/2.7.0/plat-mac/Carbon/Fm.py
rename to lib-python/2.7/plat-mac/Carbon/Fm.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/Folder.py b/lib-python/2.7/plat-mac/Carbon/Folder.py
rename from lib-python/2.7.0/plat-mac/Carbon/Folder.py
rename to lib-python/2.7/plat-mac/Carbon/Folder.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/Folders.py b/lib-python/2.7/plat-mac/Carbon/Folders.py
rename from lib-python/2.7.0/plat-mac/Carbon/Folders.py
rename to lib-python/2.7/plat-mac/Carbon/Folders.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/Fonts.py b/lib-python/2.7/plat-mac/Carbon/Fonts.py
rename from lib-python/2.7.0/plat-mac/Carbon/Fonts.py
rename to lib-python/2.7/plat-mac/Carbon/Fonts.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/Help.py b/lib-python/2.7/plat-mac/Carbon/Help.py
rename from lib-python/2.7.0/plat-mac/Carbon/Help.py
rename to lib-python/2.7/plat-mac/Carbon/Help.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/IBCarbon.py b/lib-python/2.7/plat-mac/Carbon/IBCarbon.py
rename from lib-python/2.7.0/plat-mac/Carbon/IBCarbon.py
rename to lib-python/2.7/plat-mac/Carbon/IBCarbon.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/IBCarbonRuntime.py b/lib-python/2.7/plat-mac/Carbon/IBCarbonRuntime.py
rename from lib-python/2.7.0/plat-mac/Carbon/IBCarbonRuntime.py
rename to lib-python/2.7/plat-mac/Carbon/IBCarbonRuntime.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/Icn.py b/lib-python/2.7/plat-mac/Carbon/Icn.py
rename from lib-python/2.7.0/plat-mac/Carbon/Icn.py
rename to lib-python/2.7/plat-mac/Carbon/Icn.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/Icons.py b/lib-python/2.7/plat-mac/Carbon/Icons.py
rename from lib-python/2.7.0/plat-mac/Carbon/Icons.py
rename to lib-python/2.7/plat-mac/Carbon/Icons.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/Launch.py b/lib-python/2.7/plat-mac/Carbon/Launch.py
rename from lib-python/2.7.0/plat-mac/Carbon/Launch.py
rename to lib-python/2.7/plat-mac/Carbon/Launch.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/LaunchServices.py b/lib-python/2.7/plat-mac/Carbon/LaunchServices.py
rename from lib-python/2.7.0/plat-mac/Carbon/LaunchServices.py
rename to lib-python/2.7/plat-mac/Carbon/LaunchServices.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/List.py b/lib-python/2.7/plat-mac/Carbon/List.py
rename from lib-python/2.7.0/plat-mac/Carbon/List.py
rename to lib-python/2.7/plat-mac/Carbon/List.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/Lists.py b/lib-python/2.7/plat-mac/Carbon/Lists.py
rename from lib-python/2.7.0/plat-mac/Carbon/Lists.py
rename to lib-python/2.7/plat-mac/Carbon/Lists.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/MacHelp.py b/lib-python/2.7/plat-mac/Carbon/MacHelp.py
rename from lib-python/2.7.0/plat-mac/Carbon/MacHelp.py
rename to lib-python/2.7/plat-mac/Carbon/MacHelp.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/MacTextEditor.py b/lib-python/2.7/plat-mac/Carbon/MacTextEditor.py
rename from lib-python/2.7.0/plat-mac/Carbon/MacTextEditor.py
rename to lib-python/2.7/plat-mac/Carbon/MacTextEditor.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/MediaDescr.py b/lib-python/2.7/plat-mac/Carbon/MediaDescr.py
rename from lib-python/2.7.0/plat-mac/Carbon/MediaDescr.py
rename to lib-python/2.7/plat-mac/Carbon/MediaDescr.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/Menu.py b/lib-python/2.7/plat-mac/Carbon/Menu.py
rename from lib-python/2.7.0/plat-mac/Carbon/Menu.py
rename to lib-python/2.7/plat-mac/Carbon/Menu.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/Menus.py b/lib-python/2.7/plat-mac/Carbon/Menus.py
rename from lib-python/2.7.0/plat-mac/Carbon/Menus.py
rename to lib-python/2.7/plat-mac/Carbon/Menus.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/Mlte.py b/lib-python/2.7/plat-mac/Carbon/Mlte.py
rename from lib-python/2.7.0/plat-mac/Carbon/Mlte.py
rename to lib-python/2.7/plat-mac/Carbon/Mlte.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/OSA.py b/lib-python/2.7/plat-mac/Carbon/OSA.py
rename from lib-python/2.7.0/plat-mac/Carbon/OSA.py
rename to lib-python/2.7/plat-mac/Carbon/OSA.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/OSAconst.py b/lib-python/2.7/plat-mac/Carbon/OSAconst.py
rename from lib-python/2.7.0/plat-mac/Carbon/OSAconst.py
rename to lib-python/2.7/plat-mac/Carbon/OSAconst.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/QDOffscreen.py b/lib-python/2.7/plat-mac/Carbon/QDOffscreen.py
rename from lib-python/2.7.0/plat-mac/Carbon/QDOffscreen.py
rename to lib-python/2.7/plat-mac/Carbon/QDOffscreen.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/Qd.py b/lib-python/2.7/plat-mac/Carbon/Qd.py
rename from lib-python/2.7.0/plat-mac/Carbon/Qd.py
rename to lib-python/2.7/plat-mac/Carbon/Qd.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/Qdoffs.py b/lib-python/2.7/plat-mac/Carbon/Qdoffs.py
rename from lib-python/2.7.0/plat-mac/Carbon/Qdoffs.py
rename to lib-python/2.7/plat-mac/Carbon/Qdoffs.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/Qt.py b/lib-python/2.7/plat-mac/Carbon/Qt.py
rename from lib-python/2.7.0/plat-mac/Carbon/Qt.py
rename to lib-python/2.7/plat-mac/Carbon/Qt.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/QuickDraw.py b/lib-python/2.7/plat-mac/Carbon/QuickDraw.py
rename from lib-python/2.7.0/plat-mac/Carbon/QuickDraw.py
rename to lib-python/2.7/plat-mac/Carbon/QuickDraw.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/QuickTime.py b/lib-python/2.7/plat-mac/Carbon/QuickTime.py
rename from lib-python/2.7.0/plat-mac/Carbon/QuickTime.py
rename to lib-python/2.7/plat-mac/Carbon/QuickTime.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/Res.py b/lib-python/2.7/plat-mac/Carbon/Res.py
rename from lib-python/2.7.0/plat-mac/Carbon/Res.py
rename to lib-python/2.7/plat-mac/Carbon/Res.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/Resources.py b/lib-python/2.7/plat-mac/Carbon/Resources.py
rename from lib-python/2.7.0/plat-mac/Carbon/Resources.py
rename to lib-python/2.7/plat-mac/Carbon/Resources.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/Scrap.py b/lib-python/2.7/plat-mac/Carbon/Scrap.py
rename from lib-python/2.7.0/plat-mac/Carbon/Scrap.py
rename to lib-python/2.7/plat-mac/Carbon/Scrap.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/Snd.py b/lib-python/2.7/plat-mac/Carbon/Snd.py
rename from lib-python/2.7.0/plat-mac/Carbon/Snd.py
rename to lib-python/2.7/plat-mac/Carbon/Snd.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/Sndihooks.py b/lib-python/2.7/plat-mac/Carbon/Sndihooks.py
rename from lib-python/2.7.0/plat-mac/Carbon/Sndihooks.py
rename to lib-python/2.7/plat-mac/Carbon/Sndihooks.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/Sound.py b/lib-python/2.7/plat-mac/Carbon/Sound.py
rename from lib-python/2.7.0/plat-mac/Carbon/Sound.py
rename to lib-python/2.7/plat-mac/Carbon/Sound.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/TE.py b/lib-python/2.7/plat-mac/Carbon/TE.py
rename from lib-python/2.7.0/plat-mac/Carbon/TE.py
rename to lib-python/2.7/plat-mac/Carbon/TE.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/TextEdit.py b/lib-python/2.7/plat-mac/Carbon/TextEdit.py
rename from lib-python/2.7.0/plat-mac/Carbon/TextEdit.py
rename to lib-python/2.7/plat-mac/Carbon/TextEdit.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/Win.py b/lib-python/2.7/plat-mac/Carbon/Win.py
rename from lib-python/2.7.0/plat-mac/Carbon/Win.py
rename to lib-python/2.7/plat-mac/Carbon/Win.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/Windows.py b/lib-python/2.7/plat-mac/Carbon/Windows.py
rename from lib-python/2.7.0/plat-mac/Carbon/Windows.py
rename to lib-python/2.7/plat-mac/Carbon/Windows.py
diff --git a/lib-python/2.7.0/plat-mac/Carbon/__init__.py b/lib-python/2.7/plat-mac/Carbon/__init__.py
rename from lib-python/2.7.0/plat-mac/Carbon/__init__.py
rename to lib-python/2.7/plat-mac/Carbon/__init__.py
diff --git a/lib-python/2.7.0/plat-mac/EasyDialogs.py b/lib-python/2.7/plat-mac/EasyDialogs.py
rename from lib-python/2.7.0/plat-mac/EasyDialogs.py
rename to lib-python/2.7/plat-mac/EasyDialogs.py
diff --git a/lib-python/2.7.0/plat-mac/FrameWork.py b/lib-python/2.7/plat-mac/FrameWork.py
rename from lib-python/2.7.0/plat-mac/FrameWork.py
rename to lib-python/2.7/plat-mac/FrameWork.py
diff --git a/lib-python/2.7.0/plat-mac/MiniAEFrame.py b/lib-python/2.7/plat-mac/MiniAEFrame.py
rename from lib-python/2.7.0/plat-mac/MiniAEFrame.py
rename to lib-python/2.7/plat-mac/MiniAEFrame.py
diff --git a/lib-python/2.7.0/plat-mac/PixMapWrapper.py b/lib-python/2.7/plat-mac/PixMapWrapper.py
rename from lib-python/2.7.0/plat-mac/PixMapWrapper.py
rename to lib-python/2.7/plat-mac/PixMapWrapper.py
diff --git a/lib-python/2.7.0/plat-mac/aepack.py b/lib-python/2.7/plat-mac/aepack.py
rename from lib-python/2.7.0/plat-mac/aepack.py
rename to lib-python/2.7/plat-mac/aepack.py
diff --git a/lib-python/2.7.0/plat-mac/aetools.py b/lib-python/2.7/plat-mac/aetools.py
rename from lib-python/2.7.0/plat-mac/aetools.py
rename to lib-python/2.7/plat-mac/aetools.py
diff --git a/lib-python/2.7.0/plat-mac/aetypes.py b/lib-python/2.7/plat-mac/aetypes.py
rename from lib-python/2.7.0/plat-mac/aetypes.py
rename to lib-python/2.7/plat-mac/aetypes.py
diff --git a/lib-python/2.7.0/plat-mac/applesingle.py b/lib-python/2.7/plat-mac/applesingle.py
rename from lib-python/2.7.0/plat-mac/applesingle.py
rename to lib-python/2.7/plat-mac/applesingle.py
diff --git a/lib-python/2.7.0/plat-mac/appletrawmain.py b/lib-python/2.7/plat-mac/appletrawmain.py
rename from lib-python/2.7.0/plat-mac/appletrawmain.py
rename to lib-python/2.7/plat-mac/appletrawmain.py
diff --git a/lib-python/2.7.0/plat-mac/appletrunner.py b/lib-python/2.7/plat-mac/appletrunner.py
rename from lib-python/2.7.0/plat-mac/appletrunner.py
rename to lib-python/2.7/plat-mac/appletrunner.py
diff --git a/lib-python/2.7.0/plat-mac/argvemulator.py b/lib-python/2.7/plat-mac/argvemulator.py
rename from lib-python/2.7.0/plat-mac/argvemulator.py
rename to lib-python/2.7/plat-mac/argvemulator.py
diff --git a/lib-python/2.7.0/plat-mac/bgenlocations.py b/lib-python/2.7/plat-mac/bgenlocations.py
rename from lib-python/2.7.0/plat-mac/bgenlocations.py
rename to lib-python/2.7/plat-mac/bgenlocations.py
diff --git a/lib-python/2.7.0/plat-mac/buildtools.py b/lib-python/2.7/plat-mac/buildtools.py
rename from lib-python/2.7.0/plat-mac/buildtools.py
rename to lib-python/2.7/plat-mac/buildtools.py
diff --git a/lib-python/2.7.0/plat-mac/bundlebuilder.py b/lib-python/2.7/plat-mac/bundlebuilder.py
rename from lib-python/2.7.0/plat-mac/bundlebuilder.py
rename to lib-python/2.7/plat-mac/bundlebuilder.py
diff --git a/lib-python/2.7.0/plat-mac/cfmfile.py b/lib-python/2.7/plat-mac/cfmfile.py
rename from lib-python/2.7.0/plat-mac/cfmfile.py
rename to lib-python/2.7/plat-mac/cfmfile.py
diff --git a/lib-python/2.7.0/plat-mac/dialogs.rsrc b/lib-python/2.7/plat-mac/dialogs.rsrc
rename from lib-python/2.7.0/plat-mac/dialogs.rsrc
rename to lib-python/2.7/plat-mac/dialogs.rsrc
diff --git a/lib-python/2.7.0/plat-mac/errors.rsrc b/lib-python/2.7/plat-mac/errors.rsrc
rename from lib-python/2.7.0/plat-mac/errors.rsrc
rename to lib-python/2.7/plat-mac/errors.rsrc
diff --git a/lib-python/2.7.0/plat-mac/findertools.py b/lib-python/2.7/plat-mac/findertools.py
rename from lib-python/2.7.0/plat-mac/findertools.py
rename to lib-python/2.7/plat-mac/findertools.py
diff --git a/lib-python/2.7.0/plat-mac/gensuitemodule.py b/lib-python/2.7/plat-mac/gensuitemodule.py
rename from lib-python/2.7.0/plat-mac/gensuitemodule.py
rename to lib-python/2.7/plat-mac/gensuitemodule.py
diff --git a/lib-python/2.7.0/plat-mac/ic.py b/lib-python/2.7/plat-mac/ic.py
rename from lib-python/2.7.0/plat-mac/ic.py
rename to lib-python/2.7/plat-mac/ic.py
diff --git a/lib-python/2.7.0/plat-mac/icopen.py b/lib-python/2.7/plat-mac/icopen.py
rename from lib-python/2.7.0/plat-mac/icopen.py
rename to lib-python/2.7/plat-mac/icopen.py
diff --git a/lib-python/2.7.0/plat-mac/lib-scriptpackages/CodeWarrior/CodeWarrior_suite.py b/lib-python/2.7/plat-mac/lib-scriptpackages/CodeWarrior/CodeWarrior_suite.py
rename from lib-python/2.7.0/plat-mac/lib-scriptpackages/CodeWarrior/CodeWarrior_suite.py
rename to lib-python/2.7/plat-mac/lib-scriptpackages/CodeWarrior/CodeWarrior_suite.py
diff --git a/lib-python/2.7.0/plat-mac/lib-scriptpackages/CodeWarrior/Metrowerks_Shell_Suite.py b/lib-python/2.7/plat-mac/lib-scriptpackages/CodeWarrior/Metrowerks_Shell_Suite.py
rename from lib-python/2.7.0/plat-mac/lib-scriptpackages/CodeWarrior/Metrowerks_Shell_Suite.py
rename to lib-python/2.7/plat-mac/lib-scriptpackages/CodeWarrior/Metrowerks_Shell_Suite.py
diff --git a/lib-python/2.7.0/plat-mac/lib-scriptpackages/CodeWarrior/Required.py b/lib-python/2.7/plat-mac/lib-scriptpackages/CodeWarrior/Required.py
rename from lib-python/2.7.0/plat-mac/lib-scriptpackages/CodeWarrior/Required.py
rename to lib-python/2.7/plat-mac/lib-scriptpackages/CodeWarrior/Required.py
diff --git a/lib-python/2.7.0/plat-mac/lib-scriptpackages/CodeWarrior/Standard_Suite.py b/lib-python/2.7/plat-mac/lib-scriptpackages/CodeWarrior/Standard_Suite.py
rename from lib-python/2.7.0/plat-mac/lib-scriptpackages/CodeWarrior/Standard_Suite.py
rename to lib-python/2.7/plat-mac/lib-scriptpackages/CodeWarrior/Standard_Suite.py
diff --git a/lib-python/2.7.0/plat-mac/lib-scriptpackages/CodeWarrior/__init__.py b/lib-python/2.7/plat-mac/lib-scriptpackages/CodeWarrior/__init__.py
rename from lib-python/2.7.0/plat-mac/lib-scriptpackages/CodeWarrior/__init__.py
rename to lib-python/2.7/plat-mac/lib-scriptpackages/CodeWarrior/__init__.py
diff --git a/lib-python/2.7.0/plat-mac/lib-scriptpackages/Explorer/Microsoft_Internet_Explorer.py b/lib-python/2.7/plat-mac/lib-scriptpackages/Explorer/Microsoft_Internet_Explorer.py
rename from lib-python/2.7.0/plat-mac/lib-scriptpackages/Explorer/Microsoft_Internet_Explorer.py
rename to lib-python/2.7/plat-mac/lib-scriptpackages/Explorer/Microsoft_Internet_Explorer.py
diff --git a/lib-python/2.7.0/plat-mac/lib-scriptpackages/Explorer/Netscape_Suite.py b/lib-python/2.7/plat-mac/lib-scriptpackages/Explorer/Netscape_Suite.py
rename from lib-python/2.7.0/plat-mac/lib-scriptpackages/Explorer/Netscape_Suite.py
rename to lib-python/2.7/plat-mac/lib-scriptpackages/Explorer/Netscape_Suite.py
diff --git a/lib-python/2.7.0/plat-mac/lib-scriptpackages/Explorer/Required_Suite.py b/lib-python/2.7/plat-mac/lib-scriptpackages/Explorer/Required_Suite.py
rename from lib-python/2.7.0/plat-mac/lib-scriptpackages/Explorer/Required_Suite.py
rename to lib-python/2.7/plat-mac/lib-scriptpackages/Explorer/Required_Suite.py
diff --git a/lib-python/2.7.0/plat-mac/lib-scriptpackages/Explorer/Standard_Suite.py b/lib-python/2.7/plat-mac/lib-scriptpackages/Explorer/Standard_Suite.py
rename from lib-python/2.7.0/plat-mac/lib-scriptpackages/Explorer/Standard_Suite.py
rename to lib-python/2.7/plat-mac/lib-scriptpackages/Explorer/Standard_Suite.py
diff --git a/lib-python/2.7.0/plat-mac/lib-scriptpackages/Explorer/URL_Suite.py b/lib-python/2.7/plat-mac/lib-scriptpackages/Explorer/URL_Suite.py
rename from lib-python/2.7.0/plat-mac/lib-scriptpackages/Explorer/URL_Suite.py
rename to lib-python/2.7/plat-mac/lib-scriptpackages/Explorer/URL_Suite.py
diff --git a/lib-python/2.7.0/plat-mac/lib-scriptpackages/Explorer/Web_Browser_Suite.py b/lib-python/2.7/plat-mac/lib-scriptpackages/Explorer/Web_Browser_Suite.py
rename from lib-python/2.7.0/plat-mac/lib-scriptpackages/Explorer/Web_Browser_Suite.py
rename to lib-python/2.7/plat-mac/lib-scriptpackages/Explorer/Web_Browser_Suite.py
diff --git a/lib-python/2.7.0/plat-mac/lib-scriptpackages/Explorer/__init__.py b/lib-python/2.7/plat-mac/lib-scriptpackages/Explorer/__init__.py
rename from lib-python/2.7.0/plat-mac/lib-scriptpackages/Explorer/__init__.py
rename to lib-python/2.7/plat-mac/lib-scriptpackages/Explorer/__init__.py
diff --git a/lib-python/2.7.0/plat-mac/lib-scriptpackages/Finder/Containers_and_folders.py b/lib-python/2.7/plat-mac/lib-scriptpackages/Finder/Containers_and_folders.py
rename from lib-python/2.7.0/plat-mac/lib-scriptpackages/Finder/Containers_and_folders.py
rename to lib-python/2.7/plat-mac/lib-scriptpackages/Finder/Containers_and_folders.py
diff --git a/lib-python/2.7.0/plat-mac/lib-scriptpackages/Finder/Enumerations.py b/lib-python/2.7/plat-mac/lib-scriptpackages/Finder/Enumerations.py
rename from lib-python/2.7.0/plat-mac/lib-scriptpackages/Finder/Enumerations.py
rename to lib-python/2.7/plat-mac/lib-scriptpackages/Finder/Enumerations.py
diff --git a/lib-python/2.7.0/plat-mac/lib-scriptpackages/Finder/Files.py b/lib-python/2.7/plat-mac/lib-scriptpackages/Finder/Files.py
rename from lib-python/2.7.0/plat-mac/lib-scriptpackages/Finder/Files.py
rename to lib-python/2.7/plat-mac/lib-scriptpackages/Finder/Files.py


More information about the pypy-commit mailing list