[LNT] Python 3 support: use Python 3 idioms

[thopre]

Summary

Replace Python 2 idioms for their Python 3 counterparts. These includes:

• replace calls to X.sort() optionally followed by .reverse() by calls to sorted(X)
• replace while 1 by while True

This was produced by running futurize's stage1 lib2to3.fixes.fix_idioms.

[hubert.reinterpretcast]

lnt/external/stats/stats.py

2027

Should this sort be updated to sort in the desired order instead of calling reverse() after?

[thopre]

Fold .reverse() into sorted()

[thopre]

lnt/external/stats/stats.py

2027

Good catch and good idea! Done.

[hubert.reinterpretcast]

LGTM.

lnt/external/stats/pstat.py

if keepcols == []:
                      test = 'N/A'
                  try:
                      means[i] = means[i] + [len(avgcol)]
                  except TypeError:
                      means[i] = [means[i],len(avgcol)]
          return means
      else:
          values = colex(listoflists,keepcols)
-         uniques = unique(values)
-         uniques.sort()
+         uniques = sorted(unique(values))
          newlist = []
          if not isinstance(keepcols, (list, tuple)):  keepcols = [keepcols]
          for item in uniques:
              if not isinstance(item, (list, tuple)):  item =[item]
              tmprows = linexand(listoflists,keepcols,item)
              for col in collapsecols:
                  avgcol = colex(tmprows,col)
                  item.append(cfcn(avgcol))

 def sortby(listoflists,sortcols):
     """
 Sorts a list of lists on the column(s) specified in the sequence
 sortcols.
 
 Usage:   sortby(listoflists,sortcols)
 Returns: sorted list, unchanged column ordering
 """
-    newlist = abut(colex(listoflists,sortcols),listoflists)
-    newlist.sort()
+    newlist = sorted(abut(colex(listoflists, sortcols), listoflists))
     try:
         numcols = len(sortcols)
     except TypeError:
         numcols = 1
     crit = '[' + str(numcols) + ':]'
     newlist = colex(newlist,crit)
     return newlist
 
if keepcols == []:
             except:
                 test = N.array(['N/A']*len(means))
             means = aabut(means,test)
         return means
     else:
         if not isinstance(keepcols, (list, tuple, N.ndarray)):
             keepcols = [keepcols]
         values = colex(a,keepcols)   # so that "item" can be appended (below)
-        uniques = unique(values)  # get a LIST, so .sort keeps rows intact
-        uniques.sort()
+        uniques = sorted(unique(values))  # get a LIST, so .sort keeps rows intact
         newlist = []
         for item in uniques:
             if not isinstance(item, (list, tuple, N.ndarray)):
                 item =[item]
             tmprows = alinexand(a,keepcols,item)
             for col in collapsecols:
                 avgcol = acolex(tmprows,col)
                 item.append(acollmean(avgcol))

lnt/external/stats/stats.py

 def lmedianscore (inlist):
     """
 Returns the 'middle' score of the passed list.  If there is an even
 number of scores, the mean of the 2 middle scores is returned.
 
 Usage:   lmedianscore(inlist)
 """
 
-    newlist = copy.deepcopy(inlist)
-    newlist.sort()
+    newlist = sorted(copy.deepcopy(inlist))
     if len(newlist) % 2 == 0:   # if even number of scores, average middle 2
         index = len(newlist)/2  # integer division correct
         median = float(newlist[index] + newlist[index-1]) /2
     else:
         index = len(newlist)/2  # int divsion gives mid value when count from 0
         median = newlist[index]
     return median
 
 
 def lmode(inlist):
     """
 Returns a list of the modal (most common) score(s) in the passed
 list.  If there is more than one such score, all are returned.  The
 bin-count for the mode(s) is also returned.
 
 Usage:   lmode(inlist)
 Returns: bin-count for mode(s), a list of modal value(s)
 """
 
-    scores = pstat.unique(inlist)
-    scores.sort()
+    scores = sorted(pstat.unique(inlist))
     freq = []
     for item in scores:
         freq.append(inlist.count(item))
     maxfreq = max(freq)
     mode = []
     stillmore = 1
     while stillmore:
         try:

 def litemfreq(inlist):
     """
 Returns a list of pairs.  Each pair consists of one of the scores in inlist
 and it's frequency count.  Assumes a 1D list is passed.
 
 Usage:   litemfreq(inlist)
 Returns: a 2D frequency table (col [0:n-1]=scores, col n=frequencies)
 """
-    scores = pstat.unique(inlist)
-    scores.sort()
+    scores = sorted(pstat.unique(inlist))
     freq = []
     for item in scores:
         freq.append(inlist.count(item))
     return pstat.abut(scores, freq)
 
 
 def lscoreatpercentile (inlist, percent):
     """
elif isinstance(dimension, (int, float)):
         size = inarray.shape[dimension]
         mult = N.power(inarray,1.0/size)
         mult = N.multiply.reduce(mult,dimension)
         if keepdims == 1:
             shp = list(inarray.shape)
             shp[dimension] = 1
             sum = N.reshape(sum,shp)
     else: # must be a SEQUENCE of dims to average over
-        dims = list(dimension)
-        dims.sort()
+        dims = sorted(dimension)
         dims.reverse()
         size = N.array(N.multiply.reduce(N.take(inarray.shape,dims)),N.float_)
         mult = N.power(inarray,1.0/size)
         for dim in dims:
             mult = N.multiply.reduce(mult,dim)
         if keepdims == 1:
             shp = list(inarray.shape)
             for dim in dims:
"""
     elif isinstance(dimension, (int, float)):
         size = float(inarray.shape[dimension])
         s = N.add.reduce(1.0/inarray, dimension)
         if keepdims == 1:
             shp = list(inarray.shape)
             shp[dimension] = 1
             s = N.reshape(s,shp)
     else: # must be a SEQUENCE of dims to average over
-        dims = list(dimension)
-        dims.sort()
+        dims = sorted(dimension)
         nondims = []
         for i in range(len(inarray.shape)):
             if i not in dims:
                 nondims.append(i)
         tinarray = N.transpose(inarray,nondims+dims) # put keep-dims first
         idx = [0] *len(nondims)
         if idx == []:
             size = len(N.ravel(inarray))
"""
     elif isinstance(dimension, (int, float)):
         sum = asum(inarray,dimension)
         denom = float(inarray.shape[dimension])
         if keepdims == 1:
             shp = list(inarray.shape)
             shp[dimension] = 1
             sum = N.reshape(sum,shp)
     else: # must be a TUPLE of dims to average over
-        dims = list(dimension)
-        dims.sort()
+        dims = sorted(dimension)
         dims.reverse()
         sum = inarray *1.0
         for dim in dims:
             sum = N.add.reduce(sum,dim)
         denom = N.array(N.multiply.reduce(N.take(inarray.shape,dims)),N.float_)
         if keepdims == 1:
             shp = list(inarray.shape)
             for dim in dims:
if dimension is None:
          s = N.sum(N.ravel(a))
      elif isinstance(dimension, (int, float)):
          s = N.add.reduce(a, dimension)
          if keepdims == 1:
              shp = list(a.shape)
              shp[dimension] = 1
              s = N.reshape(s,shp)
      else: # must be a SEQUENCE of dims to sum over
-        dims = list(dimension)
-        dims.sort()
+        dims = sorted(dimension)
         dims.reverse()
         s = a *1.0
         for dim in dims:
             s = N.add.reduce(s,dim)
         if keepdims == 1:
             shp = list(a.shape)
             for dim in dims:
                 shp[dim] = 1

 over multiple dimensions, but this last one just barely makes sense).
 
 Usage:   acumsum(a,dimension=None)
 """
     if dimension is None:
         a = N.ravel(a)
         dimension = 0
     if isinstance(dimension, (list, tuple, N.ndarray)):
-        dimension = list(dimension)
-        dimension.sort()
+        dimension = sorted(dimension)
         dimension.reverse()
         for d in dimension:
             a = N.add.accumulate(a,d)
         return a
     else:
         return N.add.accumulate(a,dimension)
 
 

lnt/server/db/testsuitedb.py

def _getOrCreateOrder(self, session, run_parameters):
 
         # If not, then we need to insert this order into the total ordering
         # linked list.
 
         # Add the new order and commit, to assign an ID.
         session.add(order)
         session.commit()
 
-        # Load all the orders.
-        orders = list(session.query(self.Order))
-
-        # Sort the objects to form the total ordering.
-        orders.sort()
+        # Load all the orders and sort them to form the total ordering.
+        orders = sorted(session.query(self.Order))
 
         # Find the order we just added.
         index = orders.index(order)
 
         # Insert this order into the linked list which forms the total
         # ordering.
         if index > 0:
             previous_order = orders[index - 1]
def get_adjacent_runs_on_machine(self, session, run, N, direction=-1):
         # better in the worst cast, and I prefer that response times be
         # uniform. In practice, this appears to perform fine even for quite
         # large (~1GB, ~20k runs) databases.
 
         # Find all the orders on this machine, then sort them.
         #
         # FIXME: Scalability! However, pretty fast in practice, see elaborate
         # explanation above.
-        all_machine_orders = session.query(self.Order).\
-            join(self.Run).\
-            filter(self.Run.machine == run.machine).distinct().all()
-        all_machine_orders.sort()
+        all_machine_orders = sorted(
+            session.query(self.Order)
+            .join(self.Run)
+            .filter(self.Run.machine == run.machine)
+            .distinct()
+            .all()
+        )
 
         # Find the index of the current run.
         index = all_machine_orders.index(run.order)
 
         # Gather the next N orders.
         if direction == -1:
             orders_to_return = all_machine_orders[max(0, index - N):index]
         else:

lnt/server/ui/util.py

def all_false(list, predicate):
     return not any_true(list, predicate)
 
 
 def mean(values):
     return sum(values) / len(values)
 
 
 def median(values):
-    values = list(values)
-    values.sort()
+    values = sorted(values)
     N = len(values)
     return (values[(N - 1) // 2] +
             values[(N + 0) // 2]) * .5
 
 
 def prependLines(prependStr, str):
     return ('\n' + prependStr).join(str.splitlines())
 

lnt/server/ui/views.py

def v4_machine(id):
     ts = request.get_testsuite()
 
     associated_runs = multidict.multidict(
         (run_order, r)
         for r, run_order in (session.query(ts.Run, ts.Order)
                              .join(ts.Order)
                              .filter(ts.Run.machine_id == id)
                              .order_by(ts.Run.start_time.desc())))
-    associated_runs = associated_runs.items()
-    associated_runs.sort()
+    associated_runs = sorted(associated_runs.items())
 
     try:
         machine = session.query(ts.Machine).filter(ts.Machine.id == id).one()
     except NoResultFound:
         abort(404)
 
     if request.args.get('json'):
         json_obj = dict()

 
 
 @v4_route("/all_orders")
 def v4_all_orders():
     # Get the testsuite.
     session = request.session
     ts = request.get_testsuite()
 
-    # Get the orders.
-    orders = session.query(ts.Order).all()
-
-    # Order the runs totally.
-    orders.sort()
+    # Get the orders and sort them totally.
+    orders = sorted(session.query(ts.Order).all())
 
     return render_template("v4_all_orders.html", orders=orders, **ts_data(ts))
 
 
 @v4_route("/<int:id>/graph")
 def v4_run_graph(id):
     # This is an old style endpoint that treated graphs as associated with
     # runs. Redirect to the new endpoint.

lnt/util/stats.py

def agg_mean(pairs):
     if counter > 0:
         return my_sum / counter, 0
     return None, None
 
 
 def median(values):
     if not values:
         return None
-    values = list(values)
-    values.sort()
+    values = sorted(values)
     N = len(values)
     return (values[(N - 1) // 2] + values[N // 2]) * .5
 
 
 def median_absolute_deviation(values, med=None):
     if med is None:
         med = median(values)
     return median([abs(x - med) for x in values])

lnt/util/wsgi_restart.py

except Exception:
         # been removed just before stat(), so force a restart.
 
         return True
 
     return False
 
 
 def _monitor():
-    while 1:
+    while True:
         # Check modification times on all files in sys.modules.
 
         for module in sys.modules.values():
             if not hasattr(module, '__file__'):
                 continue
             path = getattr(module, '__file__')
             if not path:
                 continue