Update style according to advice from pylint.

tools/auto_bisect/bisect_perf_regression.py

 #!/usr/bin/env python
 # Copyright (c) 2013 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Performance Test Bisect Tool
 
 This script bisects a series of changelists using binary search. It starts at
 a bad revision where a performance metric has regressed, and asks for a last
 known-good revision. It will then binary search across this revision range by
@@ skipping 134 matching lines @@
       # Android builds are also archived with the "full-build-linux prefix.
       return 'linux'
     if bisect_utils.IsMacHost():
       return 'mac'
     raise NotImplementedError('Unknown platform "%s".' % sys.platform)
 
   base_name = 'full-build-%s' % PlatformName()
   if not build_revision:
     return base_name
   if patch_sha:
-    build_revision = '%s_%s' % (build_revision , patch_sha)
+    build_revision = '%s_%s' % (build_revision, patch_sha)
   return '%s_%s.zip' % (base_name, build_revision)
 
 
 def GetRemoteBuildPath(build_revision, target_platform='chromium',
                        target_arch='ia32', patch_sha=None):
   """Returns the URL to download the build from."""
   def GetGSRootFolderName(target_platform):
     """Returns the Google Cloud Storage root folder name."""
     if bisect_utils.IsWindowsHost():
       if bisect_utils.Is64BitWindows() and target_arch == 'x64':
@@ skipping 100 matching lines @@
         os.chmod(os.path.join(output_dir, name),
                  zf.getinfo(name).external_attr >> 16L)
 
 
 def WriteStringToFile(text, file_name):
   """Writes text to a file, raising an RuntimeError on failure."""
   try:
     with open(file_name, 'wb') as f:
       f.write(text)
   except IOError:
-    raise RuntimeError('Error writing to file [%s]' % file_name )
+    raise RuntimeError('Error writing to file [%s]' % file_name)
 
 
 def ReadStringFromFile(file_name):
   """Writes text to a file, raising an RuntimeError on failure."""
   try:
     with open(file_name) as f:
       return f.read()
   except IOError:
-    raise RuntimeError('Error reading file [%s]' % file_name )
+    raise RuntimeError('Error reading file [%s]' % file_name)
 
 
 def ChangeBackslashToSlashInPatch(diff_text):
   """Formats file paths in the given patch text to Unix-style paths."""
   if not diff_text:
     return None
   diff_lines = diff_text.split('\n')
   for i in range(len(diff_lines)):
     line = diff_lines[i]
     if line.startswith('--- ') or line.startswith('+++ '):
@@ skipping 14 matching lines @@
   rxp = re.compile('vars = {(?P<vars_body>[^}]+)', re.MULTILINE)
   re_results = rxp.search(deps_file_contents)
 
   if not re_results:
     return None
 
   # We should be left with a series of entries in the vars component of
   # the DEPS file with the following format:
   # 'depot_name': 'revision',
   vars_body = re_results.group('vars_body')
-  rxp = re.compile("'(?P<depot_body>[\w_-]+)':[\s]+'(?P<rev_body>[\w@]+)'",
+  rxp = re.compile(r"'(?P<depot_body>[\w_-]+)':[\s]+'(?P<rev_body>[\w@]+)'",
                    re.MULTILINE)
   re_results = rxp.findall(vars_body)
 
   return dict(re_results)
 
 
 def _WaitUntilBuildIsReady(
     fetch_build, bot_name, builder_host, builder_port, build_request_id,
     max_timeout):
   """Waits until build is produced by bisect builder on try server.
@@ skipping 165 matching lines @@
 
   Returns:
     A list of floating point numbers found.
   """
   # Format is: RESULT <graph>: <trace>= <value> <units>
   metric_re = re.escape('RESULT %s: %s=' % (metric[0], metric[1]))
 
   # The log will be parsed looking for format:
   # <*>RESULT <graph_name>: <trace_name>= <value>
   single_result_re = re.compile(
-      metric_re + '\s*(?P<VALUE>[-]?\d*(\.\d*)?)')
+      metric_re + r'\s*(?P<VALUE>[-]?\d*(\.\d*)?)')
 
   # The log will be parsed looking for format:
   # <*>RESULT <graph_name>: <trace_name>= [<value>,value,value,...]
   multi_results_re = re.compile(
-      metric_re + '\s*\[\s*(?P<VALUES>[-]?[\d\., ]+)\s*\]')
+      metric_re + r'\s*\[\s*(?P<VALUES>[-]?[\d\., ]+)\s*\]')
 
   # The log will be parsed looking for format:
   # <*>RESULT <graph_name>: <trace_name>= {<mean>, <std deviation>}
   mean_stddev_re = re.compile(
       metric_re +
-      '\s*\{\s*(?P<MEAN>[-]?\d*(\.\d*)?),\s*(?P<STDDEV>\d+(\.\d*)?)\s*\}')
+      r'\s*\{\s*(?P<MEAN>[-]?\d*(\.\d*)?),\s*(?P<STDDEV>\d+(\.\d*)?)\s*\}')
 
   text_lines = text.split('\n')
   values_list = []
   for current_line in text_lines:
     # Parse the output from the performance test for the metric we're
     # interested in.
     single_result_match = single_result_re.search(current_line)
     multi_results_match = multi_results_re.search(current_line)
     mean_stddev_match = mean_stddev_re.search(current_line)
     if (not single_result_match is None and
@@ skipping 168 matching lines @@
     raise RunGitError('Must be in a git repository to send changes to trybots.')
 
   current_branch = current_branch.strip()
   # Make sure current branch is master.
   if current_branch != parent_branch:
     output, returncode = bisect_utils.RunGit(['checkout', '-f', parent_branch])
     if returncode:
       raise RunGitError('Failed to checkout branch: %s.' % output)
 
   # Delete new branch if exists.
-  output, returncode = bisect_utils.RunGit(['branch', '--list' ])
+  output, returncode = bisect_utils.RunGit(['branch', '--list'])
   if new_branch in output:
     output, returncode = bisect_utils.RunGit(['branch', '-D', new_branch])
     if returncode:
       raise RunGitError('Deleting branch failed, %s', output)
 
   # Check if the tree is dirty: make sure the index is up to date and then
   # run diff-index.
   bisect_utils.RunGit(['update-index', '--refresh', '-q'])
   output, returncode = bisect_utils.RunGit(['diff-index', 'HEAD'])
   if output:
@@ skipping 146 matching lines @@
       execfile(deps_file, {}, deps_data)
       deps_data = deps_data['deps']
 
       rxp = re.compile(".git@(?P<revision>[a-fA-F0-9]+)")
       results = {}
       for depot_name, depot_data in bisect_utils.DEPOT_DEPS_NAME.iteritems():
         if (depot_data.get('platform') and
             depot_data.get('platform') != os.name):
           continue
 
-        if (depot_data.get('recurse') and depot in depot_data.get('from')):
+        if depot_data.get('recurse') and depot in depot_data.get('from'):
           depot_data_src = depot_data.get('src') or depot_data.get('src_old')
           src_dir = deps_data.get(depot_data_src)
           if src_dir:
             self.depot_registry.SetDepotDir(depot_name, os.path.join(
                 self.src_cwd, depot_data_src[4:]))
             re_results = rxp.search(src_dir)
             if re_results:
               results[depot_name] = re_results.group('revision')
             else:
               warning_text = ('Could not parse revision for %s while bisecting '
@@ skipping 522 matching lines @@
     """
     if self.opts.target_platform in ['android']:
       # When its a third_party depot, get the chromium revision.
       if depot != 'chromium':
         revision = bisect_utils.CheckRunGit(
             ['rev-parse', 'HEAD'], cwd=self.src_cwd).strip()
       commit_position = source_control.GetCommitPosition(revision,
                                                          cwd=self.src_cwd)
       if not commit_position:
         return command_to_run
-      cmd_re = re.compile('--browser=(?P<browser_type>\S+)')
+      cmd_re = re.compile(r'--browser=(?P<browser_type>\S+)')
       matches = cmd_re.search(command_to_run)
       if bisect_utils.IsStringInt(commit_position) and matches:
         cmd_browser = matches.group('browser_type')
         if commit_position <= 274857 and cmd_browser == 'android-chrome-shell':
           return command_to_run.replace(cmd_browser,
                                         'android-chromium-testshell')
         elif (commit_position >= 276628 and
               cmd_browser == 'android-chromium-testshell'):
           return command_to_run.replace(cmd_browser,
                                         'android-chrome-shell')
@@ skipping 68 matching lines @@
           current_args.append('--reset-results')
         elif i == self.opts.repeat_test_count - 1 and upload_on_last_run:
           current_args.append('--upload-results')
         if results_label:
           current_args.append('--results-label=%s' % results_label)
       try:
         output, return_code = bisect_utils.RunProcessAndRetrieveOutput(
             current_args, cwd=self.src_cwd)
       except OSError, e:
         if e.errno == errno.ENOENT:
-          err_text  = ('Something went wrong running the performance test. '
-                       'Please review the command line:\n\n')
+          err_text = ('Something went wrong running the performance test. '
+                      'Please review the command line:\n\n')
           if 'src/' in ' '.join(args):
             err_text += ('Check that you haven\'t accidentally specified a '
                          'path with src/ in the command.\n\n')
           err_text += ' '.join(args)
           err_text += '\n'
 
           return (err_text, failure_code)
         raise
 
       output_of_all_runs += output
@@ skipping 95 matching lines @@
             commit_position, d, bisect_utils.DEPOT_DEPS_NAME, -1000)
 
         if dependant_rev:
           revisions_to_sync.append([d, dependant_rev])
 
       num_resolved = len(revisions_to_sync)
       num_needed = len(bisect_utils.DEPOT_DEPS_NAME[depot]['depends'])
 
       self.depot_registry.ChangeToDepotDir(depot)
 
-      if not ((num_resolved - 1) == num_needed):
+      if not (num_resolved - 1) == num_needed:
         return None
 
     return revisions_to_sync
 
   def PerformPreBuildCleanup(self):
     """Performs cleanup between runs."""
     print 'Cleaning up between runs.'
     print
 
     # Leaving these .pyc files around between runs may disrupt some perf tests.
@@ skipping 1311 matching lines @@
       bisect_utils.OutputAnnotationStepStart('Results')
     print 'Error: ', e.message
     logging.warn('A RuntimeError was caught: %s', e.message)
     if opts.output_buildbot_annotations:
       bisect_utils.OutputAnnotationStepClosed()
   return 1
 
 
 if __name__ == '__main__':
   sys.exit(main())