More flake fixes.

integration/test_web.py

@@ -9,6 +9,8 @@ WebAPI *should* do in every situation. It's not clear the latter
 exists anywhere, however.
 """
 
+from past.builtins import unicode
+
 import time
 import json
 import urllib2

integration/util.py

@@ -1,3 +1,5 @@
+from past.builtins import unicode
+
 import sys
 import time
 import json

misc/coding_tools/make-canary-files.py

@@ -52,6 +52,8 @@ system where Tahoe is installed, or in a source tree with setup.py like this:
  setup.py run_with_pythonpath -p -c 'misc/make-canary-files.py ARGS..'
 """
 
+from past.builtins import cmp
+
 import os, hashlib
 from twisted.python import usage
 from allmydata.immutable import upload

misc/operations_helpers/provisioning/provisioning.py

@@ -18,7 +18,7 @@ def factorial(n):
     factorial(n) with n<0 is -factorial(abs(n))
     """
     result = 1
-    for i in xrange(1, abs(n)+1):
+    for i in range(1, abs(n)+1):
         result *= i
     assert n >= 0
     return result
@@ -30,7 +30,7 @@ def binomial(n, k):
     # calculate n!/k! as one product, avoiding factors that
     # just get canceled
     P = k+1
-    for i in xrange(k+2, n+1):
+    for i in range(k+2, n+1):
         P *= i
     # if you are paranoid:
     # C, rem = divmod(P, factorial(n-k))

misc/simulators/hashbasedsig.py

@@ -79,7 +79,7 @@ def make_candidate(B, K, K1, K2, q, T, T_min, L_hash, lg_N, sig_bytes, c_sign, c
 
 # Winternitz with B < 4 is never optimal. For example, going from B=4 to B=2 halves the
 # chain depth, but that is cancelled out by doubling (roughly) the number of digits.
-range_B = xrange(4, 33)
+range_B = range(4, 33)
 
 M = pow(2, lg_M)
 
@@ -100,7 +100,7 @@ def calculate(K, K1, K2, q_max, L_hash, trees):
     T_min = ceil_div(lg_M - lg_K1, lg_K)
 
     last_q = None
-    for T in xrange(T_min, T_min+21):
+    for T in range(T_min, T_min+21):
         # lg(total number of leaf private keys)
         lg_S = lg_K1 + lg_K*T
         lg_N = lg_S + lg_K2
@@ -137,14 +137,14 @@ def calculate(K, K1, K2, q_max, L_hash, trees):
 
         # We approximate lg(M-x) as lg(M)
         lg_px_step = lg_M + lg_p - lg_1_p
-        for x in xrange(1, j):
+        for x in range(1, j):
             lg_px[x] = lg_px[x-1] - lg(x) + lg_px_step
 
         q = None
         # Find the minimum acceptable value of q.
-        for q_cand in xrange(1, q_max+1):
+        for q_cand in range(1, q_max+1):
             lg_q = lg(q_cand)
-            lg_pforge = [lg_px[x] + (lg_q*x - lg_K2)*q_cand for x in xrange(1, j)]
+            lg_pforge = [lg_px[x] + (lg_q*x - lg_K2)*q_cand for x in range(1, j)]
             if max(lg_pforge) < -L_hash + lg(j) and lg_px[j-1] + 1.0 < -L_hash:
                 #print("K = %d, K1 = %d, K2 = %d, L_hash = %d, lg_K2 = %.3f, q = %d, lg_pforge_1 = %.3f, lg_pforge_2 = %.3f, lg_pforge_3 = %.3f"
                 #      % (K, K1, K2, L_hash, lg_K2, q, lg_pforge_1, lg_pforge_2, lg_pforge_3))
@@ -246,13 +246,13 @@ def search():
         K_max = 50
         c2 = compressions(2*L_hash)
         c3 = compressions(3*L_hash)
-        for dau in xrange(0, 10):
+        for dau in range(0, 10):
             a = pow(2, dau)
-            for tri in xrange(0, ceil_log(30-dau, 3)):
+            for tri in range(0, ceil_log(30-dau, 3)):
                 x = int(a*pow(3, tri))
                 h = dau + 2*tri
                 c_x = int(sum_powers(2, dau)*c2 + a*sum_powers(3, tri)*c3)
-                for y in xrange(1, x+1):
+                for y in range(1, x+1):
                     if tri > 0:
                         # If the bottom level has arity 3, then for every 2 nodes by which the tree is
                         # imperfect, we can save c3 compressions by pruning 3 leaves back to their parent.
@@ -267,16 +267,16 @@ def search():
                     if y not in trees or (h, c_y, (dau, tri)) < trees[y]:
                         trees[y] = (h, c_y, (dau, tri))
 
-        #for x in xrange(1, K_max+1):
+        #for x in range(1, K_max+1):
         #    print(x, trees[x])
 
         candidates = []
         progress = 0
         fuzz = 0
         complete = (K_max-1)*(2200-200)/100
-        for K in xrange(2, K_max+1):
-            for K2 in xrange(200, 2200, 100):
-                for K1 in xrange(max(2, K-fuzz), min(K_max, K+fuzz)+1):
+        for K in range(2, K_max+1):
+            for K2 in range(200, 2200, 100):
+                for K1 in range(max(2, K-fuzz), min(K_max, K+fuzz)+1):
                     candidates += calculate(K, K1, K2, q_max, L_hash, trees)
                 progress += 1
                 print("searching: %3d %% \r" % (100.0 * progress / complete,), end=' ', file=stderr)
@@ -285,7 +285,7 @@ def search():
         step = 2.0
         bins = {}
         limit = floor_div(limit_cost, step)
-        for bin in xrange(0, limit+2):
+        for bin in range(0, limit+2):
             bins[bin] = []
 
         for c in candidates:
@@ -296,7 +296,7 @@ def search():
 
         # For each in a range of signing times, find the best candidate.
         best = []
-        for bin in xrange(0, limit):
+        for bin in range(0, limit):
             candidates = bins[bin] + bins[bin+1] + bins[bin+2]
             if len(candidates) > 0:
                 best += [min(candidates, key=lambda c: c['sig_bytes'])]

misc/simulators/simulate_load.py

@@ -4,6 +4,8 @@
 
 from __future__ import print_function
 
+from past.builtins import cmp
+
 import random
 
 SERVER_CAPACITY = 10**12

misc/simulators/sizes.py

@@ -2,6 +2,11 @@
 
 from __future__ import print_function
 
+from future.utils import PY2
+if PY2:
+    from future.builtins import input
+
+
 import random, math, re
 from twisted.python import usage
 
@@ -205,7 +210,7 @@ def graph():
         series["alacrity"][file_size] = s.bytes_until_some_data
     g.plot([ (fs, series["overhead"][fs])
              for fs in sizes ])
-    raw_input("press return")
+    input("press return")
 
 
 if __name__ == '__main__':