[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

2026–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

2026–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.reverse()
+        dims = sorted(dimension, reverse=True)
         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:
                 shp[dim] = 1
"""
     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.reverse()
+        dims = sorted(dimension, reverse=True)
         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:
                 shp[dim] = 1
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.reverse()
+        dims = sorted(dimension, reverse=True)
         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
             s = N.reshape(s,shp)
      return s
 
 
  def acumsum (a,dimension=None):
     """
 Returns an array consisting of the cumulative sum of the items in the
 passed array.  Dimension can equal None (ravel array first), an
 integer (the dimension over which to operate), or a sequence (operate
 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.reverse()
+        dimension = sorted(dimension, reverse=True)
         for d in dimension:
             a = N.add.accumulate(a,d)
         return a
     else:
         return N.add.accumulate(a,dimension)
 
 
  def ass(inarray, dimension=None, keepdims=0):

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