Replace the overfix of 2to3 with six.string_types

Author: velconia

python/paddle/fluid/clip.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 import copy
+import six
 
 import functools
 from . import layers
@@ -246,8 +247,8 @@ class GradientClipByGlobalNorm(BaseGradientClipAttr):
     """
 
     def __init__(self, clip_norm, group_name="default_group"):
-        if not isinstance(group_name, str):
-            raise TypeError("'group_name' must be a basestring.")
+        if not isinstance(group_name, six.string_types):
+            raise TypeError("'group_name' must be a %s." % (six.string_types))
 
         self.clip_norm = clip_norm
         self.group_name = group_name
@@ -312,7 +313,7 @@ def set_gradient_clip(clip, param_list=None, program=None):
         program = framework.default_main_program()
     if param_list is None:
         param_list = program.block(0).all_parameters()
-    if all(isinstance(elem, str) for elem in param_list):
+    if all(isinstance(elem, six.string_types) for elem in param_list):
         param_list = [program.block(0).var(elem) for elem in param_list]
     if not all(isinstance(elem, framework.Parameter) for elem in param_list):
         raise TypeError(

python/paddle/fluid/data_feeder.py

@@ -15,7 +15,8 @@
 from . import core
 import numpy
 import os
-import six.moves as six
+import six
+from six.moves import zip, range, xrange
 import multiprocessing
 
 from .framework import Variable, default_main_program
@@ -52,7 +53,7 @@ def __init__(self, place, lod_level, shape, dtype):
         self.data = []
         self.lod = []
 
-        for i in six.range(lod_level):
+        for i in six.moves.range(lod_level):
             self.lod.append([])
 
     def feed(self, data):
@@ -141,7 +142,7 @@ def __init__(self, feed_list, place, program=None):
         if program is None:
             program = default_main_program()
         for each_var in feed_list:
-            if isinstance(each_var, str):
+            if isinstance(each_var, six.string_types):
                 each_var = program.block(0).var(each_var)
             if not isinstance(each_var, Variable):
                 raise TypeError("Feed list should contain a list of variable")
@@ -173,7 +174,7 @@ def feed(self, iterable):
             dict: the result of conversion.
         """
         converter = []
-        for lod_level, shape, dtype in six.zip(
+        for lod_level, shape, dtype in six.moves.zip(
                 self.feed_lod_level, self.feed_shapes, self.feed_dtypes):
             converter.append(
                 DataToLoDTensorConverter(
@@ -186,10 +187,12 @@ def feed(self, iterable):
             assert len(each_sample) == len(converter), (
                 "The number of fields in data (%s) does not match " +
                 "len(feed_list) (%s)") % (len(each_sample), len(converter))
-            for each_converter, each_slot in six.zip(converter, each_sample):
+            for each_converter, each_slot in six.moves.zip(converter,
+                                                           each_sample):
                 each_converter.feed(each_slot)
         ret_dict = {}
-        for each_name, each_converter in six.zip(self.feed_names, converter):
+        for each_name, each_converter in six.moves.zip(self.feed_names,
+                                                       converter):
             ret_dict[each_name] = each_converter.done()
         return ret_dict
 
@@ -211,12 +214,14 @@ def feed_parallel(self, iterable, num_places=None):
         if isinstance(self.place, core.CUDAPlace):
             places = [
                 core.CUDAPlace(i)
-                for i in six.xrange(self._get_number_of_places_(num_places))
+                for i in six.moves.xrange(
+                    self._get_number_of_places_(num_places))
             ]
         else:
             places = [
                 core.CPUPlace()
-                for _ in six.xrange(self._get_number_of_places_(num_places))
+                for _ in six.moves.xrange(
+                    self._get_number_of_places_(num_places))
             ]
 
         if len(iterable) != len(places):
@@ -226,7 +231,7 @@ def feed_parallel(self, iterable, num_places=None):
                              "must be same.")
 
         place = self.place
-        for p, batch in six.zip(places, iterable):
+        for p, batch in six.moves.zip(places, iterable):
             self.place = p
             yield self.feed(batch)
         self.place = place

python/paddle/fluid/executor.py

@@ -14,6 +14,7 @@
 
 import numpy as np
 import contextlib
+import six
 from .framework import Program, default_main_program, Variable
 from . import core
 
@@ -211,7 +212,7 @@ def to_name_str(var):
             return var.desc.name()
         elif isinstance(var, str):
             return var
-        elif isinstance(var, str):
+        elif isinstance(var, six.string_types):
             return str(var)
         else:
             raise TypeError(str(var) + " should be Variable or str")
@@ -229,8 +230,8 @@ class Executor(object):
     to feed map and fetch_list. Feed map provides input data for the program. fetch_list provides
     the variables(or names) that user want to get after program run. Note: the executor will run all
     operators in the program but not only the operators dependent by the fetch_list.
-    It store the global variables into the global scope, and create a local scope for the temporary 
-    variables. The local scope contents will be discarded after every minibatch forward/backward finished. 
+    It store the global variables into the global scope, and create a local scope for the temporary
+    variables. The local scope contents will be discarded after every minibatch forward/backward finished.
     But the global scope variables will be persistent through different runs.
     All of ops in program will be running in sequence.
 

python/paddle/fluid/framework.py

@@ -524,12 +524,12 @@ def find_name(var_list, name):
                             % (in_proto.name, len(in_args)))
                     in_arg_names = []
                     for arg in in_args:
-                        if issubclass(arg.__class__, six.string_types):
+                        if isinstance(arg, six.string_types):
                             in_arg_names.append(arg)
                         elif isinstance(arg, six.binary_type):
                             in_arg_names.append(arg.decode())
                         else:
-                            if issubclass(arg.name.__class__, six.string_types):
+                            if isinstance(arg.name, six.string_types):
                                 in_arg_names.append(arg.name)
                             elif isinstance(arg.name, six.binary_type):
                                 in_arg_names.append(arg.name.decode())
@@ -561,7 +561,7 @@ def find_name(var_list, name):
                         (out_proto.name, len(out_args)))
                 out_arg_names = []
                 for arg in out_args:
-                    if issubclass(arg.name.__class__, six.string_types):
+                    if isinstance(arg.name, six.string_types):
                         out_arg_names.append(arg.name)
                     elif isinstance(arg.name, six.binary_type):
                         out_arg_names.append(arg.name.decode())
@@ -911,7 +911,7 @@ def var(self, name):
         Returns:
             Variable: the Variable with the giving name.
         """
-        if not issubclass(name.__class__, six.string_types):
+        if not isinstance(name, six.string_types):
             if not isinstance(name, six.binary_type):
                 raise TypeError(
                     "var require string as parameter, but get %s instead." %

python/paddle/fluid/graphviz.py

@@ -14,12 +14,13 @@
 
 import os
 import random
+import six
 import subprocess
 import logging
 
 
 def crepr(v):
-    if type(v) is str or type(v) is str:
+    if isinstance(v, six.string_types):
         return '"%s"' % v
     return str(v)
 

python/paddle/fluid/io.py

@@ -612,9 +612,6 @@ def save_inference_model(dirname,
                 if not (all(
                         isinstance(name, six.text_type)
                         for name in feeded_var_names)):
-                    import sys
-                    print([type(name) for name in feeded_var_names])
-                    sys.stdout.flush()
                     raise ValueError(
                         "'feed_var_names' should be a list of str.")
                 else:

python/paddle/fluid/layer_helper.py

@@ -14,6 +14,7 @@
 
 import copy
 import itertools
+import six
 
 from .framework import Variable, Parameter, default_main_program, default_startup_program, dtype_is_floating
 from . import unique_name
@@ -398,7 +399,7 @@ def append_activation(self, input_var):
         act = self.kwargs.get('act', None)
         if act is None:
             return input_var
-        if isinstance(act, str):
+        if isinstance(act, six.string_types):
             act = {'type': act}
 
         if 'use_cudnn' in self.kwargs and self.kwargs.get('use_cudnn'):

python/paddle/fluid/op.py

@@ -32,7 +32,7 @@ def get_all_op_protos():
 
 
 def is_str(s):
-    return isinstance(s, str) or isinstance(s, str)
+    return isinstance(s, six.string_types)
 
 
 class OpDescCreationMethod(object):

python/paddle/fluid/param_attr.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import six
+
 from .initializer import Initializer, Xavier, Constant
 from .regularizer import WeightDecayRegularizer
 
@@ -134,7 +136,7 @@ def _to_attr(arg):
             return [ParamAttr._to_attr(a) for a in arg]
         elif isinstance(arg, ParamAttr):
             return arg
-        elif isinstance(arg, str) or isinstance(arg, str):
+        elif isinstance(arg, six.string_types):
             return ParamAttr(name=arg)
         elif isinstance(arg, Initializer):
             return ParamAttr(initializer=arg)

python/paddle/fluid/tests/unittests/benchmark.py

@@ -16,6 +16,7 @@
 import unittest
 import time
 import itertools
+import six
 
 import paddle.fluid as fluid
 import paddle.fluid.core as core
@@ -40,7 +41,8 @@ def _assert_cpu_gpu_same(self, cpu_outs, gpu_outs, fetch_list, atol):
             expect_t = np.array(item_cpu_out)
             actual = item_gpu_out
             actual_t = np.array(item_gpu_out)
-            var_name = variable if isinstance(variable, str) else variable.name
+            var_name = variable if isinstance(
+                variable, six.string_types) else variable.name
             self.assertTrue(
                 np.allclose(
                     actual_t, expect_t, atol=atol),