Fbandroid/native to Python 3.

Reviewed By: dkgi

Differential Revision: D35147434

fbshipit-source-id: bf0078e74e7101842101270bce407e38e114fbc1

Author: lisroach

gen_simple_module.py

@@ -164,7 +164,7 @@ def write_py_wrapper(base_64_bytes_blob, files, filename, tar_xz):
                 compression_specific_api=_TAR_XZ_API if tar_xz else _ZIP_API,
             )
         )
-        for key, val in files.items():
+        for key, val in list(files.items()):
             f.write(f'{key} = _load("{os.path.basename(val)}")\n')
 
 
@@ -174,7 +174,7 @@ def main():
         key_val[: key_val.find("=")]: key_val[key_val.find("=") + 1 :]
         for key_val in args.inputs
     }
-    base64_blob = compress_and_base_64(files.values(), args.tarxz)
+    base64_blob = compress_and_base_64(list(files.values()), args.tarxz)
     write_py_wrapper(base64_blob, files, args.output, args.tarxz)
 
 

opt/basic-block/trace_analysis.py

@@ -63,30 +63,38 @@ def main():
 
     print("========Summary=========")
     if trace:
-        print("Num of Methods:  %d, Num of Blocks: %d" % (num_methods, num_blocks))
+        print(("Num of Methods:  %d, Num of Blocks: %d" % (num_methods, num_blocks)))
         print(
-            "Blocks/Method: %.2f, Instructions/Block: %.2f"
-            % (num_blocks / num_methods, num_instructions / num_blocks)
+            (
+                "Blocks/Method: %.2f, Instructions/Block: %.2f"
+                % (num_blocks / num_methods, num_instructions / num_blocks)
+            )
         )
-        print("Average Degree: %.2f" % (fan_in / num_blocks))
-        print("Number of Virtual Methods: %d" % (num_virtual))
+        print(("Average Degree: %.2f" % (fan_in / num_blocks)))
+        print(("Number of Virtual Methods: %d" % (num_virtual)))
         print(
-            "%dth percentile in Method Size: %.2f"
-            % (
-                int(args.percentile),
-                np.percentile(np.array(method_size_array), int(args.percentile)),
+            (
+                "%dth percentile in Method Size: %.2f"
+                % (
+                    int(args.percentile),
+                    np.percentile(np.array(method_size_array), int(args.percentile)),
+                )
             )
         )
         print(
-            "%dth percentile in Block Size: %.2f"
-            % (
-                int(args.percentile),
-                np.percentile(np.array(block_size_array), int(args.percentile)),
+            (
+                "%dth percentile in Block Size: %.2f"
+                % (
+                    int(args.percentile),
+                    np.percentile(np.array(block_size_array), int(args.percentile)),
+                )
             )
         )
         print(
-            "Methods of size %d: %d"
-            % (int(args.countSize), method_size_array.count(int(args.countSize)))
+            (
+                "Methods of size %d: %d"
+                % (int(args.countSize), method_size_array.count(int(args.countSize)))
+            )
         )
         # print method_size_array
         # print block_size_array

pyredex/unpacker.py

@@ -645,7 +645,7 @@ def unpackage(
                 with open(jarpath, "wb") as jar:
                     jar.write(cj.read(jar_sizes[i]))
 
-        for j in jar_sizes.keys():
+        for j in list(jar_sizes.keys()):
             jar_size = getsize(
                 dex_dir + "/" + self._store_name + "-" + str(j) + ".dex.jar"
             )

redex_gdb_hooks.py

@@ -159,7 +159,7 @@ def invoke(self, arg, from_tty):
         val = get_gdb_val_for_str(arg)
         printer = lookup_function(val)
         if printer is None:
-            print('No symbol "{0}" in current context'.format(arg))
+            print(('No symbol "{0}" in current context'.format(arg)))
             return
         printer.to_string()
 

test/bisect-passes.py

@@ -40,7 +40,7 @@ def bisect(passes, config, config_path, cmd):
     while lower < upper - 1:
         m = (lower + upper) / 2
         testpasses = slice_passes(passes, lower, m)
-        print("Testing passes: " + str(testpasses))
+        print(("Testing passes: " + str(testpasses)))
         config["redex"]["passes"] = testpasses
         with open(config_path, "w") as config_file:
             json.dump(config, config_file)
@@ -64,7 +64,7 @@ def bisect(passes, config, config_path, cmd):
 
     try:
         bad_passes = bisect(config["redex"]["passes"], config, args.config, args.cmd)
-        print("FAILING PASSES:" + str(bad_passes))
+        print(("FAILING PASSES:" + str(bad_passes)))
     finally:
         with open(args.config, "w") as config_file:
             config_file.write(contents)

tools/callgraph-analysis/corelib/loader.py

@@ -72,7 +72,7 @@ def get_nodes_in_class(self, class_name):
             print("class not exist in callgraph")
             return None
         return_val = []
-        for value in self.node_classes[class_name].values():
+        for value in list(self.node_classes[class_name].values()):
             return_val.extend(value)
         return return_val
 

tools/hprof/dump_classes_from_hprof.py

@@ -497,14 +497,14 @@ def resolve(self, hprof_data):
                 merged_fields_builder[name][clazz.name] = value
             clazz = clazz.super_class
 
-        for key, value in merged_fields_builder.items():
+        for key, value in list(merged_fields_builder.items()):
             # Avoid over-writing python internals, like __dict__
             if key in self.fields.__dict__:
                 key = "__hprof_" + key
                 assert key not in self.fields.__dict__
 
             if len(value) == 1:
-                setattr(self.fields, key, next(iter(value.values())))
+                setattr(self.fields, key, next(iter(list(value.values()))))
             else:
                 # There is a conflict in the class hierarchy (e.g. privates with the
                 # same name), so we need to store a dictionary.
@@ -522,8 +522,8 @@ def outgoing_references(self, filter_function=lambda x: True):
         # and attribute weight the wrong way.
         # Classes should be walked explicitly
         refs = []
-        for class_name, fields in self.class_fields.items():
-            for name, value in fields.items():
+        for class_name, fields in list(self.class_fields.items()):
+            for name, value in list(fields.items()):
                 if isinstance(value, HprofObject) and filter_function(value):
                     refs.append(FieldReference(self, value, class_name, name))
         return refs
@@ -959,11 +959,11 @@ def add_root(self, hprof_root):
 
     def resolve(self):
         # First resolve heaps
-        for heap in self.heap_dict.values():
+        for heap in list(self.heap_dict.values()):
             heap.resolve(self)
 
         # Then resolve classes
-        for obj in self.object_id_dict.values():
+        for obj in list(self.object_id_dict.values()):
             if isinstance(obj, HprofClass):
                 clazz = obj
                 clazz.resolve(self)
@@ -976,18 +976,18 @@ def resolve(self):
                             self.class_name_dict[clazz.name]
                         )
                     self.dupe_class_dict[clazz.name].append(clazz)
-                    print("Warning: duplicate class: %s" % clazz.name)
+                    print(("Warning: duplicate class: %s" % clazz.name))
                 else:
                     self.class_name_dict[clazz.name] = clazz
         # Fix up all classes to derive from java.lang.Class
         # at the time we create every HprofClass 'java.lang.Class' may have
         # not be parsed yet and thus unavailable
         clsCls = self.class_name_dict["java.lang.Class"]
-        for cls in self.class_name_dict.values():
+        for cls in list(self.class_name_dict.values()):
             cls.clazz = clsCls
 
         # Then other objects
-        for obj in self.object_id_dict.values():
+        for obj in list(self.object_id_dict.values()):
             if not isinstance(obj, HprofClass):
                 obj.resolve(self)
             obj.is_root = False  # Fixed up for root objects below
@@ -1019,15 +1019,15 @@ def lookup_load_class_record(self, class_object_id):
     def lookup_instances_of_class(self, class_name):
         return [
             obj
-            for obj in self.object_id_dict.values()
+            for obj in list(self.object_id_dict.values())
             if isinstance(obj, HprofInstance) and obj.clazz.name == class_name
         ]
 
     def load_inverted_references(self):
         if self.inverted_references is None:
             # Will be much faster for later invocations
             self.inverted_references = defaultdict(list)
-            for heap_obj in self.object_id_dict.values():
+            for heap_obj in list(self.object_id_dict.values()):
                 for ref in heap_obj.outgoing_references():
                     self.inverted_references[ref.referee].append(ref)
 
@@ -1121,7 +1121,7 @@ def roots_of_obj(hprof_data, obj):
 
 def zygote_references_to_app_objects(hprof_data):
     references = []
-    for obj in hprof_data.object_id_dict.values():
+    for obj in list(hprof_data.object_id_dict.values()):
         if obj.heap.name == "zygote":
             for reference in obj.outgoing_references():
                 if reference.referee.heap.name != "zygote":
@@ -1154,7 +1154,7 @@ def write_bitmap(bitmap_instance, filename):
 def open_bitmaps(bitmap_instances):
     tmp_dir = tempfile.mkdtemp(suffix="bitmaps")
     subprocess.call(["open", tmp_dir])  # this only works in Mac - sorry!
-    print("Writing %d bitmaps to %s." % (len(bitmap_instances), tmp_dir))
+    print(("Writing %d bitmaps to %s." % (len(bitmap_instances), tmp_dir)))
     for i, bitmap in enumerate(bitmap_instances):
         write_bitmap(bitmap, os.path.join(tmp_dir, "bitmap_%s.png" % bitmap.object_id))
         sys.stdout.write("\r%d of %d complete" % (i + 1, len(bitmap_instances)))
@@ -1174,12 +1174,12 @@ def print_view_tree(view_root=None):
         else:
             view_root = all_view_roots[0]
     else:
-        print("not an hprofdata: %s" % view_root.__class__)
+        print(("not an hprofdata: %s" % view_root.__class__))
 
-    print("%s" % view_root)
+    print(("%s" % view_root))
 
     def print_view_node(view_node, indent):
-        print("%s%s" % (indent, view_node))
+        print(("%s%s" % (indent, view_node)))
         if "android.view.ViewGroup" in view_node.class_fields:
             children = view_node.class_fields["android.view.ViewGroup"]["mChildren"]
             for child in children.array_values:
@@ -1364,25 +1364,30 @@ def forward_comparator(x, y):
 # substring can result in wasted char arrays
 # This isn't exact - need to figure out way of determining unused chars in the middle
 def wasted_string_char_arrays(hprof_data):
-    char_arrays = filter(
-        lambda v: isinstance(v, HprofPrimitiveArray) and v.prim_type is HprofBasic.CHAR,
-        hprof_data.object_id_dict.values(),
+    char_arrays = list(
+        filter(
+            lambda v: isinstance(v, HprofPrimitiveArray)
+            and v.prim_type is HprofBasic.CHAR,
+            list(hprof_data.object_id_dict.values()),
+        )
     )
-    with_wasted = map(lambda x: (x, wasted_segments(x)), char_arrays)
-    return filter(lambda x: len(x[1]) > 0, with_wasted)
+    with_wasted = [(x, wasted_segments(x)) for x in char_arrays]
+    return [x for x in with_wasted if len(x[1]) > 0]
 
 
 def wasted_string_char_count(hprof_data):
     wasted_char_array_info = wasted_string_char_arrays(hprof_data)
 
     def segment_length(segments):
-        return sum(map(lambda x: x[1] - x[0], segments))
+        return sum([x[1] - x[0] for x in segments])
 
-    return sum(map(lambda x: segment_length(x[1]), wasted_char_array_info))
+    return sum([segment_length(x[1]) for x in wasted_char_array_info])
 
 
 def app_heap_objects(hprof_data):
-    return [o for o in hprof_data.object_id_dict.values() if o.heap.name != "zygote"]
+    return [
+        o for o in list(hprof_data.object_id_dict.values()) if o.heap.name != "zygote"
+    ]
 
 
 # return a set of containing 'clazz' and all its subclasses
@@ -1410,7 +1415,9 @@ def instances_in(hprof_data, classes):
             classes = set(classes)
         else:
             classes = {classes}
-    return {obj for obj in hprof_data.object_id_dict.values() if obj.clazz in classes}
+    return {
+        obj for obj in list(hprof_data.object_id_dict.values()) if obj.clazz in classes
+    }
 
 
 # return a map of class => {instances} for the given sequence of instances
@@ -1436,7 +1443,7 @@ def java_locals(hprof_data):
         for root in hprof_data.roots
         if root.heap_tag == HeapTag.ROOT_THREAD_OBJECT
     }
-    thread_locals = {thread: set() for thread in threads.values()}
+    thread_locals = {thread: set() for thread in list(threads.values())}
     for loc in locs:
         thread_locals[threads[loc.thread_serial]].add(loc.obj)
     return thread_locals
@@ -1458,7 +1465,7 @@ def java_locals(hprof_data):
     allow_missing_ids = args.allow_missing_ids
     hp = parse_filename(args.hprof)
     classes = []
-    for cls_name, cls in hp.class_name_dict.items():
+    for cls_name, cls in list(hp.class_name_dict.items()):
         classes.append(
             (
                 cls_name,

tools/python/test/test_dex.py

@@ -35,19 +35,19 @@ def test_find_string_idx(self):
 
         for i, s_data_item in enumerate(strings):
             idx = dex_file.find_string_idx(s_data_item)
-            self.assertEquals(i, idx, f'Different index for "{s_data_item.data}"')
+            self.assertEqual(i, idx, f'Different index for "{s_data_item.data}"')
 
             idx = dex_file.find_string_idx(s_data_item.data)
-            self.assertEquals(i, idx, f'Different index for "{s_data_item.data}"')
+            self.assertEqual(i, idx, f'Different index for "{s_data_item.data}"')
 
         # Synthesize some strings.
         for s_data_item in strings:
             if s_data_item.data:
                 input = s_data_item.data
                 before = chr(ord(input[0]) - 1) + input[1:]
                 idx = dex_file.find_string_idx(before)
-                self.assertEquals(idx, -1, f'Found "{before}"')
+                self.assertEqual(idx, -1, f'Found "{before}"')
 
             after = s_data_item.data + "X"
             idx = dex_file.find_string_idx(after)
-            self.assertEquals(idx, -1, f'Found "{after}"')
+            self.assertEqual(idx, -1, f'Found "{after}"')

tools/reachability-analysis/lib/analysis.py

@@ -43,12 +43,12 @@ def group_by_common_keys(d):
     matched classes.
     """
     value_to_keys = defaultdict(set)
-    for k, values in d.items():
+    for k, values in list(d.items()):
         for v in values:
             value_to_keys[v].add(k)
 
     grouped_keys = defaultdict(set)
-    for value, keys in value_to_keys.items():
+    for value, keys in list(value_to_keys.items()):
         grouped_keys[frozenset(keys)].add(value)
 
     return grouped_keys
@@ -59,7 +59,7 @@ def find_nodes(graph, filter_fn):
     Find all nodes whose names pass the predicate :filter_fn.
     """
     nodes = set()
-    for node in graph.nodes.values():
+    for node in list(graph.nodes.values()):
         if filter_fn(node.name):
             nodes.add(node)
     return nodes
@@ -70,7 +70,7 @@ def find_nodes_in_packages(graph, pkg_prefixes):
     Find all nodes that fall under the list of :pkg_prefixes.
     """
     nodes = set()
-    for node in graph.nodes.values():
+    for node in list(graph.nodes.values()):
         for pkg_prefix in pkg_prefixes:
             # If we have an array, use its base type
             base_type = node.name.lstrip("[")
@@ -121,7 +121,7 @@ def group_members_by_class(graph):
     Return a map of class -> set of members in that class.
     """
     grouped_members = defaultdict(set)
-    for (ty, name), node in graph.nodes.items():
+    for (ty, name), node in list(graph.nodes.items()):
         if ty in [ReachableObjectType.FIELD, ReachableObjectType.METHOD]:
             cls, sep, _ = name.partition(";")
             cls += ";"
@@ -157,13 +157,13 @@ def mark(node):
         for succ in node.succs:
             mark(succ)
 
-    seeds = [node for node in graph.nodes.values() if len(node.preds) == 0]
+    seeds = [node for node in list(graph.nodes.values()) if len(node.preds) == 0]
 
     for seed in seeds:
         mark(seed)
 
     closure = set()
-    for node in graph.nodes.values():
+    for node in list(graph.nodes.values()):
         if node not in visited:
             closure.add(node)