Python 2/3 compatibility - iterable

[serge-sans-paille]

Summary

map, items, zip, filter

[michaelplatings]

utils/ABITest/ABITestGen.py

233

Need to change the inner map

[serge-sans-paille]

utils/ABITest/ABITestGen.py

233

I don't think so: we don't care if the inner map produces a generator as it's immediately consumed.

[michaelplatings]

LGTM

bindings/python/examples/cindex/cindex-dump.py

     if not tu:
         parser.error("unable to load input")
 
-    pprint(('diags', map(get_diag_info, tu.diagnostics)))
+    pprint(('diags', [get_diag_info(d) for d in  tu.diagnostics]))
     pprint(('nodes', get_info(tu.cursor)))
 
 if __name__ == '__main__':

tools/scan-view/share/Reporter.py

         return 'Email'
 
     def getParameters(self):
-        return map(lambda x:TextParameter(x),['To', 'From', 'SMTP Server', 'SMTP Port'])
+        return [TextParameter(x) for x in ['To', 'From', 'SMTP Server', 'SMTP Port']]
 
     # Lifted from python email module examples.
     def attachFile(self, outer, path):

         return 'Bugzilla'
     
     def getParameters(self):
-        return map(lambda x:TextParameter(x),['URL','Product'])
+        return [TextParameter(x) for x in ['URL','Product']]
 
     def fileReport(self, report, parameters):
         raise NotImplementedError

 
         script = os.path.join(os.path.dirname(__file__),'../share/scan-view/FileRadar.scpt')
         args = ['osascript', script, component, componentVersion, classification, personID, report.title,
-                report.description, diagnosis, config] + map(os.path.abspath, report.files)
+                report.description, diagnosis, config] + [os.path.abspath(f) for f in report.files]
 #        print >>sys.stderr, args
         try:
           p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

tools/scan-view/share/ScanView.py

 def parse_query(qs, fields=None):
     if fields is None:
         fields = {}
-    for chunk in filter(None, qs.split('&')):
+    for chunk in (_f for _f in qs.split('&') if _f):
         if '=' not in chunk:
             name = chunk
             value = ''

utils/ABITest/ABITestGen.py

                 retvalTests = None
             else:
                 retvalTests = self.getTestValuesArray(FT.returnType)
-            tests = map(self.getTestValuesArray, FT.argTypes)
+            tests = [self.getTestValuesArray(ty) for ty in FT.argTypes]
             print >>self.outputTests, 'void test_%s(void) {'%(fnName,)
 
             if retvalTests is not None:

                     yield '{ %s }' % v
                 return
 
-            fieldValues = map(list, map(self.getTestValues, nonPadding))
+            fieldValues = [list(v) for v in map(self.getTestValues, nonPadding)]
             for i,values in enumerate(fieldValues):
                 for v in values:
-                    elements = map(random.choice,fieldValues)
+                    elements = [random.choice(fv) for fv in fieldValues]
                     elements[i] = v
                     yield '{ %s }'%(', '.join(elements))
 

utils/ABITest/TypeGen.py

                                                t.getBitFieldSize())
             else:
                 return '%s field%d;'%(printer.getTypeName(t),i)
-        fields = map(getField, enumerate(self.fields))
+        fields = [getField(f) for f in enumerate(self.fields)]
         # Name the struct for more readable LLVM IR.
         return 'typedef %s %s { %s } %s;'%(('struct','union')[self.isUnion],
                                            name, ' '.join(fields), name)

         isUnion,I = False,N
         if self.useUnion:
             isUnion,I = (I&1),I>>1
-        fields = map(self.typeGen.get,getNthTuple(I,self.maxSize,self.typeGen.cardinality))
+        fields = [self.typeGen.get(f) for f in getNthTuple(I,self.maxSize,self.typeGen.cardinality)]
         return RecordType(N, isUnion, fields)
 
 class FunctionTypeGenerator(TypeGenerator):

         else:
             retTy = None
             argIndices = getNthTuple(N, self.maxSize, self.typeGen.cardinality)
-        args = map(self.typeGen.get, argIndices)
+        args = [self.typeGen.get(i) for i in argIndices]
         return FunctionType(N, retTy, args)
 
 class AnyTypeGenerator(TypeGenerator):

utils/analyzer/CmpRuns.py

             combined_data['PathsLength'].append(diagnostic.getPathLength())
 
     for stat in results.stats:
-        for key, value in stat.iteritems():
+        for key, value in stat.items():
             combined_data[key].append(value)
     combined_stats = {}
-    for key, values in combined_data.iteritems():
+    for key, values in combined_data.items():
         combined_stats[str(key)] = {
             "max": max(values),
             "min": min(values),

utils/analyzer/SATestBuild.py

 
     # Iterate and find the differences.
     NumDiffs = 0
-    PairList = zip(RefList, NewList)
-    for P in PairList:
+    for P in zip(RefList, NewList):
         RefDir = P[0]
         NewDir = P[1]
 

utils/check_cfc/check_cfc.py

     PATH"""
     pathlist = path_var.split(os.pathsep)
     norm_directory = os.path.normpath(os.path.normcase(directory))
-    pathlist = filter(lambda x: os.path.normpath(
-        os.path.normcase(x)) != norm_directory, pathlist)
+    pathlist = [x for x in pathlist if os.path.normpath(
+        os.path.normcase(x)) != norm_directory]
     return os.pathsep.join(pathlist)
 
 def path_without_wrapper():

utils/check_cfc/obj_diff.py

     if p.returncode or err:
         print("Disassemble failed: {}".format(objfile))
         sys.exit(1)
-    return filter(keep_line, out.split(os.linesep))
+    return [line for line in out.split(os.linesep) if keep_line(line)]
 
 def dump_debug(objfile):
     """Dump all of the debug info from a file."""

     if p.returncode or err:
         print("Dump debug failed: {}".format(objfile))
         sys.exit(1)
-    return filter(keep_line, out.split(os.linesep))
+    return [line for line in out.split(os.linesep) if keep_line(line)]
 
 def first_diff(a, b, fromfile, tofile):
     """Returns the first few lines of a difference, if there is one.  Python

utils/perf-training/perf-helper.py

     for a in symbols:
       counts[a] = counts.get(a,0) + 1
 
-  by_count = counts.items()
-  by_count.sort(key = lambda (_,n): -n)
+  by_count = list(counts.items())
+  by_count.sort(key = lambda __n: -__n[1])
   return [s for s,n in by_count]
  
 def form_by_random(symbol_lists):

     help="write a list of the unordered symbols to PATH (requires --binary)",
     default=None, metavar="PATH")
   parser.add_argument("--method", dest="method",
-    help="order file generation method to use", choices=methods.keys(),
+    help="order file generation method to use", choices=list(methods.keys()),
     default='call_order')
   opts = parser.parse_args(args)
 

www/builtins.py

   sys.stderr.write("%s:%d: x86 builtin %s used, too many replacements\n" % (fileinput.filename(), fileinput.filelineno(), builtin))
 
 for line in fileinput.input(inplace=1):
-  for builtin, repl in repl_map.iteritems():
+  for builtin, repl in repl_map.items():
     if builtin in line:
       line = line.replace(builtin, repl)
       report_repl(builtin, repl)