[LNT] Python 3 support: get rid of calls to cmp builtin

[thopre]

Summary

Get rid of calls to cmp builtins since it was removed in Python 3:

• for the tests, the assignment to sortTestMethodsUsing is removed altogether since the default is the built-in ordering for strings;
• for the call in the TestsuiteDB.Order class, we define the rich comparison methods that have replaced cmp;
• for the stats module, we use equality expressions since only the equality value is needed.

Note that one of the uses of cmp in the stats module is dead but removal
of the dead code is kept for future work to keep a separation of concern
between commits.

[hubert.reinterpretcast]

lnt/server/db/testsuitedb.py

284 ↗

(On Diff #220979)

Not sure what you think of this drive-by:

next(
    itertools.dropwhile(
        lambda x: x[0] == x[1],
        map(
            lambda item:
            (convert_revision(self.get_field(item), cache=Order.order_name_cache),
             convert_revision(b.get_field(item), cache=Order.order_name_cache)),
            self.fields)), (0, 0))

[hubert.reinterpretcast]

tests/server/ui/test_api_modify.py

229 ↗

(On Diff #220979)

This does get called, but the default behavior is fine.

[thopre]

• Use Hubert's improve _compare_prepare implementation and rename it accordingly

[thopre]

lnt/server/db/testsuitedb.py

284 ↗

(On Diff #220979)

Went for intermediate steps as I find it more readable, YMMV.

tests/server/ui/test_api_modify.py

229 ↗

(On Diff #220979)

What calls this lambda?

[hubert.reinterpretcast]

LGTM with suggestion for a minor drive-by typo correction.

lnt/server/db/testsuitedb.py

284 ↗

(On Diff #221546)

Minor drive-by: s/verse/versus/;

tests/server/ui/test_api_modify.py

229 ↗

(On Diff #220979)

Something called through the call to unittest.main below.

[thopre]

Fix misses uses of cmp builtin

[hubert.reinterpretcast]

LGTM.

lnt/trunk/lnt/external/stats/pstat.py

for pair in listmap:
         else:   # must be a non-Object type array and replacement
             work = N.where(work==pair[0],pair[1],work)
             return N.concatenate([a[:,0:col],work[:,N.newaxis],a[:,col+1:]],1)
 
 
  def arowcompare(row1, row2):
     """
 Compares two rows from an array, regardless of whether it is an
-array of numbers or of python objects (which requires the cmp function).
+array of numbers or of python objects (which requires rich comparison
+method __eq__).
 @@@PURPOSE? 2007-11-26
 
 Usage:   arowcompare(row1,row2)
 Returns: an array of equal length containing 1s where the two rows had
          identical elements and 0 otherwise
 """
     return 
     if row1.dtype.char=='O' or row2.dtype=='O':
-        cmpvect = N.logical_not(abs(N.array(list(map(cmp, row1, row2))))) # cmp fcn gives -1,0,1
+        cmpvect = N.array([x == y for x, y in zip(row1, row2)])
     else:
         cmpvect = N.equal(row1,row2)
     return cmpvect
 
 
  def arowsame(row1, row2):
     """
 Compares two rows from an array, regardless of whether it is an
-array of numbers or of python objects (which requires the cmp function).
+array of numbers or of python objects (which requires rich comparison
+method __eq__).
 
 Usage:   arowsame(row1,row2)
 Returns: 1 if the two rows are identical, 0 otherwise.
 """
     cmpval = N.alltrue(arowcompare(row1,row2))
     return cmpval
 
 
else:                                  # IT MUST BE A 2+D ARRAY
                         uniques = N.concatenate( [uniques,item[N.newaxis,:]] )
                     except TypeError:    # the item to add isn't a list
                         uniques = N.concatenate([uniques,N.array([item])])
                 else:
                     pass  # this item is already in the uniques array
         else:   # must be an Object array, alltrue/equal functions don't work
             for item in inarray[1:]:
                 newflag = 1
-                for unq in uniques:  # NOTE: cmp --> 0=same, -1=<, 1=>
-                    test = N.sum(abs(N.array(list(map(cmp, item, unq)))))
+                for unq in uniques:
+                    test = N.sum(N.array([x == y for x, y in zip(item, unq)]))
                     if test == 0:   # if item identical to any 1 row in uniques
                         newflag = 0 # then not a novel item to add
                         break
                 if newflag == 1:
                     try:
                         uniques = N.concatenate( [uniques,item[N.newaxis,:]] )
                     except TypeError:    # the item to add isn't a list
                         uniques = N.concatenate([uniques,N.array([item])])

lnt/trunk/lnt/server/db/testsuitedb.py

 """
 Database models for the TestSuite databases themselves.
 
 These are a bit magical because the models themselves are driven by the test
 suite metadata, so we only create the classes at runtime.
 """
 
 from __future__ import absolute_import
 import datetime
 import json
 import os
+import itertools
 
 import aniso8601
 import sqlalchemy
 import flask
 from sqlalchemy import Float, String, Integer, Column, ForeignKey, Binary, DateTime
 from sqlalchemy.orm import relation
 from sqlalchemy.orm.exc import ObjectDeletedError
 from typing import List
def __init__(self, v4db, name, test_suite):
                 _dict_update_abort_on_duplicates(result, self.get_fields())
                 _dict_update_abort_on_duplicates(result, self.parameters)
                 return result
 
         class Order(self.base, ParameterizedMixin):
             __tablename__ = db_key_name + '_Order'
 
             # We guarantee that our fields are stored in the order they are
-            # supposed to be lexicographically compared, the __cmp__ method
-            # relies on this.
+            # supposed to be lexicographically compared, the rich comparison
+            # methods rely on this.
             fields = sorted(self.order_fields,
                             key=lambda of: of.ordinal)
 
             id = Column("ID", Integer, primary_key=True)
 
             # Define two common columns which are used to store the previous
             # and next links for the total ordering amongst run orders.
             next_order_id = Column("NextOrder", Integer, ForeignKey(id))
def __init__(self, v4db, name, test_suite):
                 return '(%s)' % (
                     ', '.join(self.get_field(field)
                               for field in self.fields),)
 
             @property
             def name(self):
                 return self.as_ordered_string()
 
-            def __cmp__(self, b):
+            def _get_comparison_discriminant(self, b):
+                """Return a representative pair of converted revision from self
+                and b. Order of the element on this pair is the same as the
+                order of self relative to b.
+                """
                 # SA occasionally uses comparison to check model instances
-                # verse some sentinels, so we ensure we support comparison
+                # versus some sentinels, so we ensure we support comparison
                 # against non-instances.
                 if self.__class__ is not b.__class__:
-                    return -1
-                # Compare every field in lexicographic order.
-                return cmp([convert_revision(self.get_field(item), cache=Order.order_name_cache)
-                            for item in self.fields],
-                           [convert_revision(b.get_field(item),  cache=Order.order_name_cache)
-                            for item in self.fields])
+                    return (0, 1)
+
+                # Pair converted revision from self and b.
+                converted_revisions = map(
+                    lambda item: (
+                        convert_revision(
+                            self.get_field(item), cache=Order.order_name_cache
+                        ),
+                        convert_revision(
+                            b.get_field(item), cache=Order.order_name_cache
+                        ),
+                    ),
+                    self.fields,
+                )
+                # Return the first unequal pair, or (0, 0) otherwise.
+                return next(
+                    itertools.dropwhile(lambda x: x[0] == x[1], converted_revisions),
+                    (0, 0),
+                )
+
+            def __eq__(self, b):
+                discriminant = self._get_comparison_discriminant(b)
+                return discriminant[0] == discriminant[1]
+
+            def __ne__(self, b):
+                discriminant = self._get_comparison_discriminant(b)
+                return discriminant[0] != discriminant[1]
+
+            def __lt__(self, b):
+                discriminant = self._get_comparison_discriminant(b)
+                return discriminant[0] < discriminant[1]
+
+            def __le__(self, b):
+                discriminant = self._get_comparison_discriminant(b)
+                return discriminant[0] <= discriminant[1]
+
+            def __gt__(self, b):
+                discriminant = self._get_comparison_discriminant(b)
+                return discriminant[0] > discriminant[1]
+
+            def __ge__(self, b):
+                discriminant = self._get_comparison_discriminant(b)
+                return discriminant[0] >= discriminant[1]
 
             def __json__(self, include_id=True):
                 result = {}
                 if include_id:
                     result['id'] = self.id
                 _dict_update_abort_on_duplicates(result, self.get_fields())
                 return result
 

lnt/trunk/tests/server/ui/test_api_modify.py

def test_04_merge_into(self):
         machine_3['runs'] = [_hashabledict(run) for run in machine_3['runs']]
         allruns = set(machine_1['runs']).union(machine_3['runs'])
         resp_3 = check_json(client, 'api/db_default/v4/nts/machines/3')
         resp_3['runs'] = [_hashabledict(run) for run in resp_3['runs']]
         self.assertEqual(set(resp_3['runs']), allruns)
 
 
 if __name__ == '__main__':
-    unittest.TestLoader.sortTestMethodsUsing = lambda _, x, y: cmp(x, y)
     unittest.main(argv=[sys.argv[0], ])

lnt/trunk/tests/server/ui/test_api_roundtrip.py

def test_roundtrip(self):
         reimported = check_json(client, new_location)
 
         # The 'id' field may be the different, the rest must be the same.
         reimported['run']['id'] = original['run']['id']
         self.assertEqual(original, reimported)
 
 
 if __name__ == '__main__':
-    unittest.TestLoader.sortTestMethodsUsing = lambda _, x, y: cmp(x, y)
     unittest.main(argv=[sys.argv[0], ])