Fix style in tools/auto_bisect.

tools/auto_bisect/bisect_results.py

 # Copyright 2014 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.
 
 import math
 import os
 
 import bisect_utils
 import math_utils
 import source_control
@@ skipping 40 matching lines @@
     second option creates an error result.
 
     Args:
       bisect_state: BisectState object representing latest bisect state.
       depot_registry: DepotDirectoryRegistry object with information on each
           repository in the bisect_state.
       opts: Options passed to the bisect run.
       runtime_warnings: A list of warnings from the bisect run.
       error: Error message. When error is not None, other arguments are ignored.
     """
-
     self.error = error
     self.abort_reason = abort_reason
     if error is not None or abort_reason is not None:
       return
 
     assert (bisect_state is not None and depot_registry is not None and
             opts is not None and runtime_warnings is not None), (
-            'Incorrect use of the BisectResults constructor. When error is '
-            'None, all other arguments are required')
+                'Incorrect use of the BisectResults constructor. '
+                'When error is None, all other arguments are required.')
 
     self.state = bisect_state
 
     rev_states = bisect_state.GetRevisionStates()
     first_working_rev, last_broken_rev = self.FindBreakingRevRange(rev_states)
     self.first_working_revision = first_working_rev
     self.last_broken_revision = last_broken_rev
 
     self.warnings = runtime_warnings
 
@@ skipping 25 matching lines @@
       self.culprit_revisions = []
       self.other_regressions = []
 
   def AddRetestResults(self, results_tot, results_reverted):
     if not results_tot or not results_reverted:
       self.warnings.append(
           'Failed to re-test reverted culprit CL against ToT.')
       return
 
     confidence_params = (results_reverted[0]['values'],
-        results_tot[0]['values'])
+                         results_tot[0]['values'])
     confidence = BisectResults.ConfidenceScore(*confidence_params)
 
     self.retest_results_tot = RevisionState('ToT', 'n/a', 0)
     self.retest_results_tot.value = results_tot[0]
 
     self.retest_results_reverted = RevisionState('Reverted', 'n/a', 0)
     self.retest_results_reverted.value = results_reverted[0]
 
     if confidence <= bisect_utils.HIGH_CONFIDENCE:
       self.warnings.append(
           'Confidence of re-test with reverted CL is not high.'
           ' Check that the regression hasn\'t already recovered. '
           ' There\'s still a chance this is a regression, as performance of'
-          ' local builds may not match official builds.' )
+          ' local builds may not match official builds.')
 
   @staticmethod
   def _GetResultBasedWarnings(culprit_revisions, opts, confidence):
     warnings = []
     if len(culprit_revisions) > 1:
       warnings.append('Due to build errors, regression range could '
                       'not be narrowed down to a single commit.')
     if opts.repeat_test_count == 1:
       warnings.append('Tests were only set to run once. This may '
                       'be insufficient to get meaningful results.')
@@ skipping 70 matching lines @@
           confidence = cls.ConfidenceScore(*confidence_params,
                                            accept_single_bad_or_good=True)
           mean_of_prev_runs = math_utils.Mean(sum(previous_values, []))
           mean_of_current_runs = math_utils.Mean(current_values)
 
           # Check that the potential regression is in the same direction as
           # the overall regression. If the mean of the previous runs < the
           # mean of the current runs, this local regression is in same
           # direction.
           prev_greater_than_current = mean_of_prev_runs > mean_of_current_runs
-          is_same_direction = (prev_greater_than_current if
-              bad_greater_than_good else not prev_greater_than_current)
+          if bad_greater_than_good:
+            is_same_direction = prev_greater_than_current
+          else:
+            is_same_direction = not prev_greater_than_current
 
           # Only report potential regressions with high confidence.
           if is_same_direction and confidence > 50:
             other_regressions.append([revision_state, prev_state, confidence])
         previous_values.append(current_values)
         prev_state = revision_state
     return other_regressions
 
   @staticmethod
   def FindBreakingRevRange(revision_states):
@@ skipping 76 matching lines @@
         sum([last_broken_rev.value['values']], [])
     )
     confidence = cls.ConfidenceScore(*confidence_params)
 
     bad_greater_than_good = mean_of_bad_runs > mean_of_good_runs
 
     return {'regression_size': regression_size,
             'regression_std_err': regression_std_err,
             'confidence': confidence,
             'bad_greater_than_good': bad_greater_than_good}