Cleanup pylint errors

pylib/gyp/input.py

 # Copyright (c) 2012 Google Inc. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 from compiler.ast import Const
 from compiler.ast import Dict
 from compiler.ast import Discard
 from compiler.ast import List
 from compiler.ast import Module
 from compiler.ast import Node
@@ skipping 192 matching lines @@
     c = node.getChildren()
     children = []
     for index, child in enumerate(c):
       kp = list(keypath)  # Copy list.
       kp.append(repr(index))
       children.append(CheckNode(child, kp))
     return children
   elif isinstance(node, Const):
     return node.getChildren()[0]
   else:
-    raise TypeError, "Unknown AST node at key path '" + '.'.join(keypath) + \
-         "': " + repr(node)
+    raise TypeError("Unknown AST node at key path '" + '.'.join(keypath) +
+         "': " + repr(node))
 
 
 def LoadOneBuildFile(build_file_path, data, aux_data, includes,
                      is_target, check):
   if build_file_path in data:
     return data[build_file_path]
 
   if os.path.exists(build_file_path):
     build_file_contents = open(build_file_path).read()
   else:
@@ skipping 254 matching lines @@
     data_keys = set(data)
     aux_data_keys = set(aux_data)
 
     SetGeneratorGlobals(generator_input_info)
     result = LoadTargetBuildFile(build_file_path, data,
                                  aux_data, variables,
                                  includes, depth, check, False)
     if not result:
       return result
 
+    # pylint: disable=unpacking-non-sequence
     (build_file_path, dependencies) = result
 
     data_out = {}
     for key in data:
       if key == 'target_build_files':
         continue
       if key not in data_keys:
         data_out[key] = data[key]
     aux_data_out = {}
     for key in aux_data:
@@ skipping 169 matching lines @@
       if '1' <= string[0] <= '9':
         return string.isdigit()
 
   return False
 
 
 # This matches things like "<(asdf)", "<!(cmd)", "<!@(cmd)", "<|(list)",
 # "<!interpreter(arguments)", "<([list])", and even "<([)" and "<(<())".
 # In the last case, the inner "<()" is captured in match['content'].
 early_variable_re = re.compile(
-    '(?P<replace>(?P<type><(?:(?:!?@?)|\|)?)'
-    '(?P<command_string>[-a-zA-Z0-9_.]+)?'
-    '\((?P<is_array>\s*\[?)'
-    '(?P<content>.*?)(\]?)\))')
+    r'(?P<replace>(?P<type><(?:(?:!?@?)|\|)?)'
+    r'(?P<command_string>[-a-zA-Z0-9_.]+)?'
+    r'\((?P<is_array>\s*\[?)'
+    r'(?P<content>.*?)(\]?)\))')
 
 # This matches the same as early_variable_re, but with '>' instead of '<'.
 late_variable_re = re.compile(
-    '(?P<replace>(?P<type>>(?:(?:!?@?)|\|)?)'
-    '(?P<command_string>[-a-zA-Z0-9_.]+)?'
-    '\((?P<is_array>\s*\[?)'
-    '(?P<content>.*?)(\]?)\))')
+    r'(?P<replace>(?P<type>>(?:(?:!?@?)|\|)?)'
+    r'(?P<command_string>[-a-zA-Z0-9_.]+)?'
+    r'\((?P<is_array>\s*\[?)'
+    r'(?P<content>.*?)(\]?)\))')
 
 # This matches the same as early_variable_re, but with '^' instead of '<'.
 latelate_variable_re = re.compile(
-    '(?P<replace>(?P<type>[\^](?:(?:!?@?)|\|)?)'
-    '(?P<command_string>[-a-zA-Z0-9_.]+)?'
-    '\((?P<is_array>\s*\[?)'
-    '(?P<content>.*?)(\]?)\))')
+    r'(?P<replace>(?P<type>[\^](?:(?:!?@?)|\|)?)'
+    r'(?P<command_string>[-a-zA-Z0-9_.]+)?'
+    r'\((?P<is_array>\s*\[?)'
+    r'(?P<content>.*?)(\]?)\))')
 
 # Global cache of results from running commands so they don't have to be run
 # more then once.
 cached_command_results = {}
 
 
 def FixupPlatformCommand(cmd):
   if sys.platform == 'win32':
     if type(cmd) is list:
       cmd = [re.sub('^cat ', 'type ', cmd[0])] + cmd[1:]
@@ skipping 366 matching lines @@
     cond_expr, true_dict, false_dict, phase, variables, build_file):
   """Returns true_dict if cond_expr evaluates to true, and false_dict
   otherwise."""
   # Do expansions on the condition itself.  Since the conditon can naturally
   # contain variable references without needing to resort to GYP expansion
   # syntax, this is of dubious value for variables, but someone might want to
   # use a command expansion directly inside a condition.
   cond_expr_expanded = ExpandVariables(cond_expr, phase, variables,
                                        build_file)
   if type(cond_expr_expanded) not in (str, int):
-    raise ValueError, \
+    raise ValueError(
           'Variable expansion in this context permits str and int ' + \
-            'only, found ' + cond_expr_expanded.__class__.__name__
+            'only, found ' + cond_expr_expanded.__class__.__name__)
 
   try:
     if cond_expr_expanded in cached_conditions_asts:
       ast_code = cached_conditions_asts[cond_expr_expanded]
     else:
       ast_code = compile(cond_expr_expanded, '<string>', 'eval')
       cached_conditions_asts[cond_expr_expanded] = ast_code
     if eval(ast_code, {'__builtins__': None}, variables):
       return true_dict
     return false_dict
@@ skipping 121 matching lines @@
     ProcessVariablesAndConditionsInDict(the_dict['variables'], phase,
                                         variables, build_file, 'variables')
 
   LoadVariablesFromVariablesDict(variables, the_dict, the_dict_key)
 
   for key, value in the_dict.iteritems():
     # Skip "variables", which was already processed if present.
     if key != 'variables' and type(value) is str:
       expanded = ExpandVariables(value, phase, variables, build_file)
       if type(expanded) not in (str, int):
-        raise ValueError, \
+        raise ValueError(
               'Variable expansion in this context permits str and int ' + \
-              'only, found ' + expanded.__class__.__name__ + ' for ' + key
+              'only, found ' + expanded.__class__.__name__ + ' for ' + key)
       the_dict[key] = expanded
 
   # Variable expansion may have resulted in changes to automatics.  Reload.
   # TODO(mark): Optimization: only reload if no changes were made.
   variables = variables_in.copy()
   LoadAutomaticVariablesFromDict(variables, the_dict)
   LoadVariablesFromVariablesDict(variables, the_dict, the_dict_key)
 
   # Process conditions in this dict.  This is done after variable expansion
   # so that conditions may take advantage of expanded variables.  For example,
@@ skipping 48 matching lines @@
       ProcessVariablesAndConditionsInDict(value, phase, variables,
                                           build_file, key)
     elif type(value) is list:
       # The list itself can't influence the variables dict, and
       # ProcessVariablesAndConditionsInList will make copies of the variables
       # dict if it needs to pass it to something that can influence it.  No
       # copy is necessary here.
       ProcessVariablesAndConditionsInList(value, phase, variables,
                                           build_file)
     elif type(value) is not int:
-      raise TypeError, 'Unknown type ' + value.__class__.__name__ + \
-                       ' for ' + key
+      raise TypeError('Unknown type ' + value.__class__.__name__ + \
+                      ' for ' + key)
 
 
 def ProcessVariablesAndConditionsInList(the_list, phase, variables,
                                         build_file):
   # Iterate using an index so that new values can be assigned into the_list.
   index = 0
   while index < len(the_list):
     item = the_list[index]
     if type(item) is dict:
       # Make a copy of the variables dict so that it won't influence anything
       # outside of its own scope.
       ProcessVariablesAndConditionsInDict(item, phase, variables, build_file)
     elif type(item) is list:
       ProcessVariablesAndConditionsInList(item, phase, variables, build_file)
     elif type(item) is str:
       expanded = ExpandVariables(item, phase, variables, build_file)
       if type(expanded) in (str, int):
         the_list[index] = expanded
       elif type(expanded) is list:
         the_list[index:index+1] = expanded
         index += len(expanded)
 
         # index now identifies the next item to examine.  Continue right now
         # without falling into the index increment below.
         continue
       else:
-        raise ValueError, \
+        raise ValueError(
               'Variable expansion in this context permits strings and ' + \
               'lists only, found ' + expanded.__class__.__name__ + ' at ' + \
-              index
+              index)
     elif type(item) is not int:
-      raise TypeError, 'Unknown type ' + item.__class__.__name__ + \
-                       ' at index ' + index
+      raise TypeError('Unknown type ' + item.__class__.__name__ + \
+                      ' at index ' + index)
     index = index + 1
 
 
 def BuildTargetsDict(data):
   """Builds a dict mapping fully-qualified target names to their target dicts.
 
   |data| is a dict mapping loaded build files by pathname relative to the
   current directory.  Values in |data| are build file contents.  For each
   |data| value with a "targets" key, the value of the "targets" key is taken
   as a list containing target dicts.  Each target's fully-qualified name is
@@ skipping 732 matching lines @@
       MergeDicts(to_item, item, to_file, fro_file)
     elif type(item) is list:
       # Recurse, making a copy of the list.  If the list contains any
       # descendant dicts, path fixing will occur.  Note that here, custom
       # values for is_paths and append are dropped; those are only to be
       # applied to |to| and |fro|, not sublists of |fro|.  append shouldn't
       # matter anyway because the new |to_item| list is empty.
       to_item = []
       MergeLists(to_item, item, to_file, fro_file)
     else:
-      raise TypeError, \
+      raise TypeError(
           'Attempt to merge list item of unsupported type ' + \
-          item.__class__.__name__
+          item.__class__.__name__)
 
     if append:
       # If appending a singleton that's already in the list, don't append.
       # This ensures that the earliest occurrence of the item will stay put.
       if not singleton or not is_in_set_or_list(to_item, hashable_to_set, to):
         to.append(to_item)
         if is_hashable(to_item):
           hashable_to_set.add(to_item)
     else:
       # If prepending a singleton that's already in the list, remove the
@@ skipping 21 matching lines @@
     # modified.
     if k in to:
       bad_merge = False
       if type(v) in (str, int):
         if type(to[k]) not in (str, int):
           bad_merge = True
       elif type(v) is not type(to[k]):
         bad_merge = True
 
       if bad_merge:
-        raise TypeError, \
+        raise TypeError(
             'Attempt to merge dict value of type ' + v.__class__.__name__ + \
             ' into incompatible type ' + to[k].__class__.__name__ + \
-            ' for key ' + k
+            ' for key ' + k)
     if type(v) in (str, int):
       # Overwrite the existing value, if any.  Cheap and easy.
       is_path = IsPathSection(k)
       if is_path:
         to[k] = MakePathRelative(to_file, fro_file, v)
       else:
         to[k] = v
     elif type(v) is dict:
       # Recurse, guaranteeing copies will be made of objects that require it.
       if not k in to:
@@ skipping 38 matching lines @@
                          list_incompatible)
 
       if list_base in to:
         if ext == '?':
           # If the key ends in "?", the list will only be merged if it doesn't
           # already exist.
           continue
         elif type(to[list_base]) is not list:
           # This may not have been checked above if merging in a list with an
           # extension character.
-          raise TypeError, \
+          raise TypeError(
               'Attempt to merge dict value of type ' + v.__class__.__name__ + \
               ' into incompatible type ' + to[list_base].__class__.__name__ + \
-              ' for key ' + list_base + '(' + k + ')'
+              ' for key ' + list_base + '(' + k + ')')
       else:
         to[list_base] = []
 
       # Call MergeLists, which will make copies of objects that require it.
       # MergeLists can recurse back into MergeDicts, although this will be
       # to make copies of dicts (with paths fixed), there will be no
       # subsequent dict "merging" once entering a list because lists are
       # always replaced, appended to, or prepended to.
       is_paths = IsPathSection(list_base)
       MergeLists(to[list_base], v, to_file, fro_file, is_paths, append)
     else:
-      raise TypeError, \
+      raise TypeError(
           'Attempt to merge dict value of unsupported type ' + \
-          v.__class__.__name__ + ' for key ' + k
+          v.__class__.__name__ + ' for key ' + k)
 
 
 def MergeConfigWithInheritance(new_configuration_dict, build_file,
                                target_dict, configuration, visited):
   # Skip if previously visted.
   if configuration in visited:
     return
 
   # Look at this configuration.
   configuration_dict = target_dict['configurations'][configuration]
@@ skipping 124 matching lines @@
   # can't be done while iterating through it.
 
   lists = []
   del_lists = []
   for key, value in the_dict.iteritems():
     operation = key[-1]
     if operation != '!' and operation != '/':
       continue
 
     if type(value) is not list:
-      raise ValueError, name + ' key ' + key + ' must be list, not ' + \
-                        value.__class__.__name__
+      raise ValueError(name + ' key ' + key + ' must be list, not ' + \
+                       value.__class__.__name__)
 
     list_key = key[:-1]
     if list_key not in the_dict:
       # This happens when there's a list like "sources!" but no corresponding
       # "sources" list.  Since there's nothing for it to operate on, queue up
       # the "sources!" list for deletion now.
       del_lists.append(key)
       continue
 
     if type(the_dict[list_key]) is not list:
       value = the_dict[list_key]
-      raise ValueError, name + ' key ' + list_key + \
-                        ' must be list, not ' + \
-                        value.__class__.__name__ + ' when applying ' + \
-                        {'!': 'exclusion', '/': 'regex'}[operation]
+      raise ValueError(name + ' key ' + list_key + \
+                       ' must be list, not ' + \
+                       value.__class__.__name__ + ' when applying ' + \
+                       {'!': 'exclusion', '/': 'regex'}[operation])
 
     if not list_key in lists:
       lists.append(list_key)
 
   # Delete the lists that are known to be unneeded at this point.
   for del_list in del_lists:
     del the_dict[del_list]
 
   for list_key in lists:
     the_list = the_dict[list_key]
@@ skipping 28 matching lines @@
         pattern_re = re.compile(pattern)
 
         if action == 'exclude':
           # This item matches an exclude regex, so set its value to 0 (exclude).
           action_value = 0
         elif action == 'include':
           # This item matches an include regex, so set its value to 1 (include).
           action_value = 1
         else:
           # This is an action that doesn't make any sense.
-          raise ValueError, 'Unrecognized action ' + action + ' in ' + name + \
-                            ' key ' + regex_key
+          raise ValueError('Unrecognized action ' + action + ' in ' + name + \
+                           ' key ' + regex_key)
 
         for index in xrange(0, len(the_list)):
           list_item = the_list[index]
           if list_actions[index] == action_value:
             # Even if the regex matches, nothing will change so continue (regex
             # searches are expensive).
             continue
           if pattern_re.search(list_item):
             # Regular expression match.
             list_actions[index] = action_value
@@ skipping 428 matching lines @@
     ValidateRunAsInTarget(target, target_dict, build_file)
     ValidateActionsInTarget(target, target_dict, build_file)
 
   # Generators might not expect ints.  Turn them into strs.
   TurnIntIntoStrInDict(data)
 
   # TODO(mark): Return |data| for now because the generator needs a list of
   # build files that came in.  In the future, maybe it should just accept
   # a list, and not the whole data dict.
   return [flat_list, targets, data]