[LNT] Python 3 support: replace xrange with Python3's range

[thopre]

Summary

Use Python 3's range instead of xrange by importing it from builtins.
Also encapsulate existing uses of range into a call to list since it
returns an immutable sequence type in Python 3. This was produced by
running futurize's stage2 libfuturize.fixes.fix_xrange_with_import.

[thopre]

Ping?

[thopre]

Ping?

[thopre]

Ping?

[thopre]

Ping?

[thopre]

Ping?

[thopre]

Rebase later in the patch series

[PrzemekWirkus]

LGTM

[thopre]

Rebase earlier in the patch series

[thopre]

Committed as a5e7fc6c571ec4d702c551b2252259298e84b361

lnt/external/stats/stats.py

"""
     TINY = 1e-30
     if len(x) != len(y):
         raise ValueError('INPUT VALUES NOT PAIRED IN pointbiserialr.  ABORTING.')
     data = pstat.abut(x, y)
     categories = pstat.unique(x)
     if len(categories) != 2:
         raise ValueError("Exactly 2 categories required for pointbiserialr().")
     else:   # there are 2 categories, continue
-        codemap = pstat.abut(categories, range(2))
+        codemap = pstat.abut(categories, list(range(2)))
         recoded = pstat.recode(data, codemap, 0)
         x = pstat.linexand(data, 0, categories[0])
         y = pstat.linexand(data, 0, categories[1])
         xmean = mean(pstat.colex(x, 1))
         ymean = mean(pstat.colex(y, 1))
         n = len(data)
         adjust = math.sqrt((len(x)/float(n))*(len(y)/float(n)))
         rpb = (ymean - xmean)/samplestdev(pstat.colex(data, 1))*adjust
def lshellsort(inlist):
     """
 Shellsort algorithm.  Sorts a 1D-list.
 
 Usage:   lshellsort(inlist)
 Returns: sorted-inlist, sorting-index-vector (for original list)
 """
     n = len(inlist)
     svec = copy.deepcopy(inlist)
-    ivec = range(n)
+    ivec = list(range(n))
     gap = n // 2   # integer division needed
     while gap >0:
         for i in range(gap, n):
             for j in range(i-gap, -1, -gap):
                 while j>=0 and svec[j]>svec[j+gap]:
                     temp        = svec[j]
                     svec[j]     = svec[j+gap]
                     svec[j+gap] = temp
def ashellsort(inarray):
     """
 Shellsort algorithm.  Sorts a 1D-array.
 
 Usage:   ashellsort(inarray)
 Returns: sorted-inarray, sorting-index-vector (for original array)
 """
     n = len(inarray)
     svec = inarray *1.0
-    ivec = range(n)
+    ivec = list(range(n))
     gap = n // 2   # integer division needed
     while gap >0:
         for i in range(gap, n):
             for j in range(i-gap, -1, -gap):
                 while j>=0 and svec[j]>svec[j+gap]:
                     temp        = svec[j]
                     svec[j]     = svec[j+gap]
                     svec[j+gap] = temp

lnt/testing/profile/profilev2impl.py

 from __future__ import absolute_import
+from builtins import range
 from .profile import ProfileImpl
 import StringIO
 import bz2
 import copy
 import io
 import os
 import struct
 

 class CounterNamePool(Section):
     """
     Maps counter names to indices. It allows later sections to refer to
     counters by index.
     """
     def serialize(self, fobj):
         n_names = len(self.idx_to_name)
         writeNum(fobj, n_names)
-        for i in xrange(n_names):
+        for i in range(n_names):
             writeString(fobj, self.idx_to_name[i])
 
     def deserialize(self, fobj):
         self.idx_to_name = {}
-        for i in xrange(readNum(fobj)):
+        for i in range(readNum(fobj)):
             self.idx_to_name[i] = readString(fobj)
         self.name_to_idx = {v: k
                             for k, v
                             in self.idx_to_name.items()}
 
     def upgrade(self, impl):
         self.idx_to_name = {}
 
class TopLevelCounters(Section):
     def serialize(self, fobj):
         writeNum(fobj, len(self.counters))
         for k, v in sorted(self.counters.items()):
             writeNum(fobj, self.counter_name_pool.name_to_idx[k])
             writeNum(fobj, int(v))
 
     def deserialize(self, fobj):
         self.counters = {}
-        for i in xrange(readNum(fobj)):
+        for i in range(readNum(fobj)):
             k = readNum(fobj)
             v = readNum(fobj)
             self.counters[self.counter_name_pool.idx_to_name[k]] = v
 
     def upgrade(self, impl):
         self.counters = impl.data['counters'].copy()
 
     def copy(self, cnp):
def serialize(self, fobj):
 
             writeNum(fobj, len(f['counters']))
             for k, v in sorted(f['counters'].items()):
                 writeNum(fobj, self.counter_name_pool.name_to_idx[k])
                 writeFloat(fobj, v)
 
     def deserialize(self, fobj):
         self.functions = {}
-        for i in xrange(readNum(fobj)):
+        for i in range(readNum(fobj)):
             f = {}
             name = readString(fobj)
             f['length'] = readNum(fobj)
             self.line_counters.setOffsetFor(name, readNum(fobj))
             self.line_addresses.setOffsetFor(name, readNum(fobj))
             self.line_text.setOffsetFor(name, readNum(fobj))
             f['counters'] = {}
 
-            for j in xrange(readNum(fobj)):
+            for j in range(readNum(fobj)):
                 k = self.counter_name_pool.idx_to_name[readNum(fobj)]
                 v = readFloat(fobj)
                 f['counters'][k] = v
 
             self.functions[name] = f
 
     def upgrade(self, impl):
         self.impl = impl
         self.functions = self.impl.getFunctions()
 
     def getCodeForFunction(self, fname):
         f = self.functions[fname]
         counter_gen = self.line_counters \
             .extractForFunction(fname, list(f['counters'].keys()))
         address_gen = self.line_addresses.extractForFunction(fname)
         text_gen = self.line_text.extractForFunction(fname)
-        for n in xrange(f['length']):
+        for n in range(f['length']):
             yield (next(counter_gen), next(address_gen), next(text_gen))
 
     def copy(self, counter_name_pool, line_counters,
              line_addresses, line_text):
         new = copy.copy(self)
         new.counter_name_pool = counter_name_pool
         new.line_counters = line_counters
         new.line_addresses = line_addresses

lnt/tests/nt.py

def rerun_test(config, name, num_times):
     test_full_path = os.path.join(
         config.report_dir, relative_test_path)
 
     assert os.path.exists(test_full_path), \
         "Previous test directory not there?" + test_full_path
 
     results = []
     no_errors = True
-    for _ in xrange(0, num_times):
+    for _ in range(0, num_times):
         test_results, t_no_errors = _execute_test_again(
             config, test_name, test_full_path, relative_test_path, logfile)
         no_errors &= t_no_errors
         results.extend(test_results)
 
     # Check we got an exec and status from each run.
     assert len(results) >= num_times, \
         "Did not get all the runs?" + str(results)

tests/utils/blast.py

 """
 Smash a LNT instance with random submissions.
 
 This should only be used for (load) testing.  It will add a bunch
 of bad data to your instance, so don't use it on a production instance.
 """
 from __future__ import print_function
 ## Just to make sure there are no syntax errors in this.  This does not
 ## actually run a blast.
 # RUN: python %{src_root}/tests/utils/blast.py
+from builtins import range
 import time
 import subprocess
 import os
 import lnt.testing
 import tempfile
 import random
 import sys
 
def external_submission(url, fname):
     print("Calling " + cmd)
     subprocess.check_call(cmd, shell=True)
 
 
 def rand_sample():
     """Make a random sized list of random samples."""
     r = random.randint(1, 20)
     samples = []
-    for i in xrange(r):
+    for i in range(r):
         samples.append(random.random() * 100)
     return samples
 
 
 run_info = {'tag': 'nts'}
 
 start_time = "2015-11-11 22:04:09"
 end_time = "2015-11-11 23:04:09"
 MACH = "LNTLoadTest-Blast"
 DEFAULT_MACHINE_INFO = {'hardware': '', 'os': 'darwin'}
 # Setup our run_order since it is an info_key.
 # run_info_copy = dict(run_info)
 tstamp = int(time.time())
 run_info['run_order'] = tstamp
 
 if len(sys.argv) < 3:
     print("Usage: python blast.py <num_submissions> <sleep_between> [optional url]")
     sys.exit(0)
 
-for i in xrange(int(sys.argv[1])):
+for i in range(int(sys.argv[1])):
     machine = lnt.testing.Machine(MACH, DEFAULT_MACHINE_INFO)
     run = lnt.testing.Run(start_time, end_time, run_info)
     report = lnt.testing.Report(machine=machine, run=run, tests=[])
 
     for t in TESTS:
         full_test_name = "nts.{}.compile".format(t)
         tests = lnt.testing.TestSamples(full_test_name, rand_sample())
         report.tests.append(tests)