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
#
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()
_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))
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:
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
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))
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)
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,
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.
# 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
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
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):
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)
# --------------------------------------------------------------------
# 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"
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
# 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
projects / python / commitdiff