Run auto-formatter (autopep8) on webkitpy.

third_party/WebKit/Tools/Scripts/webkitpy/common/net/buildbot/buildbot.py

 # Copyright (c) 2009, 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 26 matching lines @@
 from webkitpy.common.net.layouttestresults import LayoutTestResults
 from webkitpy.common.net.networktransaction import NetworkTransaction
 from webkitpy.common.system.logutils import get_logger
 from webkitpy.thirdparty.BeautifulSoup import BeautifulSoup
 
 
 _log = get_logger(__file__)
 
 
 class Builder(object):
+
     def __init__(self, name, buildbot):
         self._name = name
         self._buildbot = buildbot
         self._builds_cache = {}
         self._revision_to_build_number = None
 
     def name(self):
         return self._name
 
     def results_url(self):
         return config_urls.chromium_results_url_base_for_builder(self._name)
 
     def accumulated_results_url(self):
         return config_urls.chromium_accumulated_results_url_base_for_builder(self._name)
 
     def latest_layout_test_results_url(self):
-        return self.accumulated_results_url() or self.latest_cached_build().results_url();
+        return self.accumulated_results_url() or self.latest_cached_build().results_url()
 
     @memoized
     def latest_layout_test_results(self):
         return self.fetch_layout_test_results(self.latest_layout_test_results_url())
 
     def _fetch_file_from_results(self, results_url, file_name):
         # It seems this can return None if the url redirects and then returns 404.
         result = urllib2.urlopen("%s/%s" % (results_url, file_name))
         if not result:
             return None
         # urlopen returns a file-like object which sometimes works fine with str()
         # but sometimes is a addinfourl object.  In either case calling read() is correct.
         return result.read()
 
     def fetch_layout_test_results(self, results_url):
         # FIXME: This should cache that the result was a 404 and stop hitting the network.
-        results_file = NetworkTransaction(convert_404_to_None=True).run(lambda: self._fetch_file_from_results(results_url, "failing_results.json"))
+        results_file = NetworkTransaction(convert_404_to_None=True).run(
+            lambda: self._fetch_file_from_results(results_url, "failing_results.json"))
         return LayoutTestResults.results_from_string(results_file)
 
     def url_encoded_name(self):
         return urllib.quote(self._name)
 
     def url(self):
         return "%s/builders/%s" % (self._buildbot.buildbot_url, self.url_encoded_name())
 
     # This provides a single place to mock
     def _fetch_build(self, build_number):
         build_dictionary = self._buildbot._fetch_build_dictionary(self, build_number)
         if not build_dictionary:
             return None
         revision_string = build_dictionary['sourceStamp']['revision']
         return Build(self,
-            build_number=int(build_dictionary['number']),
-            # 'revision' may be None if a trunk build was started by the force-build button on the web page.
-            revision=(int(revision_string) if revision_string else None),
-            # Buildbot uses any nubmer other than 0 to mean fail.  Since we fetch with
-            # filter=1, passing builds may contain no 'results' value.
-            is_green=(not build_dictionary.get('results')),
-        )
+                     build_number=int(build_dictionary['number']),
+                     # 'revision' may be None if a trunk build was started by the force-build button on the web page.
+                     revision=(int(revision_string) if revision_string else None),
+                     # Buildbot uses any nubmer other than 0 to mean fail.  Since we fetch with
+                     # filter=1, passing builds may contain no 'results' value.
+                     is_green=(not build_dictionary.get('results')),
+                     )
 
     def build(self, build_number):
         if not build_number:
             return None
         cached_build = self._builds_cache.get(build_number)
         if cached_build:
             return cached_build
 
         build = self._fetch_build(build_number)
         self._builds_cache[build_number] = build
         return build
 
     def latest_cached_build(self):
         revision_build_pairs = self.revision_build_pairs_with_results()
         revision_build_pairs.sort(key=lambda i: i[1])
         latest_build_number = revision_build_pairs[-1][1]
         return self.build(latest_build_number)
 
     file_name_regexp = re.compile(r"r(?P<revision>\d+) \((?P<build_number>\d+)\)")
+
     def _revision_and_build_for_filename(self, filename):
         # Example: "r47483 (1)/" or "r47483 (1).zip"
         match = self.file_name_regexp.match(filename)
         if not match:
             return None
         return (int(match.group("revision")), int(match.group("build_number")))
 
     def _fetch_revision_to_build_map(self):
         # All _fetch requests go through _buildbot for easier mocking
         # FIXME: This should use NetworkTransaction's 404 handling instead.
@@ skipping 31 matching lines @@
     # This assumes there can be only one build per revision, which is false, but we don't care for now.
     def build_for_revision(self, revision, allow_failed_lookups=False):
         # NOTE: This lookup will fail if that exact revision was never built.
         build_number = self._revision_to_build_map().get(int(revision))
         if not build_number:
             return None
         build = self.build(build_number)
         if not build and allow_failed_lookups:
             # Builds for old revisions with fail to lookup via buildbot's json api.
             build = Build(self,
-                build_number=build_number,
-                revision=revision,
-                is_green=False,
-            )
+                          build_number=build_number,
+                          revision=revision,
+                          is_green=False,
+                          )
         return build
 
 
 class Build(object):
+
     def __init__(self, builder, build_number, revision, is_green):
         self._builder = builder
         self._number = build_number
         self._revision = revision
         self._is_green = is_green
 
     @staticmethod
     def build_url(builder, build_number):
         return "%s/builds/%s" % (builder.url(), build_number)
 
@@ skipping 30 matching lines @@
         self.buildbot_url = url if url else self._default_url
         self._builder_by_name = {}
 
     def _parse_last_build_cell(self, builder, cell):
         status_link = cell.find('a')
         if status_link:
             # Will be either a revision number or a build number
             revision_string = status_link.string
             # If revision_string has non-digits assume it's not a revision number.
             builder['built_revision'] = int(revision_string) \
-                                        if not re.match('\D', revision_string) \
-                                        else None
+                if not re.match('\D', revision_string) \
+                else None
 
             # FIXME: We treat slave lost as green even though it is not to
             # work around the Qts bot being on a broken internet connection.
             # The real fix is https://bugs.webkit.org/show_bug.cgi?id=37099
             builder['is_green'] = not re.search('fail', cell.renderContents()) or \
-                                  not not re.search('lost', cell.renderContents())
+                not not re.search('lost', cell.renderContents())
 
             status_link_regexp = r"builders/(?P<builder_name>.*)/builds/(?P<build_number>\d+)"
             link_match = re.match(status_link_regexp, status_link['href'])
             builder['build_number'] = int(link_match.group("build_number"))
         else:
             # We failed to find a link in the first cell, just give up.  This
             # can happen if a builder is just-added, the first cell will just
             # be "no build"
             # Other parts of the code depend on is_green being present.
             builder['is_green'] = False
             builder['built_revision'] = None
             builder['build_number'] = None
 
     def _parse_current_build_cell(self, builder, cell):
         activity_lines = cell.renderContents().split("<br />")
-        builder["activity"] = activity_lines[0] # normally "building" or "idle"
+        builder["activity"] = activity_lines[0]  # normally "building" or "idle"
         # The middle lines document how long left for any current builds.
         match = re.match("(?P<pending_builds>\d) pending", activity_lines[-1])
         builder["pending_builds"] = int(match.group("pending_builds")) if match else 0
 
     def _parse_builder_status_from_row(self, status_row):
         status_cells = status_row.findAll('td')
         builder = {}
 
         # First cell is the name
         name_link = status_cells[0].find('a')
@@ skipping 13 matching lines @@
     def _fetch_build_dictionary(self, builder, build_number):
         # Note: filter=1 will remove None and {} and '', which cuts noise but can
         # cause keys to be missing which you might otherwise expect.
         # FIXME: The bot sends a *huge* amount of data for each request, we should
         # find a way to reduce the response size further.
         json_url = "%s/json/builders/%s/builds/%s?filter=1" % (self.buildbot_url, urllib.quote(builder.name()), build_number)
         try:
             return json.load(urllib2.urlopen(json_url))
         except urllib2.URLError, err:
             build_url = Build.build_url(builder, build_number)
-            _log.error("Error fetching data for %s build %s (%s, json: %s): %s" % (builder.name(), build_number, build_url, json_url, err))
+            _log.error("Error fetching data for %s build %s (%s, json: %s): %s" %
+                       (builder.name(), build_number, build_url, json_url, err))
             return None
         except ValueError, err:
             build_url = Build.build_url(builder, build_number)
             _log.error("Error decoding json data from %s: %s" % (build_url, err))
             return None
 
     def _fetch_one_box_per_builder(self):
         build_status_url = "%s/one_box_per_builder" % self.buildbot_url
         return urllib2.urlopen(build_status_url)
 
@@ skipping 92 matching lines @@
 
             builders_succeeded_in_past = set()
             for past_revision in revisions_in_order[i:]:
                 if not revision_statuses[past_revision]:
                     break
                 builders_succeeded_in_past = builders_succeeded_in_past.union(revision_statuses[past_revision])
 
             if len(builders_succeeded_in_future) == len(builder_revisions) and len(builders_succeeded_in_past) == len(builder_revisions):
                 return revision
         return None