[LNT] Python 3 support: print statements

[hubert.reinterpretcast]

Summary

This patch applies 2to3 -f print fixes, corrects the indentation mangled by 2to3 for multiline print statements, and adds from __future__ import print_function to each file that was modified. As requested on review, spaces are then added after commas separating arguments to print, separating function call arguments or tuple elements within arguments to print, etc.

The changes cover the files found to be affected when running tests (without result submission).

[thopre]

Could you take advantage of the change to consistently have a whitespace between comma and the next argument?

BTW thanks for working on this, I was working myself on a patch series to port LNT to python3, in the process of cleaning up that said patch series.

[cmatthews]

LGTM. Thanks!

[hubert.reinterpretcast]

In D67532#1669054, @thopre wrote:

Could you take advantage of the change to consistently have a whitespace between comma and the next argument?

I'll commit this with the requested whitespace change.

[hubert.reinterpretcast]

Add spaces after commas in calls to print

Spaces are added after commas separating arguments to print, separating function call arguments or tuple elements within arguments to print, etc.

[hubert.reinterpretcast]

• Handle one more case of missing space after comma

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

 ## 12/05/98 ... updated doc-strings
 ##              added features to collapse() function
 ##              added flat() function for lists
 ##              fixed a broken asortrows() 
 ## 11/16/98 ... fixed minor bug in aput for 1D arrays
 ##
 ## 11/08/98 ... fixed aput to output large arrays correctly
 
+from __future__ import print_function
 import stats  # required 3rd party module
 import string, copy
 from types import *
 
 __version__ = 0.4
 
 ###===========================  LIST FUNCTIONS  ==========================
 ###
for row in rowstokill:
         del list2print[row]
     maxsize = [0]*len(list2print[0])
     for col in range(len(list2print[0])):
         items = colex(list2print,col)
         items = map(makestr,items)
         maxsize[col] = max(map(len,items)) + extra
     for row in lst:
         if row == ['\n'] or row == '\n' or row == '' or row == ['']:
-            print
+            print()
         elif row == ['dashes'] or row == 'dashes':
             dashes = [0]*len(maxsize)
             for j in range(len(maxsize)):
                 dashes[j] = '-'*(maxsize[j]-2)
-            print lineincustcols(dashes,maxsize)
+            print(lineincustcols(dashes, maxsize))
         else:
-            print lineincustcols(row,maxsize)
+            print(lineincustcols(row, maxsize))
     return None
 
 
 def printincols (listoflists,colsize):
     """
 Prints a list of lists in columns of (fixed) colsize width, where
 colsize is an integer.
 
 Usage:   printincols (listoflists,colsize)
 Returns: None
 """
     for row in listoflists:
-        print lineincols(row,colsize)
+        print(lineincols(row, colsize))
     return None
 
 
 def pl (listoflists):
     """
 Prints a list of lists, 1 list (row) at a time.
 
 Usage:   pl(listoflists)
 Returns: None
 """
     for row in listoflists:
         if row[-1] == '\n':
-            print row,
+            print(row, end=' ')
         else:
-            print row
+            print(row)
     return None
 
 
 def printl(listoflists):
     """Alias for pl."""
     pl(listoflists)
     return
 

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

 allows different functions to be called depending on the type of the passed
 arguments.  Thus, stats.mean is a member of the Dispatch class and
 stats.mean(range(20)) will call stats.lmean(range(20)) while
 stats.mean(Numeric.arange(20)) will call stats.amean(Numeric.arange(20)).
 This is a handy way to keep consistent function names when different
 argument types require different functions to be called.  Having
 implementated the Dispatch class, however, means that to get info on
 a given function, you must use the REAL function name ... that is
-"print stats.lmean.__doc__" or "print stats.amean.__doc__" work fine,
-while "print stats.mean.__doc__" will print the doc for the Dispatch
+"print(stats.lmean.__doc__)" or "print(stats.amean.__doc__)" work fine,
+while "print(stats.mean.__doc__)" will print the doc for the Dispatch
 class.  NUMPY FUNCTIONS ('a' prefix) generally have more argument options
 but should otherwise be consistent with the corresponding list functions.
 
 Disclaimers:  The function list is obviously incomplete and, worse, the
 functions are not optimized.  All functions have been tested (some more
 so than others), but they are far from bulletproof.  Thus, as with any
 free software, no warranty or guarantee is expressed or implied. :-)  A
 few extra functions that don't appear in the list below can be found by

 ## 12/01/98 ... added anova() function (requires NumPy)
 ##              incorporated Dispatch class
 ## 11/12/98 ... added functionality to amean, aharmonicmean, ageometricmean
 ##              added 'asum' function (added functionality to N.add.reduce)
 ##              fixed both moment and amoment (two errors)
 ##              changed name of skewness and askewness to skew and askew
 ##              fixed (a)histogram (which sometimes counted points <lowerlimit)
 
+from __future__ import print_function
 import pstat               # required 3rd party module
 import math, string, copy  # required python modules
 from types import *
 
 __version__ = 0.6
 
 ############# DISPATCH CODE ##############
 

 def lscoreatpercentile (inlist, percent):
     """
 Returns the score at a given percentile relative to the distribution
 given by inlist.
 
 Usage:   lscoreatpercentile(inlist,percent)
 """
     if percent > 1:
-        print "\nDividing percent>1 by 100 in lscoreatpercentile().\n"
+        print("\nDividing percent>1 by 100 in lscoreatpercentile().\n")
         percent = percent / 100.0
     targetcf = percent*len(inlist)
     h, lrl, binsize, extras = histogram(inlist)
     cumhist = cumsum(copy.deepcopy(h))
     for i in range(len(cumhist)):
         if cumhist[i] >= targetcf:
             break
     score = binsize * ((targetcf - cumhist[i-1]) / float(h[i])) + (lrl+binsize*i)
for num in inlist:
             if (num-lowerreallimit) < 0:
                 extrapoints = extrapoints + 1
             else:
                 bintoincrement = int((num-lowerreallimit)/float(binsize))
                 bins[bintoincrement] = bins[bintoincrement] + 1
         except:
             extrapoints = extrapoints + 1
     if (extrapoints > 0 and printextras == 1):
-        print '\nPoints outside given histogram range =',extrapoints
+        print('\nPoints outside given histogram range =', extrapoints)
     return (bins, lowerreallimit, binsize, extrapoints)
 
 
 def lcumfreq(inlist,numbins=10,defaultreallimits=None):
     """
 Returns a cumulative frequency histogram, using the histogram function.
 
 Usage:   lcumfreq(inlist,numbins=10,defaultreallimits=None)

 Interactively determines the type of data and then runs the
 appropriated statistic for paired group data.
 
 Usage:   lpaired(x,y)
 Returns: appropriate statistic name, value, and probability
 """
     samples = ''
     while samples not in ['i','r','I','R','c','C']:
-        print '\nIndependent or related samples, or correlation (i,r,c): ',
+        print('\nIndependent or related samples, or correlation (i,r,c): ', end=' ')
         samples = raw_input()
 
     if samples in ['i','I','r','R']:
-        print '\nComparing variances ...',
+        print('\nComparing variances ...', end=' ')
 # USE O'BRIEN'S TEST FOR HOMOGENEITY OF VARIANCE, Maxwell & delaney, p.112
         r = obrientransform(x,y)
         f,p = F_oneway(pstat.colex(r,0),pstat.colex(r,1))
         if p<0.05:
             vartype='unequal, p='+str(round(p,4))
         else:
             vartype='equal'
-        print vartype
+        print(vartype)
         if samples in ['i','I']:
             if vartype[0]=='e':
                 t,p = ttest_ind(x,y,0)
-                print '\nIndependent samples t-test:  ', round(t,4),round(p,4)
+                print('\nIndependent samples t-test:  ', round(t, 4), round(p, 4))
             else:
                 if len(x)>20 or len(y)>20:
                     z,p = ranksums(x,y)
-                    print '\nRank Sums test (NONparametric, n>20):  ', round(z,4),round(p,4)
+                    print('\nRank Sums test (NONparametric, n>20):  ', round(z, 4), round(p, 4))
                 else:
                     u,p = mannwhitneyu(x,y)
-                    print '\nMann-Whitney U-test (NONparametric, ns<20):  ', round(u,4),round(p,4)
+                    print('\nMann-Whitney U-test (NONparametric, ns<20):  ', round(u, 4), round(p, 4))
 
         else:  # RELATED SAMPLES
             if vartype[0]=='e':
                 t,p = ttest_rel(x,y,0)
-                print '\nRelated samples t-test:  ', round(t,4),round(p,4)
+                print('\nRelated samples t-test:  ', round(t, 4), round(p, 4))
             else:
                 t,p = ranksums(x,y)
-                print '\nWilcoxon T-test (NONparametric):  ', round(t,4),round(p,4)
+                print('\nWilcoxon T-test (NONparametric):  ', round(t, 4), round(p, 4))
     else:  # CORRELATION ANALYSIS
         corrtype = ''
         while corrtype not in ['c','C','r','R','d','D']:
-            print '\nIs the data Continuous, Ranked, or Dichotomous (c,r,d): ',
+            print('\nIs the data Continuous, Ranked, or Dichotomous (c,r,d): ', end=' ')
             corrtype = raw_input()
         if corrtype in ['c','C']:
             m,b,r,p,see = linregress(x,y)
-            print '\nLinear regression for continuous variables ...'
+            print('\nLinear regression for continuous variables ...')
             lol = [['Slope','Intercept','r','Prob','SEestimate'],[round(m,4),round(b,4),round(r,4),round(p,4),round(see,4)]]
             pstat.printcc(lol)
         elif corrtype in ['r','R']:
             r,p = spearmanr(x,y)
-            print '\nCorrelation for ranked variables ...'
-            print "Spearman's r: ",round(r,4),round(p,4)
+            print('\nCorrelation for ranked variables ...')
+            print("Spearman's r: ", round(r, 4), round(p, 4))
         else: # DICHOTOMOUS
             r,p = pointbiserialr(x,y)
-            print '\nAssuming x contains a dichotomous variable ...'
-            print 'Point Biserial r: ',round(r,4),round(p,4)
-    print '\n\n'
+            print('\nAssuming x contains a dichotomous variable ...')
+            print('Point Biserial r: ', round(r, 4), round(p, 4))
+    print('\n\n')
     return None
 
 
 def lpearsonr(x,y):
     """
 Calculates a Pearson correlation coefficient and the associated
 probability value.  Taken from Heiman's Basic Statistics for the Behav.
 Sci (2nd), p.195.
for i in range(ITMAX+1):
         bpp = bp+d*bz
         aold = az
         am = ap/bpp
         bm = bp/bpp
         az = app/bpp
         bz = 1.0
         if (abs(az-aold)<(EPS*abs(az))):
             return az
-    print 'a or b too big, or ITMAX too small in Betacf.'
+    print('a or b too big, or ITMAX too small in Betacf.')
 
 
 def lgammln(xx):
     """
 Returns the gamma function of xx.
     Gamma(z) = Integral(0,infinity) of t^(z-1)exp(-t) dt.
 (Adapted from: Numerical Recipies in C.)
 
except:
         pass
     if  prob < 0.001:  suffix = '  ***'
     elif prob < 0.01:  suffix = '  **'
     elif prob < 0.05:  suffix = '  *'
     title = [['Name','N','Mean','SD','Min','Max']]
     lofl = title+[[name1,n1,round(m1,3),round(math.sqrt(se1),3),min1,max1],
                   [name2,n2,round(m2,3),round(math.sqrt(se2),3),min2,max2]]
     if type(fname)<>StringType or len(fname)==0:
-        print
-        print statname
-        print
+        print()
+        print(statname)
+        print()
         pstat.printcc(lofl)
-        print
+        print()
         try:
             if stat.shape == ():
                 stat = stat[0]
             if prob.shape == ():
                 prob = prob[0]
         except:
             pass
-        print 'Test statistic = ',round(stat,3),'   p = ',round(prob,3),suffix
-        print
+        print('Test statistic = ', round(stat, 3), '   p = ', round(prob, 3), suffix)
+        print()
     else:
         file = open(fname,writemode)
         file.write('\n'+statname+'\n\n')
         file.close()
         writecc(lofl,fname,'a')
         file = open(fname,'a')
         try:
             if stat.shape == ():

 dimensions).
 
 Usage:   askew(a, dimension=None)
 Returns: skew of vals in a along dimension, returning ZERO where all vals equal
 """
     denom = N.power(amoment(a,2,dimension),1.5)
     zero = N.equal(denom,0)
     if type(denom) == N.ndarray and asum(zero) <> 0:
-        print "Number of zeros in askew: ",asum(zero)
+        print("Number of zeros in askew: ", asum(zero))
     denom = denom + zero  # prevent divide-by-zero
     return N.where(zero, 0, amoment(a,3,dimension)/denom)
 
 
  def akurtosis(a,dimension=None):
     """
 Returns the kurtosis of a distribution (normal ==> 3.0; >3 means
 heavier in the tails, and usually more peaked).  Use akurtosistest()
 to see if it's close enough.  Dimension can equal None (ravel array
 first), an integer (the dimension over which to operate), or a
 sequence (operate over multiple dimensions).
 
 Usage:   akurtosis(a,dimension=None)
 Returns: kurtosis of values in a along dimension, and ZERO where all vals equal
 """
     denom = N.power(amoment(a,2,dimension),2)
     zero = N.equal(denom,0)
     if type(denom) == N.ndarray and asum(zero) <> 0:
-        print "Number of zeros in akurtosis: ",asum(zero)
+        print("Number of zeros in akurtosis: ", asum(zero))
     denom = denom + zero  # prevent divide-by-zero
     return N.where(zero,0,amoment(a,4,dimension)/denom)
 
 
  def adescribe(inarray,dimension=None):
      """
 Returns several descriptive statistics of the passed array.  Dimension
 can equal None (ravel array first), an integer (the dimension over

 Usage:   akurtosistest(a,dimension=None)
 Returns: z-score and 2-tail z-probability, returns 0 for bad pixels
 """
     if dimension == None:
         a = N.ravel(a)
         dimension = 0
     n = float(a.shape[dimension])
     if n<20:
-        print "akurtosistest only valid for n>=20 ... continuing anyway, n=",n
+        print("akurtosistest only valid for n>=20 ... continuing anyway, n=", n)
     b2 = akurtosis(a,dimension)
     E = 3.0*(n-1) /(n+1)
     varb2 = 24.0*n*(n-2)*(n-3) / ((n+1)*(n+1)*(n+3)*(n+5))
     x = (b2-E)/N.sqrt(varb2)
     sqrtbeta1 = 6.0*(n*n-5*n+2)/((n+7)*(n+9)) * N.sqrt((6.0*(n+3)*(n+5))/
                                                        (n*(n-2)*(n-3)))
     A = 6.0 + 8.0/sqrtbeta1 *(2.0/sqrtbeta1 + N.sqrt(1+4.0/(sqrtbeta1**2)))
     term1 = 1 -2/(9.0*A)
for num in inarray:
             if (num-lowerreallimit) < 0:
                 extrapoints = extrapoints + 1
             else:
                 bintoincrement = int((num-lowerreallimit) / float(binsize))
                 bins[bintoincrement] = bins[bintoincrement] + 1
         except:                           # point outside lower/upper limits
             extrapoints = extrapoints + 1
     if (extrapoints > 0 and printextras == 1):
-        print '\nPoints outside given histogram range =',extrapoints
+        print('\nPoints outside given histogram range =', extrapoints)
     return (bins, lowerreallimit, binsize, extrapoints)
 
 
  def acumfreq(a,numbins=10,defaultreallimits=None):
     """
 Returns a cumulative frequency histogram, using the histogram function.
 Defaultreallimits can be None (use all data), or a 2-sequence containing
 lower and upper limits on values to include.

 Interactively determines the type of data in x and y, and then runs the
 appropriated statistic for paired group data.
 
 Usage:   apaired(x,y)     x,y = the two arrays of values to be compared
 Returns: appropriate statistic name, value, and probability
 """
     samples = ''
     while samples not in ['i','r','I','R','c','C']:
-        print '\nIndependent or related samples, or correlation (i,r,c): ',
+        print('\nIndependent or related samples, or correlation (i,r,c): ', end=' ')
         samples = raw_input()
 
     if samples in ['i','I','r','R']:
-        print '\nComparing variances ...',
+        print('\nComparing variances ...', end=' ')
 # USE O'BRIEN'S TEST FOR HOMOGENEITY OF VARIANCE, Maxwell & delaney, p.112
         r = obrientransform(x,y)
         f,p = F_oneway(pstat.colex(r,0),pstat.colex(r,1))
         if p<0.05:
             vartype='unequal, p='+str(round(p,4))
         else:
             vartype='equal'
-        print vartype
+        print(vartype)
         if samples in ['i','I']:
             if vartype[0]=='e':
                 t,p = ttest_ind(x,y,None,0)
-                print '\nIndependent samples t-test:  ', round(t,4),round(p,4)
+                print('\nIndependent samples t-test:  ', round(t, 4), round(p, 4))
             else:
                 if len(x)>20 or len(y)>20:
                     z,p = ranksums(x,y)
-                    print '\nRank Sums test (NONparametric, n>20):  ', round(z,4),round(p,4)
+                    print('\nRank Sums test (NONparametric, n>20):  ', round(z, 4), round(p, 4))
                 else:
                     u,p = mannwhitneyu(x,y)
-                    print '\nMann-Whitney U-test (NONparametric, ns<20):  ', round(u,4),round(p,4)
+                    print('\nMann-Whitney U-test (NONparametric, ns<20):  ', round(u, 4), round(p, 4))
 
         else:  # RELATED SAMPLES
             if vartype[0]=='e':
                 t,p = ttest_rel(x,y,0)
-                print '\nRelated samples t-test:  ', round(t,4),round(p,4)
+                print('\nRelated samples t-test:  ', round(t, 4), round(p, 4))
             else:
                 t,p = ranksums(x,y)
-                print '\nWilcoxon T-test (NONparametric):  ', round(t,4),round(p,4)
+                print('\nWilcoxon T-test (NONparametric):  ', round(t, 4), round(p, 4))
     else:  # CORRELATION ANALYSIS
         corrtype = ''
         while corrtype not in ['c','C','r','R','d','D']:
-            print '\nIs the data Continuous, Ranked, or Dichotomous (c,r,d): ',
+            print('\nIs the data Continuous, Ranked, or Dichotomous (c,r,d): ', end=' ')
             corrtype = raw_input()
         if corrtype in ['c','C']:
             m,b,r,p,see = linregress(x,y)
-            print '\nLinear regression for continuous variables ...'
+            print('\nLinear regression for continuous variables ...')
             lol = [['Slope','Intercept','r','Prob','SEestimate'],[round(m,4),round(b,4),round(r,4),round(p,4),round(see,4)]]
             pstat.printcc(lol)
         elif corrtype in ['r','R']:
             r,p = spearmanr(x,y)
-            print '\nCorrelation for ranked variables ...'
-            print "Spearman's r: ",round(r,4),round(p,4)
+            print('\nCorrelation for ranked variables ...')
+            print("Spearman's r: ", round(r, 4), round(p, 4))
         else: # DICHOTOMOUS
             r,p = pointbiserialr(x,y)
-            print '\nAssuming x contains a dichotomous variable ...'
-            print 'Point Biserial r: ',round(r,4),round(p,4)
-    print '\n\n'
+            print('\nAssuming x contains a dichotomous variable ...')
+            print('Point Biserial r: ', round(r, 4), round(p, 4))
+    print('\n\n')
     return None
 
 
  def dices(x,y):
     """
 Calculates Dice's coefficient ... (2*number of common terms)/(number of terms in x +
 number of terms in y). Returns a value between 0 (orthogonal) and 1.
 
"""
     x = x.astype(N.float_)
     y = y.astype(N.float_)
     n = len(x)
     xmean = amean(x)
     ymean = amean(y,0)
     shp = N.ones(len(y.shape))
     shp[0] = len(x)
     x.shape = shp
-    print x.shape, y.shape
+    print(x.shape, y.shape)
     r_num = n*(N.add.reduce(x*y,0)) - N.add.reduce(x)*N.add.reduce(y,0)
     r_den = N.sqrt((n*ass(x) - asquare_of_sums(x))*(n*ass(y,0)-asquare_of_sums(y,0)))
     zerodivproblem = N.equal(r_den,0)
     r_den = N.where(zerodivproblem,1,r_den)  # avoid zero-division in 1st place
     r = r_num / r_den  # need to do this nicely for matrix division
     r = N.where(zerodivproblem,0.0,r)
     z = 0.5*N.log((1.0+r+TINY)/(1.0-r+TINY))
     df = n-2

 Usage:  ap2t(pval,df)
 Returns: an array of t-values with the shape of pval
     """
     pval = N.array(pval)
     signs = N.sign(pval)
     pval = abs(pval)
     t = N.ones(pval.shape,N.float_)*50
     step = N.ones(pval.shape,N.float_)*25
-    print "Initial ap2t() prob calc"
+    print("Initial ap2t() prob calc")
     prob = abetai(0.5*df,0.5,float(df)/(df+t*t))
-    print 'ap2t() iter: ',
+    print('ap2t() iter: ', end=' ')
     for i in range(10):
-        print i,' ',
+        print(i, ' ', end=' ')
         t = N.where(pval<prob,t+step,t-step)
         prob = abetai(0.5*df,0.5,float(df)/(df+t*t))
         step = step/2
-    print
+    print()
     # since this is an ugly hack, we get ugly boundaries
     t = N.where(t>99.9,1000,t)      # hit upper-boundary
     t = t+signs
     return t #, prob, pval
 
 
  def attest_rel (a,b,dimension=None,printit=0,name1='Samp1',name2='Samp2',writemode='a'):
     """
for i in range(ITMAX+1):
         bm = bp/bpp
         az = app/bpp
         bz = 1.0
         newmask = N.less(abs(az-aold),EPS*abs(az))
         frozen = N.where(newmask*N.equal(mask,0), az, frozen)
         mask = N.clip(mask+newmask,0,1)
     noconverge = asum(N.equal(frozen,-1))
     if noconverge <> 0 and verbose:
-        print 'a or b too big, or ITMAX too small in Betacf for ',noconverge,' elements'
+        print('a or b too big, or ITMAX too small in Betacf for ', noconverge, ' elements')
     if arrayflag:
         return frozen
     else:
         return frozen[0]
 
 
  def agammln(xx):
     """
from:
     Peterson et al. Statistical limitations in functional neuroimaging
     I. Non-inferential methods and statistical models.  Phil Trans Royal Soc
     Lond B 354: 1239-1260.
 
 Usage:   aglm(data,para)
 Returns: statistic, p-value ???
 """
     if len(para) <> len(data):
-        print "data and para must be same length in aglm"
+        print("data and para must be same length in aglm")
         return
     n = len(para)
     p = pstat.aunique(para)
     x = N.zeros((n,len(p)))  # design matrix
     for l in range(len(p)):
         x[:,l] = N.equal(para,p[l])
     b = N.dot(N.dot(LA.inv(N.dot(N.transpose(x),x)),  # i.e., b=inv(X'X)X'Y
                     N.transpose(x)),

lnt/trunk/lnt/lnttool/create.py

+from __future__ import print_function
 import click
 import platform
 
 
 kConfigVersion = (0, 1, 0)
 kConfigTemplate = """\
 # LNT configuration file
 #
LNT configuration.
     wsgi_file = open(wsgi_path, 'w')
     wsgi_file.write(kWSGITemplate % locals())
     wsgi_file.close()
     os.chmod(wsgi_path, 0755)
 
     # Execute an upgrade on the database to initialize the schema.
     lnt.server.db.migrate.update_path(db_path)
 
-    print 'created LNT configuration in %r' % basepath
-    print '  configuration file: %s' % cfg_path
-    print '  WSGI app          : %s' % wsgi_path
-    print '  database file     : %s' % db_path
-    print '  temporary dir     : %s' % tmp_path
-    print '  host URL          : %s' % hosturl
-    print
-    print 'You can execute:'
-    print '  %s' % wsgi_path
-    print 'to test your installation with the builtin server.'
-    print
-    print 'For production use configure this application to run with any'
-    print 'WSGI capable web server. You may need to modify the permissions'
-    print 'on the database and temporary file directory to allow writing'
-    print 'by the web app.'
-    print
+    print('created LNT configuration in %r' % basepath)
+    print('  configuration file: %s' % cfg_path)
+    print('  WSGI app          : %s' % wsgi_path)
+    print('  database file     : %s' % db_path)
+    print('  temporary dir     : %s' % tmp_path)
+    print('  host URL          : %s' % hosturl)
+    print()
+    print('You can execute:')
+    print('  %s' % wsgi_path)
+    print('to test your installation with the builtin server.')
+    print()
+    print('For production use configure this application to run with any')
+    print('WSGI capable web server. You may need to modify the permissions')
+    print('on the database and temporary file directory to allow writing')
+    print('by the web app.')
+    print()

lnt/trunk/lnt/lnttool/main.py

 """Implement the command line 'lnt' tool."""
+from __future__ import print_function
 from .common import init_logger
 from .common import submit_options
 from .convert import action_convert
 from .create import action_create
 from .import_data import action_import
 from .import_report import action_importreport
 from .updatedb import action_updatedb
 from .viewcomparison import action_view_comparison
if error_msg is not None:
         sys.stderr.write("%s: %s\n" % (file, error_msg))
         sys.exit(1)
 
 
 def _print_result_url(results, verbose):
     result_url = results.get('result_url')
     if result_url is not None:
         if verbose:
-            print "Results available at:", result_url
+            print("Results available at:", result_url)
         else:
-            print result_url
+            print(result_url)
     elif verbose:
-        print "Results available at: no URL available"
+        print("Results available at: no URL available")
 
 
 class RunTestCLI(click.MultiCommand):
     def list_commands(self, ctx):
         import lnt.tests
         return lnt.tests.get_names()
 
     def get_command(self, ctx, name):

 
 
 @click.command("showtests")
 def action_showtests():
     """show the available built-in tests"""
     import lnt.tests
     import inspect
 
-    print 'Available tests:'
+    print('Available tests:')
     test_names = lnt.tests.get_names()
     max_name = max(map(len, test_names))
     for name in test_names:
         test_module = lnt.tests.get_module(name)
         description = inspect.cleandoc(test_module.__doc__)
-        print '  %-*s - %s' % (max_name, name, description)
+        print('  %-*s - %s' % (max_name, name, description))
 
 
 @click.command("submit")
 @click.argument("url")
 @click.argument("files", nargs=-1, type=click.Path(exists=True), required=True)
 @submit_options
 @click.option("--verbose", "-v", is_flag=True,
               help="show verbose test results")
def command_update(input, output):
     profile.Profile.fromFile(input).upgrade().save(filename=output)
 
 
 @action_profile.command("getVersion")
 @click.argument("input", type=click.Path(exists=True))
 def command_get_version(input):
     """print the version of a profile"""
     import lnt.testing.profile.profile as profile
-    print profile.Profile.fromFile(input).getVersion()
+    print(profile.Profile.fromFile(input).getVersion())
 
 
 @action_profile.command("getTopLevelCounters")
 @click.argument("input", type=click.Path(exists=True))
 def command_top_level_counters(input):
     """print the whole-profile counter values"""
     import json
     import lnt.testing.profile.profile as profile
-    print json.dumps(profile.Profile.fromFile(input).getTopLevelCounters())
+    print(json.dumps(profile.Profile.fromFile(input).getTopLevelCounters()))
 
 
 @action_profile.command("getFunctions")
 @click.argument("input", type=click.Path(exists=True))
 def command_get_functions(input):
     """print the functions in a profile"""
     import json
     import lnt.testing.profile.profile as profile
-    print json.dumps(profile.Profile.fromFile(input).getFunctions())
+    print(json.dumps(profile.Profile.fromFile(input).getFunctions()))
 
 
 @action_profile.command("getCodeForFunction")
 @click.argument("input", type=click.Path(exists=True))
 @click.argument('fn')
 def command_code_for_function(input, fn):
     """print the code/instruction for a function"""
     import json
     import lnt.testing.profile.profile as profile
-    print json.dumps(
-        list(profile.Profile.fromFile(input).getCodeForFunction(fn)))
+    print(json.dumps(
+        list(profile.Profile.fromFile(input).getCodeForFunction(fn))))
 
 
 def _version_check():
     """
     Check that the installed version of the LNT is up-to-date with the running
     package.
 
     This check is used to force users of distribute's develop mode to reinstall

 
 
 def show_version(ctx, param, value):
     """print LNT version"""
     import lnt
     if not value or ctx.resilient_parsing:
         return
     if lnt.__version__:
-        print "LNT %s" % (lnt.__version__,)
+        print("LNT %s" % (lnt.__version__, ))
     ctx.exit()
 
 
 @click.group(invoke_without_command=True, no_args_is_help=True)
 @click.option('--version', is_flag=True, callback=show_version,
               expose_value=False, is_eager=True, help=show_version.__doc__)
 def main():
     """LNT command line tool

lnt/trunk/lnt/server/ui/app.py

+from __future__ import print_function
 import StringIO
 import logging
 import logging.handlers
 import sys
 import time
 import traceback
 from logging import Formatter
 
def start_file_logging(self, log_file_name):
                     LOG_FILENAME, maxBytes=1048576, backupCount=5)
                 rotating.setFormatter(Formatter(
                     '%(asctime)s %(levelname)s: %(message)s '
                     '[in %(filename)s:%(lineno)d]'
                 ))
                 rotating.setLevel(logging.DEBUG)
                 self.logger.addHandler(rotating)
             except (OSError, IOError) as e:
-                print >> sys.stderr, "Error making log file", \
-                                     LOG_FILENAME, str(e)
-                print >> sys.stderr, "Will not log to file."
+                print("Error making log file", \
+                      LOG_FILENAME, str(e), file=sys.stderr)
+                print("Will not log to file.", file=sys.stderr)
             else:
                 self.logger.info("Started file logging.")
-                print "Logging to :", LOG_FILENAME
+                print("Logging to :", LOG_FILENAME)
         else:
             self.config['log_file_name'] = log_file_name
 
 
 def create_jinja_environment(env=None):
     """
     create_jinja_environment([env]) -> jinja2.Environment
 

lnt/trunk/lnt/tests/builtintest.py

 """
 Base class for builtin-in tests.
 """
 
+from __future__ import print_function
 import sys
 import os
 
 from lnt.testing.util.misc import timestamp
 
 import lnt.util.ServerUtil as ServerUtil
 import lnt.util.ImportData as ImportData
 
def run_test(self, opts):
         Execute the test (accessed via name, for use in the usage message) with
         the given command line args.
         """
         raise RuntimeError("Abstract Method.")
 
     def log(self, message, ts=None):
         if not ts:
             ts = timestamp()
-        print >>sys.stderr, '%s: %s' % (ts, message)
+        print('%s: %s' % (ts, message), file=sys.stderr)
 
     @staticmethod
     def print_report(report, output):
         """Print the report object to the output path."""
         if output == '-':
             output_stream = sys.stdout
         else:
             output_stream = open(output, 'w')
-        print >> output_stream, report.render()
+        print(report.render(), file=output_stream)
         if output_stream is not sys.stdout:
             output_stream.close()
 
     def submit(self, report_path, config, ts_name=None):
         """Submit the results file to the server.  If no server
         was specified, use a local mock server.
 
         report_path is the location of the json report file.  config
def submit(self, report_path, config, ts_name=None):
                                            sys.stderr, config.verbose)
         return server_report
 
     @staticmethod
     def show_results_url(server_results):
         """Print the result URL"""
         result_url = server_results.get('result_url', None)
         if result_url is not None:
-            print "Results available at:", server_results['result_url']
+            print("Results available at:", server_results['result_url'])

lnt/trunk/lnt/tests/compile.py

 """Single file compile-time performance testing"""
+from __future__ import print_function
 import errno
 import hashlib
 import json
 import os
 import platform
 import pprint
 import re
 import shlex
def run_test(self, opts):
             opts.ld = opts.cc
         # If no ldxx was set, set ldxx to opts.cxx
         if opts.ldxx is None:
             opts.ldxx = opts.cxx
 
         # Set up the sandbox.
         global g_output_dir
         if not os.path.exists(opts.sandbox_path):
-            print >>sys.stderr, "%s: creating sandbox: %r" % (
-                timestamp(), opts.sandbox_path)
+            print("%s: creating sandbox: %r" % (
+                timestamp(), opts.sandbox_path), file=sys.stderr)
             os.mkdir(opts.sandbox_path)
         if opts.timestamp_build:
             fmt_timestamp = timestamp().replace(' ', '_').replace(':', '-')
             report_name = "test-%s" % (fmt_timestamp)
         else:
             report_name = "build"
         g_output_dir = os.path.join(os.path.abspath(opts.sandbox_path),
                                     report_name)
def run_test(self, opts):
 
         # Compute the list of all tests.
         all_tests = list(get_tests(opts.test_suite_externals, opts.test_subdir,
                                    flags_to_test, jobs_to_test,
                                    configs_to_test))
 
         # Show the tests, if requested.
         if opts.show_tests:
-            print >>sys.stderr, 'Available Tests'
+            print('Available Tests', file=sys.stderr)
             for name in sorted(set(name for name, _ in all_tests)):
-                print >>sys.stderr, '  %s' % (name,)
-            print
+                print('  %s' % (name, ), file=sys.stderr)
+            print()
             raise SystemExit
 
         # Find the tests to run.
         if not opts.tests and not opts.test_filters:
             tests_to_run = list(all_tests)
         else:
             all_test_names = set(test[0] for test in all_tests)
 

lnt/trunk/lnt/tests/nt.py

 """LLVM test-suite compile and execution tests"""
+from __future__ import print_function
 import csv
 import os
 import platform
 import re
 import shutil
 import subprocess
 import sys
 import glob
class TestModule(object):
 
     def call(self, args, **kwargs):
         if kwargs.get('shell', False):
             cmdstr = args
         else:
             cmdstr = ' '.join(args)
 
         if 'cwd' in kwargs:
-            print >>self._log, "# In working dir: " + kwargs['cwd']
-        print >>self.log, cmdstr
+            print("# In working dir: " + kwargs['cwd'], file=self._log)
+        print(cmdstr, file=self.log)
 
         self._log.flush()
         p = subprocess.Popen(args, stdout=self._log, stderr=self._log,
                              **kwargs)
         return p.wait()
 
     def get_time(self):
         if self._user_time:

 
 # FIXME: Support duplicate logfiles to global directory.
 def execute_test_modules(test_log, test_modules, test_module_variables,
                          basedir, config, make_variables):
     # For now, we don't execute these in parallel, but we do forward the
     # parallel build options to the test.
     test_modules.sort()
 
-    print >>sys.stderr, '%s: executing test modules' % (timestamp(),)
+    print('%s: executing test modules' % (timestamp(), ), file=sys.stderr)
     results = []
     for name in test_modules:
         # First, load the test module file.
         locals = globals = {}
         test_path = os.path.join(config.test_suite_root, 'LNTBased', name)
         # This is where shared code between test modules should go.
         sys.path.append(os.path.join(config.test_suite_root, 'LNTBased/lib'))
         test_obj_path = os.path.join(basedir, 'LNTBased', name)
def execute_nt_tests(test_log, make_variables, basedir, config):
     common_args.extend('%s=%s' % (k, v) for k, v in make_variables.items())
     if config.only_test is not None:
         common_args.extend(['-C', config.only_test])
 
     # If we are using isolation, run under sandbox-exec.
     if config.use_isolation:
         # Write out the sandbox profile.
         sandbox_profile_path = os.path.join(basedir, "isolation.sb")
-        print >>sys.stderr, "%s: creating sandbox profile %r" % (
-            timestamp(), sandbox_profile_path)
+        print("%s: creating sandbox profile %r" % (
+            timestamp(), sandbox_profile_path), file=sys.stderr)
         with open(sandbox_profile_path, 'w') as f:
-            print >>f, """
+            print("""
 ;; Sandbox profile for isolation test access.
 (version 1)
 
 ;; Allow everything by default, and log debug messages on deny.
 (allow default)
 (debug deny)
 
 ;; Deny all file writes by default.
 (deny file-write*)
 
 ;; Deny all network access by default.
 (deny network*)
 
 ;; Explicitly allow writes to temporary directories, /dev/, and the sandbox
 ;; output directory.
 (allow file-write*      (regex #"^/private/var/tmp/")
                         (regex #"^/private/tmp/")
                         (regex #"^/private/var/folders/")
                         (regex #"^/dev/")
-                        (regex #"^%s"))""" % (basedir,)
+                        (regex #"^%s"))""" % (basedir, ), file=f)
         common_args = ['sandbox-exec', '-f', sandbox_profile_path] +\
             common_args
 
     # Run a separate 'make build' step if --build-threads was given.
     if config.build_threads > 0:
         args = common_args + ['-j', str(config.build_threads), 'build']
-        print >>test_log, '%s: running: %s' % (timestamp(),
-                                               ' '.join('"%s"' % a
-                                                        for a in args))
+        print('%s: running: %s' % (timestamp(),
+                                            for a in args)), file=test_log)
         test_log.flush()
 
-        print >>sys.stderr, '%s: building "nightly tests" with -j%u...' % (
-            timestamp(), config.build_threads)
+        print('%s: building "nightly tests" with -j%u...' % (
+            timestamp(), config.build_threads), file=sys.stderr)
         res = execute_command(test_log, basedir, args, report_dir)
         if res != 0:
-            print >> sys.stderr, "Failure while running make build! " \
-                                 "See log: %s" % test_log.name
+            print("Failure while running make build! " \
+                  "See log: %s" % test_log.name, file=sys.stderr)
 
     # Then 'make report'.
     args = common_args + ['-j', str(config.threads),
                           'report', 'report.%s.csv' % config.test_style]
-    print >>test_log, '%s: running: %s' % (timestamp(),
-                                           ' '.join('"%s"' % a
-                                                    for a in args))
+    print('%s: running: %s' % (timestamp(),
+                                        for a in args)), file=test_log)
     test_log.flush()
 
     # FIXME: We shouldn't need to set env=os.environ here, but if we don't
     # somehow MACOSX_DEPLOYMENT_TARGET gets injected into the environment on OS
     # X (which changes the driver behavior and causes generally weirdness).
-    print >>sys.stderr, '%s: executing "nightly tests" with -j%u...' % (
-        timestamp(), config.threads)
+    print('%s: executing "nightly tests" with -j%u...' % (
+        timestamp(), config.threads), file=sys.stderr)
 
     res = execute_command(test_log, basedir, args, report_dir)
 
     if res != 0:
-        print >> sys.stderr, "Failure while running nightly tests!  "\
-                             "See log: %s" % test_log.name
+        print("Failure while running nightly tests!  "\
+              "See log: %s" % test_log.name, file=sys.stderr)
 
 
 # Keep a mapping of mangled test names, to the original names in the
 # test-suite.
 TEST_TO_NAME = {}
 KNOWN_SAMPLE_KEYS = ('compile', 'exec', 'hash',
                      'gcc.compile', 'bc.compile', 'llc.compile',
                      'llc-beta.compile', 'jit.compile', 'gcc.exec', 'llc.exec',
def load_nt_report_file(report_path, config):
     report_file.close()
 
     return test_samples, no_errors
 
 
 def prepare_report_dir(config):
     # Set up the sandbox.
     sandbox_path = config.sandbox_path
-    print sandbox_path
+    print(sandbox_path)
     if not os.path.exists(sandbox_path):
-        print >>sys.stderr, "%s: creating sandbox: %r" % (
-            timestamp(), sandbox_path)
+        print("%s: creating sandbox: %r" % (
+            timestamp(), sandbox_path), file=sys.stderr)
         os.mkdir(sandbox_path)
 
     # Create the per-test directory.
     report_dir = config.report_dir
     if os.path.exists(report_dir):
         needs_clean = True
     else:
         needs_clean = False
def prepare_build_dir(config, iteration):
     if needs_clean and config.timestamp_build:
         fatal('refusing to reuse pre-existing build dir %r' % build_dir)
     return build_dir
 
 
 def update_tools(make_variables, config, iteration):
     """Update the test suite tools. """
 
-    print >>sys.stderr, '%s: building test-suite tools' % (timestamp(),)
+    print('%s: building test-suite tools' % (timestamp(), ), file=sys.stderr)
     args = ['make', 'tools']
     args.extend('%s=%s' % (k, v) for k, v in make_variables.items())
     build_tools_log_path = os.path.join(config.build_dir(iteration),
                                         'build-tools.log')
     build_tools_log = open(build_tools_log_path, 'w')
-    print >>build_tools_log, '%s: running: %s' % (timestamp(),
-                                                  ' '.join('"%s"' % a
-                                                           for a in args))
+    print('%s: running: %s' % (timestamp(),
+                                        for a in args)), file=build_tools_log)
     build_tools_log.flush()
     res = execute_command(build_tools_log, config.build_dir(iteration),
                           args, config.report_dir)
     build_tools_log.close()
     if res != 0:
         fatal('Unable to build tools, aborting! See log: %s' %
               build_tools_log_path)
 
else:
                      '--with-llvmobj=%s' % config.llvm_obj_root])
 
     if config.test_suite_externals:
         args.append('--with-externals=%s' %
                     os.path.realpath(config.test_suite_externals))
 
     args.extend(['--target=%s' % config.target])
 
-    print >>configure_log, '%s: running: %s' % (timestamp(),
-                                                ' '.join('"%s"' % a
-                                                         for a in args))
+    print('%s: running: %s' % (timestamp(),
+                                        for a in args)), file=configure_log)
     configure_log.flush()
 
-    print >>sys.stderr, '%s: configuring...' % timestamp()
+    print('%s: configuring...' % timestamp(), file=sys.stderr)
     res = execute_command(configure_log, basedir, args, config.report_dir)
     configure_log.close()
     if res != 0:
         fatal('Configure failed, log is here: %r' % configure_log_path)
 
 
 def copy_missing_makefiles(config, basedir):
     """When running with only_test something, makefiles will be missing,
     so copy them into place. """
     suffix = ''
     for component in config.only_test.split('/'):
         suffix = os.path.join(suffix, component)
         obj_path = os.path.join(basedir, suffix)
         src_path = os.path.join(config.test_suite_root, suffix)
         if not os.path.exists(obj_path):
-            print '%s: initializing test dir %s' % (timestamp(), suffix)
+            print('%s: initializing test dir %s' % (timestamp(), suffix))
             os.mkdir(obj_path)
             shutil.copyfile(os.path.join(src_path, 'Makefile'),
                             os.path.join(obj_path, 'Makefile'))
 
 
 def run_test(nick_prefix, iteration, config):
-    print >>sys.stderr, "%s: checking source versions" % (
-        timestamp(),)
+    print("%s: checking source versions" % (
+        timestamp(), ), file=sys.stderr)
 
     test_suite_source_version = get_source_version(config.test_suite_root)
 
     # Compute the make variables.
     make_variables, public_make_variables = config.compute_run_make_variables()
 
     # Compute the test module variables, which are a restricted subset of the
     # make variables.
     test_module_variables = compute_test_module_variables(make_variables,
                                                           config)
 
     # Scan for LNT-based test modules.
-    print >>sys.stderr, "%s: scanning for LNT-based test modules" % (
-        timestamp(),)
+    print("%s: scanning for LNT-based test modules" % (
+        timestamp(), ), file=sys.stderr)
     test_modules = list(scan_for_test_modules(config))
-    print >>sys.stderr, "%s: found %d LNT-based test modules" % (
-        timestamp(), len(test_modules))
+    print("%s: found %d LNT-based test modules" % (
+        timestamp(), len(test_modules)), file=sys.stderr)
 
     nick = nick_prefix
     if config.auto_name:
         # Construct the nickname from a few key parameters.
         cc_info = config.cc_info
         cc_nick = '%s_%s' % (cc_info.get('cc_name'), cc_info.get('cc_build'))
         nick += "__%s__%s" % (cc_nick, cc_info.get('cc_target').split('-')[0])
-    print >>sys.stderr, "%s: using nickname: %r" % (timestamp(), nick)
+    print("%s: using nickname: %r" % (timestamp(), nick), file=sys.stderr)
 
     basedir = prepare_build_dir(config, iteration)
 
     # FIXME: Auto-remove old test directories in the source directory (which
     # cause make horrible fits).
 
     start_time = timestamp()
-    print >>sys.stderr, '%s: starting test in %r' % (start_time, basedir)
+    print('%s: starting test in %r' % (start_time, basedir), file=sys.stderr)
 
     # Configure the test suite.
     if config.run_configure or not os.path.exists(os.path.join(
             basedir, 'Makefile.config')):
         configure_test_suite(config, iteration)
 
     # If running with --only-test, creating any dirs which might be missing and
     # copy Makefiles.
def run_test(nick_prefix, iteration, config):
     end_time = timestamp()
 
     # Load the nightly test samples.
     if config.test_style == "simple":
         test_namespace = 'nts'
     else:
         test_namespace = 'nightlytest'
     if run_nightly_test:
-        print >>sys.stderr, '%s: loading nightly test data...' % timestamp()
+        print('%s: loading nightly test data...' % timestamp(), file=sys.stderr)
         # If nightly test went screwy, it won't have produced a report.
-        print build_report_path
+        print(build_report_path)
         if not os.path.exists(build_report_path):
             fatal('nightly test failed, no report generated')
 
         test_samples, no_errors = \
             load_nt_report_file(build_report_path, config)
     else:
         test_samples = []
         no_errors = True
 
     # Merge in the test samples from all of the test modules.
     existing_tests = set(s.name for s in test_samples)
     for module, results in test_module_results:
         for s in results:
             if s.name in existing_tests:
                 fatal("test module %r added duplicate test: %r" % (
                         module, s.name))
             existing_tests.add(s.name)
         test_samples.extend(results)
 
-    print >>sys.stderr, '%s: capturing machine information' % (timestamp(),)
+    print('%s: capturing machine information' % (timestamp(), ), file=sys.stderr)
     # Collect the machine and run info.
     #
     # FIXME: Import full range of data that the Clang tests are using?
     machine_info = {}
     machine_info['hardware'] = capture(["uname", "-m"],
                                        include_stderr=True).strip()
     machine_info['os'] = capture(["uname", "-sr"], include_stderr=True).strip()
     if config.cc_reference is not None:
for target, params in ((machine_info, config.machine_parameters),
         for entry in params:
             if '=' not in entry:
                 name, value = entry, ''
             else:
                 name, value = entry.split('=', 1)
             if name in target:
                 logger.warning("parameter %r overwrote existing value: %r" %
                                (name, target.get(name)))
-            print target, name, value
+            print(target, name, value)
             target[name] = value
 
     # Generate the test report.
     lnt_report_path = config.report_path(iteration)
-    print >>sys.stderr, '%s: generating report: %r' % (timestamp(),
-                                                       lnt_report_path)
+    print('%s: generating report: %r' % (timestamp(),
+                                         lnt_report_path), file=sys.stderr)
     machine = lnt.testing.Machine(nick, machine_info)
     run = lnt.testing.Run(start_time, end_time, info=run_info)
 
     report = lnt.testing.Report(machine, run, test_samples)
     lnt_report_file = open(lnt_report_path, 'w')
-    print >>lnt_report_file, report.render()
+    print(report.render(), file=lnt_report_file)
     lnt_report_file.close()
 
     return report
 
 ###
 
 
 def _construct_report_path(basedir, only_test, test_style, file_type="csv"):
def _prepare_testsuite_for_rerun(test_name, test_full_path, config):
 
     # Remove all the test-suite accounting files for this benchmark
     to_go = glob.glob(test_path_prefix + "*.time")
     to_go.extend(glob.glob(test_path_prefix + "*.txt"))
     to_go.extend(glob.glob(test_path_prefix + "*.csv"))
 
     assert len(to_go) >= 1, "Missing at least one accounting file."
     for path in to_go:
-        print "Removing:", path
+        print("Removing:", path)
         os.remove(path)
 
 
 def _execute_test_again(config, test_name, test_path, test_relative_path,
                         logfile):
     """(Re)Execute the benchmark of interest. """
 
     _prepare_testsuite_for_rerun(test_name, test_path, config)
def run_test(self, opts):
 
         # Multisample, if requested.
         merge_run = None
         if opts.multisample is not None:
             # Collect the sample reports.
             reports = []
 
             for i in range(opts.multisample):
-                print >>sys.stderr, "%s: (multisample) running iteration %d" %\
-                        (timestamp(), i)
+                print("%s: (multisample) running iteration %d" %\
+                        (timestamp(), i), file=sys.stderr)
                 report = run_test(opts.label, i, config)
                 reports.append(report)
 
             # Create the merged report.
             #
             # FIXME: Do a more robust job of merging the reports?
-            print >>sys.stderr, "%s: (multisample) creating merged report" % (
-                timestamp(),)
+            print("%s: (multisample) creating merged report" % (
+                timestamp(), ), file=sys.stderr)
             machine = reports[0].machine
             run = reports[0].run
             run.end_time = reports[-1].run.end_time
             test_samples = sum([r.tests
                                 for r in reports], [])
 
             # Write out the merged report.
             lnt_report_path = config.report_path(None)
             report = lnt.testing.Report(machine, run, test_samples)
             lnt_report_file = open(lnt_report_path, 'w')
-            print >>lnt_report_file, report.render()
+            print(report.render(), file=lnt_report_file)
             lnt_report_file.close()
 
         else:
             test_results = run_test(opts.label, None, config)
             if opts.rerun:
                 self.log("Performing any needed reruns.")
                 server_report = self.submit_helper(config)
                 new_samples = _process_reruns(config, server_report,
                                               test_results)
                 test_results.update_report(new_samples)
 
                 # persist report with new samples.
                 lnt_report_path = config.report_path(None)
 
                 lnt_report_file = open(lnt_report_path, 'w')
-                print >>lnt_report_file, test_results.render()
+                print(test_results.render(), file=lnt_report_file)
                 lnt_report_file.close()
                 merge_run = 'replace'
 
             if config.output is not None:
                 self.print_report(test_results, config.output)
 
         server_report = self.submit_helper(config, merge_run)
 

lnt/trunk/lnt/tests/test_suite.py

 """LLVM test-suite"""
+from __future__ import print_function
 import subprocess
 import tempfile
 import json
 import os
 import shlex
 import platform
 import pipes
 import sys
def diagnose(self):
             if not sudo:
                 sudo = []
             else:
                 sudo = [sudo]
             iprofiler = os.getenv("IPROFILER_CMD",
                                   "iprofiler -timeprofiler -I 40u")
 
             cmd_iprofiler = cmd + ['-DTEST_SUITE_RUN_UNDER=' + iprofiler]
-            print ' '.join(cmd_iprofiler)
+            print(' '.join(cmd_iprofiler))
 
             out = subprocess.check_output(cmd_iprofiler)
 
             os.chdir(local_path)
             make_iprofiler_temps = [self.opts.make, "VERBOSE=1", short_name]
             p = subprocess.Popen(make_iprofiler_temps,
                                  stdout=subprocess.PIPE,
                                  stderr=subprocess.PIPE)

lnt/trunk/lnt/util/ImportData.py

+from __future__ import print_function
 from lnt.util import NTEmailReport
 from contextlib import closing
 from lnt.util import logger
 import collections
 import datetime
 import lnt.formats
 import lnt.server.reporting.analysis
 import lnt.testing
def print_report_result(result, out, err, verbose=True):
     print_report_result(result, out, [err], [verbose]) -> None
 
     Print a human readable form of an import result object to the given output
     stream. Test results are printed in 'lit' format.
     """
 
     # Print the generic import information.
     if 'import_file' in result:
-        print >>out, "Importing %r" % os.path.basename(result['import_file'])
+        print("Importing %r" % os.path.basename(result['import_file']), file=out)
     if result['success']:
-        print >>out, "Import succeeded."
-        print >>out
+        print("Import succeeded.", file=out)
+        print(file=out)
     else:
         out.flush()
-        print >>err, "Import Failed:"
-        print >>err, "%s\n" % result['error']
+        print("Import Failed:", file=err)
+        print("%s\n" % result['error'], file=err)
         message = result.get('message', None)
         if message:
-            print >>err, "%s\n" % message
-        print >>err, "--------------"
+            print("%s\n" % message, file=err)
+        print("--------------", file=err)
         err.flush()
         return
 
     # Print the test results.
     test_results = result.get('test_results')
     if not test_results:
         return
 
     # List the parameter sets, if interesting.
     show_pset = len(test_results) > 1
     if show_pset:
-        print >>out, "Parameter Sets"
-        print >>out, "--------------"
+        print("Parameter Sets", file=out)
+        print("--------------", file=out)
         for i, info in enumerate(test_results):
-            print >>out, "P%d: %s" % (i, info['pset'])
-        print >>out
+            print("P%d: %s" % (i, info['pset']), file=out)
+        print(file=out)
 
     total_num_tests = sum([len(item['results'])
                            for item in test_results])
-    print >>out, "--- Tested: %d tests --" % total_num_tests
+    print("--- Tested: %d tests --" % total_num_tests, file=out)
     test_index = 0
     result_kinds = collections.Counter()
     for i, item in enumerate(test_results):
         pset_results = item['results']
 
         for name, test_status, perf_status in pset_results:
             test_index += 1
             # FIXME: Show extended information for performance changes,
for i, item in enumerate(test_results):
                 result_string = 'PASS'
             result_kinds[result_string] += 1
             # Ignore passes unless in verbose mode.
             if not verbose and result_string == 'PASS':
                 continue
 
             if show_pset:
                 name = 'P%d :: %s' % (i, name)
-            print >>out, "%s: %s (%d of %d)" % (result_string, name,
-                                                test_index, total_num_tests)
+            print("%s: %s (%d of %d)" % (result_string, name,
+                                         test_index, total_num_tests), file=out)
 
             if result_info:
-                print >>out, "%s TEST '%s' %s" % ('*'*20, name, '*'*20)
-                print >>out, result_info
-                print >>out, "*" * 20
+                print("%s TEST '%s' %s" % ('*'*20, name, '*'*20), file=out)
+                print(result_info, file=out)
+                print("*" * 20, file=out)
 
     if 'original_run' in result:
-        print >>out, ("This submission is a duplicate of run %d, "
-                      "already in the database.") % result['original_run']
-        print >>out
+        print(("This submission is a duplicate of run %d, "
+               "already in the database.") % result['original_run'], file=out)
+        print(file=out)
 
     if result['report_to_address']:
-        print >>out, "Report emailed to: %r" % result['report_to_address']
-        print >>out
+        print("Report emailed to: %r" % result['report_to_address'], file=out)
+        print(file=out)
 
     # Print the processing times.
-    print >>out, "Processing Times"
-    print >>out, "----------------"
-    print >>out, "Load   : %.2fs" % result['load_time']
-    print >>out, "Import : %.2fs" % result['import_time']
-    print >>out, "Report : %.2fs" % result['report_time']
-    print >>out, "Total  : %.2fs" % result['total_time']
-    print >>out
+    print("Processing Times", file=out)
+    print("----------------", file=out)
+    print("Load   : %.2fs" % result['load_time'], file=out)
+    print("Import : %.2fs" % result['import_time'], file=out)
+    print("Report : %.2fs" % result['report_time'], file=out)
+    print("Total  : %.2fs" % result['total_time'], file=out)
+    print(file=out)
 
     # Print the added database items.
     total_added = (result['added_machines'] + result['added_runs'] +
                    result['added_tests'] + result.get('added_samples', 0))
     if total_added:
-        print >>out, "Imported Data"
-        print >>out, "-------------"
+        print("Imported Data", file=out)
+        print("-------------", file=out)
         if result['added_machines']:
-            print >>out, "Added Machines: %d" % result['added_machines']
+            print("Added Machines: %d" % result['added_machines'], file=out)
         if result['added_runs']:
-            print >>out, "Added Runs    : %d" % result['added_runs']
+            print("Added Runs    : %d" % result['added_runs'], file=out)
         if result['added_tests']:
-            print >>out, "Added Tests   : %d" % result['added_tests']
+            print("Added Tests   : %d" % result['added_tests'], file=out)
         if result.get('added_samples', 0):
-            print >>out, "Added Samples : %d" % result['added_samples']
-        print >>out
-    print >>out, "Results"
-    print >>out, "----------------"
+            print("Added Samples : %d" % result['added_samples'], file=out)
+        print(file=out)
+    print("Results", file=out)
+    print("----------------", file=out)
     for kind, count in result_kinds.items():
-        print >>out, kind, ":", count
+        print(kind, ":", count, file=out)
 
 
 def import_from_string(config, db_name, db, session, ts_name, data,
                        select_machine=None, merge_run=None):
     # Stash a copy of the raw submission.
     #
     # To keep the temporary directory organized, we keep files in
     # subdirectories organized by (database, year-month).

lnt/trunk/lnt/util/ServerUtil.py

 """
 Utility for submitting files to a web server over HTTP.
 """
+from __future__ import print_function
 import sys
 import urllib
 import urllib2
 import contextlib
 import json
 
 import lnt.server.instance
 
 # FIXME: I used to maintain this file in such a way that it could be used
 # separate from LNT to do submission. This could be useful for adapting an
 # older system to report to LNT, for example. It might be nice to factor the
 # simplified submit code into a separate utility.
 
 
 def _show_json_error(reply):
     try:
         error = json.loads(reply)
     except ValueError:
-        print "error: {}".format(reply)
+        print("error: {}".format(reply))
         return
     sys.stderr.write("error: lnt server: {}\n".format(error.get('error')))
     message = error.get('message', '')
     if message:
         sys.stderr.write(message + '\n')
 
 
 def submitFileToServer(url, file, select_machine=None, merge_run=None):
except urllib2.URLError as e:
         return
     result_data = response.read()
 
     # The result is expected to be a JSON object.
     try:
         return json.loads(result_data)
     except Exception:
         import traceback
-        print "Unable to load result, not a valid JSON object."
-        print
-        print "Traceback:"
+        print("Unable to load result, not a valid JSON object.")
+        print()
+        print("Traceback:")
         traceback.print_exc()
-        print
-        print "Result:"
-        print "error:", result_data
+        print()
+        print("Result:")
+        print("error:", result_data)
         return
 
 
 def submitFileToInstance(path, file, select_machine=None, merge_run=None):
     # Otherwise, assume it is a local url and submit to the default database
     # in the instance.
     instance = lnt.server.instance.Instance.frompath(path)
     config = instance.config

lnt/trunk/lnt/util/wsgi_restart.py

 # This code lifted from the mod_wsgi docs.
+from __future__ import print_function
 import os
 import sys
 import signal
 import threading
 import atexit
 import Queue
 
 _interval = 1.0
 _times = {}
 _files = []
 
 _running = False
 _queue = Queue.Queue()
 _lock = threading.Lock()
 
 
 def _restart(path):
     _queue.put(True)
     prefix = 'monitor (pid=%d):' % os.getpid()
-    print >> sys.stderr, '%s Change detected to \'%s\'.' % (prefix, path)
-    print >> sys.stderr, '%s Triggering process restart.' % prefix
+    print('%s Change detected to \'%s\'.' % (prefix, path), file=sys.stderr)
+    print('%s Triggering process restart.' % prefix, file=sys.stderr)
     os.kill(os.getpid(), signal.SIGINT)
 
 
 def _modified(path):
     try:
         # If path doesn't denote a file and were previously
         # tracking it, then it has been removed or the file type
         # has changed so force a restart. If not previously
def start(interval=1.0):
     global _interval
     if interval < _interval:
         _interval = interval
 
     global _running
     _lock.acquire()
     if not _running:
         prefix = 'monitor (pid=%d):' % os.getpid()
-        print >> sys.stderr, '%s Starting change monitor.' % prefix
+        print('%s Starting change monitor.' % prefix, file=sys.stderr)
         _running = True
         _thread.start()