Convert some custom sort comparison functions to equivalent key functions.

Lib/bsddb/dbtables.py

@@ -88,6 +88,15 @@ class LikeCond(Cond):
     def __call__(self, s):
         return self.re.match(s.decode(self.encoding))
 
+def CmpToKey(mycmp):
+    'Convert a cmp= function into a key= function'
+    class K(object):
+        def __init__(self, obj, *args):
+            self.obj = obj
+        def __lt__(self, other):
+            return mycmp(self.obj, other.obj) == -1
+    return K
+
 #
 # keys used to store database metadata
 #
@@ -587,7 +596,7 @@ class bsdTableDB :
             return 0
 
         conditionlist = list(conditions.items())
-        conditionlist.sort(cmp_conditions)
+        conditionlist.sort(key=CmpToKey(cmp_conditions))
 
         # Apply conditions to column data to find what we want
         cur = self.db.cursor()

Lib/bsddb/test/test_compare.py

@@ -32,10 +32,20 @@ _expected_lexical_test_data = [s.encode('ascii') for s in
 _expected_lowercase_test_data = [s.encode('ascii') for s in
         ('', 'a', 'aaa', 'b', 'c', 'CC', 'cccce', 'ccccf', 'CCCP')]
 
+
+def CmpToKey(mycmp):
+    'Convert a cmp= function into a key= function'
+    class K(object):
+        def __init__(self, obj, *args):
+            self.obj = obj
+        def __lt__(self, other):
+            return mycmp(self.obj, other.obj) == -1
+    return K
+
 class ComparatorTests (unittest.TestCase):
     def comparator_test_helper (self, comparator, expected_data):
         data = expected_data[:]
-        data.sort (comparator)
+        data.sort (key=CmpToKey(comparator))
         self.failUnless (data == expected_data,
                          "comparator `%s' is not right: %s vs. %s"
                          % (comparator, expected_data, data))

Lib/ctypes/util.py

@@ -123,7 +123,7 @@ elif os.name == "posix":
             res = re.findall(expr, data)
             if not res:
                 return _get_soname(_findLib_gcc(name))
-            res.sort(cmp= lambda x,y: cmp(_num_version(x), _num_version(y)))
+            res.sort(key=_num_version)
             return res[-1]
 
     else:

Lib/idlelib/MultiCall.py

@@ -125,7 +125,7 @@ def expand_substates(states):
     statelist = []
     for state in states:
         substates = list(set(state & x for x in states))
-        substates.sort(lambda a,b: nbits(b) - nbits(a))
+        substates.sort(key=nbits, reverse=True)
         statelist.append(substates)
     return statelist
 

Lib/idlelib/TreeWidget.py

@@ -398,7 +398,7 @@ class FileTreeItem(TreeItem):
             names = os.listdir(self.path)
         except os.error:
             return []
-        names.sort(lambda a, b: cmp(os.path.normcase(a), os.path.normcase(b)))
+        names.sort(key = os.path.normcase)
         sublist = []
         for name in names:
             item = FileTreeItem(os.path.join(self.path, name))

Lib/pyclbr.py

@@ -324,8 +324,7 @@ def _main():
         path = []
     dict = readmodule_ex(mod, path)
     objs = dict.values()
-    objs.sort(lambda a, b: cmp(getattr(a, 'lineno', 0),
-                               getattr(b, 'lineno', 0)))
+    objs.sort(key=lambda a: getattr(a, 'lineno', 0))
     for obj in objs:
         if isinstance(obj, Class):
             print("class", obj.name, obj.super, obj.lineno)

Lib/pydoc.py

@@ -797,10 +797,7 @@ class HTMLDoc(Doc):
             tag += ':<br>\n'
 
             # Sort attrs by name.
-            try:
-                attrs.sort(key=lambda t: t[0])
-            except TypeError:
-                attrs.sort(lambda t1, t2: cmp(t1[0], t2[0]))    # 2.3 compat
+            attrs.sort(key=lambda t: t[0])
 
             # Pump out the attrs, segregated by kind.
             attrs = spill('Methods %s' % tag, attrs,

Lib/tarfile.py

@@ -2016,7 +2016,7 @@ class TarFile(object):
                 self.extract(tarinfo, path)
 
         # Reverse sort directories.
-        directories.sort(lambda a, b: cmp(a.name, b.name))
+        directories.sort(key=lambda a: a.name)
         directories.reverse()
 
         # Set correct owner, mtime and filemode on directories.

Lib/unittest.py

@@ -504,6 +504,15 @@ class FunctionTestCase(TestCase):
 # Locating and loading tests
 ##############################################################################
 
+def CmpToKey(mycmp):
+    'Convert a cmp= function into a key= function'
+    class K(object):
+        def __init__(self, obj, *args):
+            self.obj = obj
+        def __lt__(self, other):
+            return mycmp(self.obj, other.obj) == -1
+    return K
+
 class TestLoader:
     """This class is responsible for loading tests according to various
     criteria and returning them wrapped in a TestSuite
@@ -598,7 +607,7 @@ class TestLoader:
                    and hasattr(getattr(testCaseClass, attrname), '__call__')
         testFnNames = list(filter(isTestMethod, dir(testCaseClass)))
         if self.sortTestMethodsUsing:
-            testFnNames.sort(self.sortTestMethodsUsing)
+            testFnNames.sort(key=CmpToKey(self.sortTestMethodsUsing))
         return testFnNames
 
 

Tools/pynche/ColorDB.py

@@ -122,10 +122,7 @@ class ColorDB:
             self.__allnames = []
             for name, aliases in self.__byrgb.values():
                 self.__allnames.append(name)
-            # sort irregardless of case
-            def nocase_cmp(n1, n2):
-                return cmp(n1.lower(), n2.lower())
-            self.__allnames.sort(nocase_cmp)
+            self.__allnames.sort(key=unicode.lower)
         return self.__allnames
 
     def aliases_of(self, red, green, blue):

Tools/scripts/finddiv.py

@@ -78,7 +78,7 @@ def processdir(dir, listnames):
         fn = os.path.join(dir, name)
         if os.path.normcase(fn).endswith(".py") or os.path.isdir(fn):
             files.append(fn)
-    files.sort(lambda a, b: cmp(os.path.normcase(a), os.path.normcase(b)))
+    files.sort(key=os.path.normcase)
     exit = None
     for fn in files:
         x = process(fn, listnames)

Tools/unicode/makeunicodedata.py

@@ -441,6 +441,15 @@ def makeunicodetype(unicode, trace):
 # --------------------------------------------------------------------
 # unicode name database
 
+def CmpToKey(mycmp):
+    'Convert a cmp= function into a key= function'
+    class K(object):
+        def __init__(self, obj, *args):
+            self.obj = obj
+        def __lt__(self, other):
+            return mycmp(self.obj, other.obj) == -1
+    return K
+
 def makeunicodename(unicode, trace):
 
     FILE = "Modules/unicodename_db.h"
@@ -490,7 +499,7 @@ def makeunicodename(unicode, trace):
         if r:
             return r
         return cmp(aword, bword)
-    wordlist.sort(cmpwords)
+    wordlist.sort(key=CmpToKey(cmpwords))
 
     # figure out how many phrasebook escapes we need
     escapes = 0
@@ -514,7 +523,7 @@ def makeunicodename(unicode, trace):
     # length (to maximize overlap)
 
     wordlist, wordtail = wordlist[:short], wordlist[short:]
-    wordtail.sort(lambda a, b: len(b[0])-len(a[0]))
+    wordtail.sort(key=lambda a: a[0], reverse=True)
     wordlist.extend(wordtail)
 
     # generate lexicon from words