Run auto-formatter (autopep8) on webkitpy.

third_party/WebKit/Tools/Scripts/webkitpy/tool/commands/rebaseline.py

 # Copyright (c) 2010 Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 51 matching lines @@
     if not branch_name:
         # If HEAD is detached use commit SHA instead.
         return tool.executive.run_command(['git', 'rev-parse', 'HEAD']).strip()
     return branch_name
 
 
 class AbstractRebaseliningCommand(AbstractDeclarativeCommand):
     # not overriding execute() - pylint: disable=W0223
 
     no_optimize_option = optparse.make_option('--no-optimize', dest='optimize', action='store_false', default=True,
-        help=('Do not optimize/de-dup the expectations after rebaselining (default is to de-dup automatically). '
-              'You can use "webkit-patch optimize-baselines" to optimize separately.'))
+                                              help=('Do not optimize/de-dup the expectations after rebaselining (default is to de-dup automatically). '
+                                                    'You can use "webkit-patch optimize-baselines" to optimize separately.'))
 
     platform_options = factory.platform_options(use_globs=True)
 
     results_directory_option = optparse.make_option("--results-directory", help="Local results directory to use")
 
     suffixes_option = optparse.make_option("--suffixes", default=','.join(BASELINE_SUFFIX_LIST), action="store",
-        help="Comma-separated-list of file types to rebaseline")
+                                           help="Comma-separated-list of file types to rebaseline")
 
     def __init__(self, options=None):
         super(AbstractRebaseliningCommand, self).__init__(options=options)
         self._baseline_suffix_list = BASELINE_SUFFIX_LIST
         self._scm_changes = {'add': [], 'delete': [], 'remove-lines': []}
 
     def _add_to_scm_later(self, path):
         self._scm_changes['add'].append(path)
 
     def _delete_from_scm_later(self, path):
         self._scm_changes['delete'].append(path)
 
 
 class BaseInternalRebaselineCommand(AbstractRebaseliningCommand):
+
     def __init__(self):
         super(BaseInternalRebaselineCommand, self).__init__(options=[
             self.results_directory_option,
             self.suffixes_option,
             optparse.make_option("--builder", help="Builder to pull new baselines from"),
             optparse.make_option("--test", help="Test to rebaseline"),
-            ])
+        ])
 
     def _baseline_directory(self, builder_name):
         port = self._tool.port_factory.get_from_builder_name(builder_name)
         override_dir = builders.rebaseline_override_dir(builder_name)
         if override_dir:
             return self._tool.filesystem.join(port.layout_tests_dir(), 'platform', override_dir)
         return port.baseline_version_dir()
 
     def _test_root(self, test_name):
         return self._tool.filesystem.splitext(test_name)[0]
@@ skipping 28 matching lines @@
         return immediate_predecessors_in_fallback
 
     def _port_for_primary_baseline(self, baseline):
         for port in [self._tool.port_factory.get(port_name) for port_name in self._tool.port_factory.all_port_names()]:
             if self._tool.filesystem.basename(port.baseline_version_dir()) == baseline:
                 return port
         raise Exception("Failed to find port for primary baseline %s." % baseline)
 
     def _copy_existing_baseline(self, builder_name, test_name, suffix):
         baseline_directory = self._baseline_directory(builder_name)
-        ports = [self._port_for_primary_baseline(baseline) for baseline in self._immediate_predecessors_in_fallback(baseline_directory)]
+        ports = [self._port_for_primary_baseline(baseline)
+                 for baseline in self._immediate_predecessors_in_fallback(baseline_directory)]
 
         old_baselines = []
         new_baselines = []
 
         # Need to gather all the baseline paths before modifying the filesystem since
         # the modifications can affect the results of port.expected_filename.
         for port in ports:
             old_baseline = port.expected_filename(test_name, "." + suffix)
             if not self._tool.filesystem.exists(old_baseline):
                 _log.debug("No existing baseline for %s." % test_name)
@@ skipping 46 matching lines @@
         if not self._tool.scm().exists(target_baseline):
             self._add_to_scm_later(target_baseline)
 
     def _rebaseline_test(self, builder_name, test_name, suffix, results_url):
         baseline_directory = self._baseline_directory(builder_name)
 
         source_baseline = "%s/%s" % (results_url, self._file_name_for_actual_result(test_name, suffix))
         target_baseline = self._tool.filesystem.join(baseline_directory, self._file_name_for_expected_result(test_name, suffix))
 
         _log.debug("Retrieving %s." % source_baseline)
-        self._save_baseline(self._tool.web.get_binary(source_baseline, convert_404_to_None=True), target_baseline, baseline_directory, test_name, suffix)
+        self._save_baseline(self._tool.web.get_binary(source_baseline, convert_404_to_None=True),
+                            target_baseline, baseline_directory, test_name, suffix)
 
     def _rebaseline_test_and_update_expectations(self, options):
         port = self._tool.port_factory.get_from_builder_name(options.builder)
         if (port.reference_files(options.test)):
             _log.warning("Cannot rebaseline reftest: %s", options.test)
             return
 
         if options.results_directory:
             results_url = 'file://' + options.results_directory
         else:
@@ skipping 11 matching lines @@
 
 class OptimizeBaselines(AbstractRebaseliningCommand):
     name = "optimize-baselines"
     help_text = "Reshuffles the baselines for the given tests to use as litte space on disk as possible."
     show_in_main_help = True
     argument_names = "TEST_NAMES"
 
     def __init__(self):
         super(OptimizeBaselines, self).__init__(options=[
             self.suffixes_option,
-            optparse.make_option('--no-modify-scm', action='store_true', default=False, help='Dump SCM commands as JSON instead of '),
-            ] + self.platform_options)
+            optparse.make_option('--no-modify-scm', action='store_true', default=False,
+                                 help='Dump SCM commands as JSON instead of '),
+        ] + self.platform_options)
 
     def _optimize_baseline(self, optimizer, test_name):
         files_to_delete = []
         files_to_add = []
         for suffix in self._baseline_suffix_list:
             baseline_name = _baseline_name(self._tool.filesystem, test_name, suffix)
             succeeded, more_files_to_delete, more_files_to_add = optimizer.optimize(baseline_name)
             if not succeeded:
                 print "Heuristics failed to optimize %s" % baseline_name
             files_to_delete.extend(more_files_to_delete)
@@ skipping 22 matching lines @@
 class AnalyzeBaselines(AbstractRebaseliningCommand):
     name = "analyze-baselines"
     help_text = "Analyzes the baselines for the given tests and prints results that are identical."
     show_in_main_help = True
     argument_names = "TEST_NAMES"
 
     def __init__(self):
         super(AnalyzeBaselines, self).__init__(options=[
             self.suffixes_option,
             optparse.make_option('--missing', action='store_true', default=False, help='show missing baselines as well'),
-            ] + self.platform_options)
+        ] + self.platform_options)
         self._optimizer_class = BaselineOptimizer  # overridable for testing
         self._baseline_optimizer = None
         self._port = None
 
     def _write(self, msg):
         print msg
 
     def _analyze_baseline(self, options, test_name):
         for suffix in self._baseline_suffix_list:
             baseline_name = _baseline_name(self._tool.filesystem, test_name, suffix)
@@ skipping 41 matching lines @@
             if builder_name.find('ASAN') != -1:
                 continue
             port = self._tool.port_factory.get_from_builder_name(builder_name)
             if port.test_configuration().build_type == 'release':
                 release_builders.append(builder_name)
         return release_builders
 
     def _run_webkit_patch(self, args, verbose):
         try:
             verbose_args = ['--verbose'] if verbose else []
-            stderr = self._tool.executive.run_command([self._tool.path()] + verbose_args + args, cwd=self._tool.scm().checkout_root, return_stderr=True)
+            stderr = self._tool.executive.run_command([self._tool.path()] + verbose_args +
+                                                      args, cwd=self._tool.scm().checkout_root, return_stderr=True)
             for line in stderr.splitlines():
                 _log.warning(line)
         except ScriptError:
             traceback.print_exc(file=sys.stderr)
 
     def _builders_to_fetch_from(self, builders_to_check):
         # This routine returns the subset of builders that will cover all of the baseline search paths
         # used in the input list. In particular, if the input list contains both Release and Debug
         # versions of a configuration, we *only* return the Release version (since we don't save
         # debug versions of baselines).
@@ skipping 17 matching lines @@
         path_to_webkit_patch = self._tool.path()
         cwd = self._tool.scm().checkout_root
         copy_baseline_commands = []
         rebaseline_commands = []
         lines_to_remove = {}
         port = self._tool.port_factory.get()
 
         for test_prefix in test_prefix_list:
             for test in port.tests([test_prefix]):
                 for builder in self._builders_to_fetch_from(test_prefix_list[test_prefix]):
-                    actual_failures_suffixes = self._suffixes_for_actual_failures(test, builder, test_prefix_list[test_prefix][builder])
+                    actual_failures_suffixes = self._suffixes_for_actual_failures(
+                        test, builder, test_prefix_list[test_prefix][builder])
                     if not actual_failures_suffixes:
                         # If we're not going to rebaseline the test because it's passing on this
                         # builder, we still want to remove the line from TestExpectations.
                         if test not in lines_to_remove:
                             lines_to_remove[test] = []
                         lines_to_remove[test].append(builder)
                         continue
 
                     suffixes = ','.join(actual_failures_suffixes)
                     cmd_line = ['--suffixes', suffixes, '--builder', builder, '--test', test]
                     if options.results_directory:
                         cmd_line.extend(['--results-directory', options.results_directory])
                     if options.verbose:
                         cmd_line.append('--verbose')
-                    copy_baseline_commands.append(tuple([[self._tool.executable, path_to_webkit_patch, 'copy-existing-baselines-internal'] + cmd_line, cwd]))
-                    rebaseline_commands.append(tuple([[self._tool.executable, path_to_webkit_patch, 'rebaseline-test-internal'] + cmd_line, cwd]))
+                    copy_baseline_commands.append(
+                        tuple([[self._tool.executable, path_to_webkit_patch, 'copy-existing-baselines-internal'] + cmd_line, cwd]))
+                    rebaseline_commands.append(
+                        tuple([[self._tool.executable, path_to_webkit_patch, 'rebaseline-test-internal'] + cmd_line, cwd]))
         return copy_baseline_commands, rebaseline_commands, lines_to_remove
 
     def _serial_commands(self, command_results):
         files_to_add = set()
         files_to_delete = set()
         lines_to_remove = {}
         for output in [result[1].split('\n') for result in command_results]:
             file_added = False
             for line in output:
                 try:
@@ skipping 138 matching lines @@
 
 
 class RebaselineJson(AbstractParallelRebaselineCommand):
     name = "rebaseline-json"
     help_text = "Rebaseline based off JSON passed to stdin. Intended to only be called from other scripts."
 
     def __init__(self,):
         super(RebaselineJson, self).__init__(options=[
             self.no_optimize_option,
             self.results_directory_option,
-            ])
+        ])
 
     def execute(self, options, args, tool):
         self._rebaseline(options, json.loads(sys.stdin.read()))
 
 
 class RebaselineExpectations(AbstractParallelRebaselineCommand):
     name = "rebaseline-expectations"
     help_text = "Rebaselines the tests indicated in TestExpectations."
     show_in_main_help = True
 
     def __init__(self):
         super(RebaselineExpectations, self).__init__(options=[
             self.no_optimize_option,
-            ] + self.platform_options)
+        ] + self.platform_options)
         self._test_prefix_list = None
 
     def _tests_to_rebaseline(self, port):
         tests_to_rebaseline = {}
         for path, value in port.expectations_dict().items():
             expectations = TestExpectations(port, include_overrides=False, expectations_dict={path: value})
             for test in expectations.get_rebaselining_failures():
                 suffixes = TestExpectations.suffixes_for_expectations(expectations.get_expectations(test))
                 tests_to_rebaseline[test] = suffixes or BASELINE_SUFFIX_LIST
         return tests_to_rebaseline
@@ skipping 31 matching lines @@
     help_text = "Rebaseline tests with results from the build bots. Shows the list of failing tests on the builders if no test names are provided."
     show_in_main_help = True
     argument_names = "[TEST_NAMES]"
 
     def __init__(self):
         super(Rebaseline, self).__init__(options=[
             self.no_optimize_option,
             # FIXME: should we support the platform options in addition to (or instead of) --builders?
             self.suffixes_option,
             self.results_directory_option,
-            optparse.make_option("--builders", default=None, action="append", help="Comma-separated-list of builders to pull new baselines from (can also be provided multiple times)"),
-            ])
+            optparse.make_option("--builders", default=None, action="append",
+                                 help="Comma-separated-list of builders to pull new baselines from (can also be provided multiple times)"),
+        ])
 
     def _builders_to_pull_from(self):
-        chosen_names = self._tool.user.prompt_with_list("Which builder to pull results from:", self._release_builders(), can_choose_multiple=True)
+        chosen_names = self._tool.user.prompt_with_list(
+            "Which builder to pull results from:", self._release_builders(), can_choose_multiple=True)
         return [self._builder_with_name(name) for name in chosen_names]
 
     def _builder_with_name(self, name):
         return self._tool.buildbot.builder_with_name(name)
 
     def execute(self, options, args, tool):
         if not args:
             _log.error("Must list tests to rebaseline.")
             return
 
@@ skipping 32 matching lines @@
     SECONDS_BEFORE_GIVING_UP = 300
 
     def __init__(self):
         super(AutoRebaseline, self).__init__(options=[
             # FIXME: Remove this option.
             self.no_optimize_option,
             # FIXME: Remove this option.
             self.results_directory_option,
             optparse.make_option("--auth-refresh-token-json", help="Rietveld auth refresh JSON token."),
             optparse.make_option("--dry-run", action='store_true', default=False,
-                help='Run without creating a temporary branch, committing locally, or uploading/landing '
-                'changes to the remote repository.')
-            ])
+                                 help='Run without creating a temporary branch, committing locally, or uploading/landing '
+                                 'changes to the remote repository.')
+        ])
         self._blame_regex = re.compile(r"""
                 ^(\S*)      # Commit hash
                 [^(]* \(    # Whitespace and open parenthesis
                 <           # Email address is surrounded by <>
                 (
                     [^@]+   # Username preceding @
                     @
                     [^@>]+  # Domain terminated by @ or >, some lines have an additional @ fragment after the email.
                 )
                 .*?([^ ]*)  # Test file name
@@ skipping 108 matching lines @@
         return test_prefix_list, lines_to_remove
 
     def _run_git_cl_command(self, options, command):
         subprocess_command = ['git', 'cl'] + command
         if options.verbose:
             subprocess_command.append('--verbose')
         if options.auth_refresh_token_json:
             subprocess_command.append('--auth-refresh-token-json')
             subprocess_command.append(options.auth_refresh_token_json)
 
-        process = self._tool.executive.popen(subprocess_command, stdout=self._tool.executive.PIPE, stderr=self._tool.executive.STDOUT)
+        process = self._tool.executive.popen(subprocess_command, stdout=self._tool.executive.PIPE,
+                                             stderr=self._tool.executive.STDOUT)
         last_output_time = time.time()
 
         # git cl sometimes completely hangs. Bail if we haven't gotten any output to stdout/stderr in a while.
         while process.poll() == None and time.time() < last_output_time + self.SECONDS_BEFORE_GIVING_UP:
             # FIXME: This doesn't make any sense. readline blocks, so all this code to
             # try and bail is useless. Instead, we should do the readline calls on a
             # subthread. Then the rest of this code would make sense.
             out = process.stdout.readline().rstrip('\n')
             if out:
                 last_output_time = time.time()
@@ skipping 21 matching lines @@
 
         if not options.dry_run and tool.scm().has_working_directory_changes():
             _log.error("Cannot proceed with working directory changes. Clean working directory first.")
             return
 
         revision_data = self.bot_revision_data()
         if not revision_data:
             return
 
         min_revision = int(min([item["revision"] for item in revision_data]))
-        tests, revision, commit, author, bugs, has_any_needs_rebaseline_lines = self.tests_to_rebaseline(tool, min_revision, print_revisions=options.verbose)
+        tests, revision, commit, author, bugs, has_any_needs_rebaseline_lines = self.tests_to_rebaseline(
+            tool, min_revision, print_revisions=options.verbose)
 
         if options.verbose:
             _log.info("Min revision across all bots is %s." % min_revision)
             for item in revision_data:
                 _log.info("%s: r%s" % (item["builder"], item["revision"]))
 
         if not tests:
             _log.debug('No tests to rebaseline.')
             return
 
@@ skipping 113 matching lines @@
             out = self._log_line(process.stdout)
 
     def _do_one_rebaseline(self):
         self._log_queue = Queue.Queue(256)
         log_thread = threading.Thread(name='LogToServer', target=self._log_to_server_thread)
         log_thread.start()
         old_branch_name_or_ref = ''
         try:
             old_branch_name_or_ref = _get_branch_name_or_ref(self._tool)
             self._run_logged_command(['git', 'pull'])
-            rebaseline_command = [self._tool.filesystem.join(self._tool.scm().checkout_root, 'third_party', 'WebKit', 'Tools', 'Scripts', 'webkit-patch'), 'auto-rebaseline']
+            rebaseline_command = [self._tool.filesystem.join(
+                self._tool.scm().checkout_root, 'third_party', 'WebKit', 'Tools', 'Scripts', 'webkit-patch'), 'auto-rebaseline']
             if self._verbose:
                 rebaseline_command.append('--verbose')
             self._run_logged_command(rebaseline_command)
         except:
             self._log_queue.put(self.QUIT_LOG)
             traceback.print_exc(file=sys.stderr)
             # Sometimes git crashes and leaves us on a detached head.
             if old_branch_name_or_ref:
                 self._tool.scm().checkout_branch(old_branch_name_or_ref)
         else:
             self._log_queue.put(self.QUIT_LOG)
         log_thread.join()
 
     def execute(self, options, args, tool):
         self._verbose = options.verbose
         while True:
             self._do_one_rebaseline()
             time.sleep(self.SLEEP_TIME_IN_SECONDS)