diff --git a/.ruff.toml b/.ruff.toml
new file mode 100644
index 0000000..3fad54a
--- /dev/null
+++ b/.ruff.toml
@@ -0,0 +1,3 @@
+line-length = 80
+indent-width = 2
+extend-exclude = ["*_pb2.py", "third_party"]
diff --git a/PRESUBMIT.py b/PRESUBMIT.py
index 2d77fc3..8287e3a 100644
--- a/PRESUBMIT.py
+++ b/PRESUBMIT.py
@@ -21,18 +21,52 @@
   sys_path_backup = sys.path
   try:
     sys.path = [
-        input_api.PresubmitLocalPath(),
-        join('tests'),
-        join('third_party'),
+      input_api.PresubmitLocalPath(),
+      join("tests"),
+      join("third_party"),
     ] + sys.path
     files_to_skip = list(input_api.DEFAULT_FILES_TO_SKIP) + [
-        r'.*_pb2\.py$',
+      r".*_pb2\.py$",
+    ]
+    disabled_warnings = [
+      "bad-plugin-value",
+      "consider-using-dict-items",
+      "consider-using-f-string",
+      "consider-using-from-import",
+      "consider-using-generator",
+      "consider-using-in",
+      "consider-using-max-builtin",
+      "consider-using-min-builtin",
+      "consider-using-with",
+      "contextmanager-generator-missing-cleanup",
+      "line-too-long",
+      "missing-parentheses-for-call-in-test",
+      "missing-timeout",
+      "no-value-for-parameter",
+      "possibly-used-before-assignment",
+      "relative-import",
+      "unknown-option-value",
+      "unnecessary-lambda-assignment",
+      "unrecognized-option",
+      "unspecified-encoding",
+      "unsupported-assignment-operation",
+      "unused-variable",
+      "use-dict-literal",
+      "use-yield-from",
+      "used-before-assignment",
+      "useless-object-inheritance",
+      "useless-option-value",
     ]
     output.extend(
-        input_api.canned_checks.RunPylint(input_api,
-                                          output_api,
-                                          files_to_skip=files_to_skip,
-                                          pylintrc=join('../', 'pylintrc')))
+      input_api.canned_checks.RunPylint(
+        input_api,
+        output_api,
+        files_to_skip=files_to_skip,
+        disabled_warnings=disabled_warnings,
+        pylintrc=join("../", "pylintrc"),
+        version="3.2",
+      )
+    )
   finally:
     sys.path = sys_path_backup
 
diff --git a/README.py b/README.py
index 888632b..a346b17 100755
--- a/README.py
+++ b/README.py
@@ -24,14 +24,14 @@
 
 def main():
   for i in sorted(os.listdir(os.path.dirname(os.path.abspath(__file__)))):
-    if not i.endswith('.py') or i == 'PRESUBMIT.py':
+    if not i.endswith(".py") or i == "PRESUBMIT.py":
       continue
     module = __import__(i[:-3])
-    if hasattr(module, '__doc__'):
+    if hasattr(module, "__doc__"):
       print(module.__name__)
-      print(''.join('  %s\n' % i for i in module.__doc__.splitlines()))
+      print("".join("  %s\n" % i for i in module.__doc__.splitlines()))
   return 0
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
   sys.exit(main())
diff --git a/libs/logdog/bootstrap.py b/libs/logdog/bootstrap.py
index e213a58..fb5ff86 100644
--- a/libs/logdog/bootstrap.py
+++ b/libs/logdog/bootstrap.py
@@ -9,13 +9,13 @@
 
 
 class NotBootstrappedError(RuntimeError):
-  """Raised when the current environment is missing Butler bootstrap variables.
-  """
+  """Raised when the current environment is missing Butler bootstrap variables."""
 
 
-_ButlerBootstrapBase = collections.namedtuple('_ButlerBootstrapBase',
-    ('project', 'prefix', 'streamserver_uri', 'coordinator_host',
-     'namespace'))
+_ButlerBootstrapBase = collections.namedtuple(
+  "_ButlerBootstrapBase",
+  ("project", "prefix", "streamserver_uri", "coordinator_host", "namespace"),
+)
 
 
 class ButlerBootstrap(_ButlerBootstrapBase):
@@ -27,11 +27,11 @@
   """
 
   # TODO(iannucci): move all of these to LUCI_CONTEXT
-  _ENV_PROJECT = 'LOGDOG_STREAM_PROJECT'
-  _ENV_PREFIX = 'LOGDOG_STREAM_PREFIX'
-  _ENV_STREAM_SERVER_PATH = 'LOGDOG_STREAM_SERVER_PATH'
-  _ENV_COORDINATOR_HOST = 'LOGDOG_COORDINATOR_HOST'
-  _ENV_NAMESPACE = 'LOGDOG_NAMESPACE'
+  _ENV_PROJECT = "LOGDOG_STREAM_PROJECT"
+  _ENV_PREFIX = "LOGDOG_STREAM_PREFIX"
+  _ENV_STREAM_SERVER_PATH = "LOGDOG_STREAM_SERVER_PATH"
+  _ENV_COORDINATOR_HOST = "LOGDOG_COORDINATOR_HOST"
+  _ENV_NAMESPACE = "LOGDOG_NAMESPACE"
 
   @classmethod
   def probe(cls, env=None):
@@ -53,18 +53,19 @@
         streamname.validate_stream_name(val)
         return val
       except ValueError as exp:
-        raise NotBootstrappedError('%s (%s) is invalid: %s' % (kind, val, exp))
+        raise NotBootstrappedError("%s (%s) is invalid: %s" % (kind, val, exp))
 
     streamserver_uri = env.get(cls._ENV_STREAM_SERVER_PATH)
     if not streamserver_uri:
-      raise NotBootstrappedError('No streamserver in bootstrap environment.')
+      raise NotBootstrappedError("No streamserver in bootstrap environment.")
 
     return cls(
-        project=env.get(cls._ENV_PROJECT, ''),
-        prefix=_check("Prefix", env.get(cls._ENV_PREFIX, '')),
-        streamserver_uri=streamserver_uri,
-        coordinator_host=env.get(cls._ENV_COORDINATOR_HOST, ''),
-        namespace=_check("Namespace", env.get(cls._ENV_NAMESPACE, '')))
+      project=env.get(cls._ENV_PROJECT, ""),
+      prefix=_check("Prefix", env.get(cls._ENV_PREFIX, "")),
+      streamserver_uri=streamserver_uri,
+      coordinator_host=env.get(cls._ENV_COORDINATOR_HOST, ""),
+      namespace=_check("Namespace", env.get(cls._ENV_NAMESPACE, "")),
+    )
 
   def stream_client(self, reg=None):
     """Returns: (StreamClient) stream client for the bootstrap streamserver URI.
@@ -83,8 +84,9 @@
     """
     reg = reg or stream._default_registry
     return reg.create(
-        self.streamserver_uri,
-        project=self.project,
-        prefix=self.prefix,
-        coordinator_host=self.coordinator_host,
-        namespace=self.namespace)
+      self.streamserver_uri,
+      project=self.project,
+      prefix=self.prefix,
+      coordinator_host=self.coordinator_host,
+      namespace=self.namespace,
+    )
diff --git a/libs/logdog/stream.py b/libs/logdog/stream.py
index ecd71c9..acff435 100644
--- a/libs/logdog/stream.py
+++ b/libs/logdog/stream.py
@@ -20,25 +20,26 @@
 
 
 _StreamParamsBase = collections.namedtuple(
-    '_StreamParamsBase', ('name', 'type', 'content_type', 'tags'))
+  "_StreamParamsBase", ("name", "type", "content_type", "tags")
+)
 
 
 # Magic number at the beginning of a Butler stream
 #
 # See "ProtocolFrameHeaderMagic" in:
 # <luci-go>/logdog/client/butlerlib/streamproto
-BUTLER_MAGIC = b'BTLR1\x1e'
+BUTLER_MAGIC = b"BTLR1\x1e"
 
 
 class StreamParams(_StreamParamsBase):
   """Defines the set of parameters to apply to a new stream."""
 
   # A text content stream.
-  TEXT = 'text'
+  TEXT = "text"
   # A binary content stream.
-  BINARY = 'binary'
+  BINARY = "binary"
   # A datagram content stream.
-  DATAGRAM = 'datagram'
+  DATAGRAM = "datagram"
 
   @classmethod
   def make(cls, **kwargs):
@@ -56,11 +57,11 @@
     streamname.validate_stream_name(self.name)
 
     if self.type not in (self.TEXT, self.BINARY, self.DATAGRAM):
-      raise ValueError('Invalid type (%s)' % (self.type,))
+      raise ValueError("Invalid type (%s)" % (self.type,))
 
     if self.tags is not None:
       if not isinstance(self.tags, collections.abc.Mapping):
-        raise ValueError('Invalid tags type (%s)' % (self.tags,))
+        raise ValueError("Invalid tags type (%s)" % (self.tags,))
       for k, v in self.tags.items():
         streamname.validate_tag(k, v)
 
@@ -75,24 +76,23 @@
     self.validate()
 
     obj = {
-        'name': self.name,
-        'type': self.type,
+      "name": self.name,
+      "type": self.type,
     }
 
     def _maybe_add(key, value):
       if value is not None:
         obj[key] = value
 
-    _maybe_add('contentType', self.content_type)
-    _maybe_add('tags', self.tags)
+    _maybe_add("contentType", self.content_type)
+    _maybe_add("tags", self.tags)
 
     # Note that "dumps' will dump UTF-8 by default, which is what Butler wants.
     return json.dumps(obj, sort_keys=True, ensure_ascii=True, indent=None)
 
 
 class StreamProtocolRegistry:
-  """Registry of streamserver URI protocols and their client classes.
-  """
+  """Registry of streamserver URI protocols and their client classes."""
 
   def __init__(self):
     self._registry = {}
@@ -100,7 +100,7 @@
   def register_protocol(self, protocol, client_cls):
     assert issubclass(client_cls, StreamClient)
     if self._registry.get(protocol) is not None:
-      raise KeyError('Duplicate protocol registered.')
+      raise KeyError("Duplicate protocol registered.")
     self._registry[protocol] = client_cls
 
   def create(self, uri, **kwargs):
@@ -118,14 +118,14 @@
       ValueError: if the supplied URI references an invalid or improperly
           configured streamserver.
     """
-    uri = uri.split(':', 1)
+    uri = uri.split(":", 1)
     if len(uri) != 2:
-      raise ValueError('Invalid stream server URI [%s]' % (uri,))
+      raise ValueError("Invalid stream server URI [%s]" % (uri,))
     protocol, value = uri
 
     client_cls = self._registry.get(protocol)
     if not client_cls:
-      raise ValueError('Unknown stream client protocol (%s)' % (protocol,))
+      raise ValueError("Unknown stream client protocol (%s)" % (protocol,))
     return client_cls._create(value, **kwargs)
 
 
@@ -135,8 +135,7 @@
 
 
 class StreamClient:
-  """Abstract base class for a streamserver client.
-  """
+  """Abstract base class for a streamserver client."""
 
   class _StreamBase:
     """ABC for StreamClient streams."""
@@ -170,7 +169,6 @@
       """
       return self._stream_client.get_viewer_url(self._params.name)
 
-
   class _BasicStream(_StreamBase):
     """Wraps a basic file descriptor, offering "write" and "close"."""
 
@@ -191,7 +189,6 @@
     def close(self):
       return self._fd.close()
 
-
   class _TextStream(_BasicStream):
     """Extends _BasicStream, ensuring data written is UTF-8 text."""
 
@@ -201,12 +198,14 @@
 
     def write(self, data):
       if isinstance(data, str):
-        return self._fd.write(data.encode('utf-8'))
-      raise ValueError('expect str, got %r that is type %s' % (
+        return self._fd.write(data.encode("utf-8"))
+      raise ValueError(
+        "expect str, got %r that is type %s"
+        % (
           data,
           type(data),
-      ))
-
+        )
+      )
 
   class _DatagramStream(_StreamBase):
     """Wraps a stream object to write length-prefixed datagrams."""
@@ -222,9 +221,9 @@
     def close(self):
       return self._fd.close()
 
-
-  def __init__(self, project=None, prefix=None, coordinator_host=None,
-               namespace=''):
+  def __init__(
+    self, project=None, prefix=None, coordinator_host=None, namespace=""
+  ):
     """Constructs a new base StreamClient instance.
 
     Args:
@@ -255,8 +254,7 @@
 
   @property
   def coordinator_host(self):
-    """Returns (str or None): The coordinator host, or None if not configured.
-    """
+    """Returns (str or None): The coordinator host, or None if not configured."""
     return self._coordinator_host
 
   @property
@@ -278,7 +276,7 @@
           not defined in the client.
     """
     if not self._prefix:
-      raise KeyError('Stream prefix is not configured')
+      raise KeyError("Stream prefix is not configured")
     return streamname.StreamPath.make(self._prefix, name)
 
   def get_viewer_url(self, name):
@@ -293,14 +291,13 @@
           path.
     """
     if not self._coordinator_host:
-      raise KeyError('Coordinator host is not configured')
+      raise KeyError("Coordinator host is not configured")
     if not self._project:
-      raise KeyError('Stream project is not configured')
+      raise KeyError("Stream project is not configured")
 
     return streamname.get_logdog_viewer_url(
-        self._coordinator_host,
-        self._project,
-        self.get_stream_path(name))
+      self._coordinator_host, self._project, self.get_stream_path(name)
+    )
 
   def _register_new_stream(self, name):
     """Registers a new stream name.
@@ -364,7 +361,7 @@
       are not valid.
     """
     self._register_new_stream(params.name)
-    params_bytes = params.to_json().encode('utf-8')
+    params_bytes = params.to_json().encode("utf-8")
 
     fobj = self._connect_raw()
     fobj.write(BUTLER_MAGIC)
@@ -411,10 +408,11 @@
         be closed when finished using its `close` method.
     """
     params = StreamParams.make(
-        name=posixpath.join(self._namespace, name),
-        type=StreamParams.TEXT,
-        content_type=content_type,
-        tags=tags)
+      name=posixpath.join(self._namespace, name),
+      type=StreamParams.TEXT,
+      content_type=content_type,
+      tags=tags,
+    )
     return self._TextStream(self, params, self.new_connection(params))
 
   @contextlib.contextmanager
@@ -456,10 +454,11 @@
         be closed when finished using its `close` method.
     """
     params = StreamParams.make(
-        name=posixpath.join(self._namespace, name),
-        type=StreamParams.BINARY,
-        content_type=content_type,
-        tags=tags)
+      name=posixpath.join(self._namespace, name),
+      type=StreamParams.BINARY,
+      content_type=content_type,
+      tags=tags,
+    )
     return self._BasicStream(self, params, self.new_connection(params))
 
   @contextlib.contextmanager
@@ -499,16 +498,16 @@
         finished by using its `close` method.
     """
     params = StreamParams.make(
-        name=posixpath.join(self._namespace, name),
-        type=StreamParams.DATAGRAM,
-        content_type=content_type,
-        tags=tags)
+      name=posixpath.join(self._namespace, name),
+      type=StreamParams.DATAGRAM,
+      content_type=content_type,
+      tags=tags,
+    )
     return self._DatagramStream(self, params, self.new_connection(params))
 
 
 class _NamedPipeStreamClient(StreamClient):
-  """A StreamClient implementation that connects to a Windows named pipe.
-  """
+  """A StreamClient implementation that connects to a Windows named pipe."""
 
   def __init__(self, name, **kwargs):
     r"""Initializes a new Windows named pipe stream client.
@@ -517,7 +516,7 @@
       name (str): The name of the Windows named pipe to use (e.g., "\\.\name")
     """
     super(_NamedPipeStreamClient, self).__init__(**kwargs)
-    self._name = '\\\\.\\pipe\\' + name
+    self._name = "\\\\.\\pipe\\" + name
 
   @classmethod
   def _create(cls, value, **kwargs):
@@ -530,19 +529,18 @@
     #   https://github.com/microsoft/go-winio/blob/master/pipe.go (tryDialPipe)
     while True:
       try:
-        return open(self._name, 'wb+', buffering=0)
+        return open(self._name, "wb+", buffering=0)
       except (OSError, IOError):
         if GetLastError() != self.ERROR_PIPE_BUSY:
           raise
       time.sleep(0.001)  # 1ms
 
 
-_default_registry.register_protocol('net.pipe', _NamedPipeStreamClient)
+_default_registry.register_protocol("net.pipe", _NamedPipeStreamClient)
 
 
 class _UnixDomainSocketStreamClient(StreamClient):
-  """A StreamClient implementation that uses a UNIX domain socket.
-  """
+  """A StreamClient implementation that uses a UNIX domain socket."""
 
   class SocketFile:
     """A write-only file-like object that writes to a UNIX socket."""
@@ -574,7 +572,7 @@
   @classmethod
   def _create(cls, value, **kwargs):
     if not os.path.exists(value):
-      raise ValueError('UNIX domain socket [%s] does not exist.' % (value,))
+      raise ValueError("UNIX domain socket [%s] does not exist." % (value,))
     return cls(value, **kwargs)
 
   def _connect_raw(self):
@@ -582,4 +580,5 @@
     sock.connect(self._path)
     return self.SocketFile(sock)
 
-_default_registry.register_protocol('unix', _UnixDomainSocketStreamClient)
+
+_default_registry.register_protocol("unix", _UnixDomainSocketStreamClient)
diff --git a/libs/logdog/streamname.py b/libs/logdog/streamname.py
index 3bb26fd..7c856b4 100644
--- a/libs/logdog/streamname.py
+++ b/libs/logdog/streamname.py
@@ -7,13 +7,14 @@
 import string
 import urllib
 
-_STREAM_SEP = '/'
+_STREAM_SEP = "/"
 _ALNUM_CHARS = string.ascii_letters + string.digits
-_VALID_SEG_CHARS = _ALNUM_CHARS + ':_-.'
-_SEGMENT_RE_BASE = r'[a-zA-Z0-9][a-zA-Z0-9:_\-.]*'
-_SEGMENT_RE = re.compile('^' + _SEGMENT_RE_BASE + '$')
-_STREAM_NAME_RE = re.compile('^(' + _SEGMENT_RE_BASE + ')(/' +
-                             _SEGMENT_RE_BASE + ')*$')
+_VALID_SEG_CHARS = _ALNUM_CHARS + ":_-."
+_SEGMENT_RE_BASE = r"[a-zA-Z0-9][a-zA-Z0-9:_\-.]*"
+_SEGMENT_RE = re.compile("^" + _SEGMENT_RE_BASE + "$")
+_STREAM_NAME_RE = re.compile(
+  "^(" + _SEGMENT_RE_BASE + ")(/" + _SEGMENT_RE_BASE + ")*$"
+)
 _MAX_STREAM_NAME_LENGTH = 4096
 
 _MAX_TAG_KEY_LENGTH = 64
@@ -32,9 +33,9 @@
   """
   maxlen = maxlen or _MAX_STREAM_NAME_LENGTH
   if len(v) > maxlen:
-    raise ValueError('Maximum length exceeded (%d > %d)' % (len(v), maxlen))
+    raise ValueError("Maximum length exceeded (%d > %d)" % (len(v), maxlen))
   if _STREAM_NAME_RE.match(v) is None:
-    raise ValueError('Invalid stream name: %r' % v)
+    raise ValueError("Invalid stream name: %r" % v)
 
 
 def validate_tag(key, value):
@@ -68,23 +69,24 @@
   """
   if not seg:
     if prefix is None:
-      raise ValueError('Cannot normalize empty segment with no prefix.')
+      raise ValueError("Cannot normalize empty segment with no prefix.")
     seg = prefix
   else:
 
     def replace_if_invalid(ch, first=False):
-      ret = ch if ch in _VALID_SEG_CHARS else '_'
+      ret = ch if ch in _VALID_SEG_CHARS else "_"
       if first and ch not in _ALNUM_CHARS:
         if prefix is None:
-          raise ValueError('Segment has invalid beginning, and no prefix was '
-                           'provided.')
+          raise ValueError(
+            "Segment has invalid beginning, and no prefix was provided."
+          )
         return prefix + ret
       return ret
 
-    seg = ''.join(replace_if_invalid(ch, i == 0) for i, ch in enumerate(seg))
+    seg = "".join(replace_if_invalid(ch, i == 0) for i, ch in enumerate(seg))
 
   if _SEGMENT_RE.match(seg) is None:
-    raise AssertionError('Normalized segment is still invalid: %r' % seg)
+    raise AssertionError("Normalized segment is still invalid: %r" % seg)
 
   return seg
 
@@ -105,13 +107,14 @@
     ValueError: If normalization could not be successfully performed.
   """
   normalized = _STREAM_SEP.join(
-      normalize_segment(seg, prefix=prefix) for seg in v.split(_STREAM_SEP))
+    normalize_segment(seg, prefix=prefix) for seg in v.split(_STREAM_SEP)
+  )
   # Validate the resulting string.
   validate_stream_name(normalized)
   return normalized
 
 
-class StreamPath(collections.namedtuple('_StreamPath', ('prefix', 'name'))):
+class StreamPath(collections.namedtuple("_StreamPath", ("prefix", "name"))):
   """StreamPath is a full stream path.
 
   This consists of both a stream prefix and a stream name.
@@ -146,9 +149,9 @@
     Raises:
       ValueError: If path is not a full, valid stream path string.
     """
-    parts = path.split('/+/', 1)
+    parts = path.split("/+/", 1)
     if len(parts) != 2:
-      raise ValueError('Not a full stream path: [%s]' % (path,))
+      raise ValueError("Not a full stream path: [%s]" % (path,))
     return cls.make(*parts)
 
   def validate(self):
@@ -156,15 +159,27 @@
     try:
       validate_stream_name(self.prefix)
     except ValueError as e:
-      raise ValueError('Invalid prefix component [%s]: %s' % (self.prefix, e,))
+      raise ValueError(
+        "Invalid prefix component [%s]: %s"
+        % (
+          self.prefix,
+          e,
+        )
+      )
 
     try:
       validate_stream_name(self.name)
     except ValueError as e:
-      raise ValueError('Invalid name component [%s]: %s' % (self.name, e,))
+      raise ValueError(
+        "Invalid name component [%s]: %s"
+        % (
+          self.name,
+          e,
+        )
+      )
 
   def __str__(self):
-    return '%s/+/%s' % (self.prefix, self.name)
+    return "%s/+/%s" % (self.prefix, self.name)
 
 
 def get_logdog_viewer_url(host, project, *stream_paths):
@@ -176,12 +191,18 @@
     stream_paths: A set of StreamPath instances for the stream paths to
         generate the URL for.
   """
-  return urllib.parse.urlunparse((
-      'https',  # Scheme
+  return urllib.parse.urlunparse(
+    (
+      "https",  # Scheme
       host,  # netloc
-      'v/',  # path
-      '',  # params
-      '&'.join(('s=%s' % (urllib.parse.quote('%s/%s' % (project, path), ''))
-                for path in stream_paths)),  # query
-      '',  # fragment
-  ))
+      "v/",  # path
+      "",  # params
+      "&".join(
+        (
+          "s=%s" % (urllib.parse.quote("%s/%s" % (project, path), ""))
+          for path in stream_paths
+        )
+      ),  # query
+      "",  # fragment
+    )
+  )
diff --git a/libs/logdog/tests/bootstrap_test.py b/libs/logdog/tests/bootstrap_test.py
index 5879de5..ed5e324 100755
--- a/libs/logdog/tests/bootstrap_test.py
+++ b/libs/logdog/tests/bootstrap_test.py
@@ -7,13 +7,21 @@
 import sys
 import unittest
 
-ROOT_DIR = os.path.dirname(os.path.abspath(os.path.join(
-    __file__.decode(sys.getfilesystemencoding()),
-    os.pardir, os.pardir, os.pardir)))
+ROOT_DIR = os.path.dirname(
+  os.path.abspath(
+    os.path.join(
+      __file__.decode(sys.getfilesystemencoding()),
+      os.pardir,
+      os.pardir,
+      os.pardir,
+    )
+  )
+)
 sys.path.insert(0, ROOT_DIR)
 
 # pylint: disable=no-name-in-module
 from utils import tools
+
 tools.force_local_third_party(ROOT_DIR)
 
 from libs.logdog import bootstrap, stream
@@ -21,15 +29,15 @@
 
 # pylint: disable=protected-access
 
-class BootstrapTestCase(unittest.TestCase):
 
+class BootstrapTestCase(unittest.TestCase):
   def setUp(self):
     self.env = {
-        bootstrap.ButlerBootstrap._ENV_PROJECT: 'test-project',
-        bootstrap.ButlerBootstrap._ENV_PREFIX: 'foo/bar',
-        bootstrap.ButlerBootstrap._ENV_STREAM_SERVER_PATH: 'fake:path',
-        bootstrap.ButlerBootstrap._ENV_COORDINATOR_HOST: 'example.appspot.com',
-        bootstrap.ButlerBootstrap._ENV_NAMESPACE: 'something',
+      bootstrap.ButlerBootstrap._ENV_PROJECT: "test-project",
+      bootstrap.ButlerBootstrap._ENV_PREFIX: "foo/bar",
+      bootstrap.ButlerBootstrap._ENV_STREAM_SERVER_PATH: "fake:path",
+      bootstrap.ButlerBootstrap._ENV_COORDINATOR_HOST: "example.appspot.com",
+      bootstrap.ButlerBootstrap._ENV_NAMESPACE: "something",
     }
 
   @classmethod
@@ -43,60 +51,76 @@
         class fakeFile:
           def write(self, data):
             pass
+
         return fakeFile()
+
     cls.reg = stream.StreamProtocolRegistry()
-    cls.reg.register_protocol('test', TestStreamClient)
+    cls.reg.register_protocol("test", TestStreamClient)
 
   def testProbeSucceeds(self):
     bs = bootstrap.ButlerBootstrap.probe(self.env)
-    self.assertEqual(bs, bootstrap.ButlerBootstrap(
-      project='test-project',
-      prefix='foo/bar',
-      streamserver_uri='fake:path',
-      coordinator_host='example.appspot.com',
-      namespace='something'))
+    self.assertEqual(
+      bs,
+      bootstrap.ButlerBootstrap(
+        project="test-project",
+        prefix="foo/bar",
+        streamserver_uri="fake:path",
+        coordinator_host="example.appspot.com",
+        namespace="something",
+      ),
+    )
 
   def testProbeNoBootstrapRaisesError(self):
-    self.assertRaises(bootstrap.NotBootstrappedError,
-        bootstrap.ButlerBootstrap.probe, env={})
+    self.assertRaises(
+      bootstrap.NotBootstrappedError, bootstrap.ButlerBootstrap.probe, env={}
+    )
 
   def testNoNamespaceOK(self):
     del self.env[bootstrap.ButlerBootstrap._ENV_NAMESPACE]
     bootstrap.ButlerBootstrap.probe(self.env)
 
   def testProbeBadNamespaceRaisesError(self):
-    self.env[bootstrap.ButlerBootstrap._ENV_NAMESPACE] = '!!! invalid'
-    self.assertRaises(bootstrap.NotBootstrappedError,
-        bootstrap.ButlerBootstrap.probe, env=self.env)
+    self.env[bootstrap.ButlerBootstrap._ENV_NAMESPACE] = "!!! invalid"
+    self.assertRaises(
+      bootstrap.NotBootstrappedError,
+      bootstrap.ButlerBootstrap.probe,
+      env=self.env,
+    )
 
   def testProbeInvalidPrefixRaisesError(self):
-    self.env[bootstrap.ButlerBootstrap._ENV_PREFIX] = '!!! not valid !!!'
-    self.assertRaises(bootstrap.NotBootstrappedError,
-        bootstrap.ButlerBootstrap.probe, env=self.env)
+    self.env[bootstrap.ButlerBootstrap._ENV_PREFIX] = "!!! not valid !!!"
+    self.assertRaises(
+      bootstrap.NotBootstrappedError,
+      bootstrap.ButlerBootstrap.probe,
+      env=self.env,
+    )
 
   def testCreateStreamClient(self):
     bs = bootstrap.ButlerBootstrap(
-      project='test-project',
-      prefix='foo/bar',
-      streamserver_uri='test:',
-      coordinator_host='example.appspot.com',
-      namespace='something/deep')
+      project="test-project",
+      prefix="foo/bar",
+      streamserver_uri="test:",
+      coordinator_host="example.appspot.com",
+      namespace="something/deep",
+    )
     sc = bs.stream_client(reg=self.reg)
-    self.assertEqual(sc.prefix, 'foo/bar')
-    self.assertEqual(sc.coordinator_host, 'example.appspot.com')
-    self.assertEqual(sc.open_text('foobar').params.name,
-                     'something/deep/foobar')
+    self.assertEqual(sc.prefix, "foo/bar")
+    self.assertEqual(sc.coordinator_host, "example.appspot.com")
+    self.assertEqual(
+      sc.open_text("foobar").params.name, "something/deep/foobar"
+    )
 
   def testCreateStreamClientNoNamespace(self):
     bs = bootstrap.ButlerBootstrap(
-      project='test-project',
-      prefix='foo/bar',
-      streamserver_uri='test:',
-      coordinator_host='example.appspot.com',
-      namespace='')
+      project="test-project",
+      prefix="foo/bar",
+      streamserver_uri="test:",
+      coordinator_host="example.appspot.com",
+      namespace="",
+    )
     sc = bs.stream_client(reg=self.reg)
-    self.assertEqual(sc.open_text('foobar').params.name, 'foobar')
+    self.assertEqual(sc.open_text("foobar").params.name, "foobar")
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
   unittest.main()
diff --git a/libs/logdog/tests/stream_test.py b/libs/logdog/tests/stream_test.py
index f5abcae..397f76e 100755
--- a/libs/logdog/tests/stream_test.py
+++ b/libs/logdog/tests/stream_test.py
@@ -12,37 +12,43 @@
 import unittest
 
 ROOT_DIR = os.path.dirname(
-    os.path.abspath(os.path.join(__file__, os.pardir, os.pardir, os.pardir)))
+  os.path.abspath(os.path.join(__file__, os.pardir, os.pardir, os.pardir))
+)
 sys.path.insert(0, ROOT_DIR)
 
 # pylint: disable=no-name-in-module
 from utils import tools
+
 tools.force_local_third_party(ROOT_DIR)
 
 from libs.logdog import stream, streamname, varint
 
 
 class StreamParamsTestCase(unittest.TestCase):
-
   def setUp(self):
     self.params = stream.StreamParams(
-        'name',
-        type=stream.StreamParams.TEXT,
-        content_type='content-type',
-        tags={
-            'foo': 'bar',
-            'baz': 'qux',
-        })
+      "name",
+      type=stream.StreamParams.TEXT,
+      content_type="content-type",
+      tags={
+        "foo": "bar",
+        "baz": "qux",
+      },
+    )
 
   def testParamsToJson(self):
-    self.assertEqual(self.params.to_json(),
-                     ('{"contentType": "content-type", "name": "name", '
-                      '"tags": {"baz": "qux", "foo": "bar"}, "type": "text"}'))
+    self.assertEqual(
+      self.params.to_json(),
+      (
+        '{"contentType": "content-type", "name": "name", '
+        '"tags": {"baz": "qux", "foo": "bar"}, "type": "text"}'
+      ),
+    )
 
   def testParamsToJsonWithEmpties(self):
     params = self.params._replace(
-        content_type=None,
-        tags=None,
+      content_type=None,
+      tags=None,
     )
     self.assertEqual(params.to_json(), '{"name": "name", "type": "text"}')
 
@@ -51,24 +57,22 @@
     self.assertRaises(ValueError, params.to_json)
 
   def testParamsWithInvalidTagRaisesValueError(self):
-    params = self.params._replace(tags='foo')
+    params = self.params._replace(tags="foo")
     self.assertRaises(ValueError, params.to_json)
 
-    params = self.params._replace(tags={'!!! invalid tag key !!!': 'bar'})
+    params = self.params._replace(tags={"!!! invalid tag key !!!": "bar"})
     self.assertRaises(ValueError, params.to_json)
 
 
 class StreamClientTestCase(unittest.TestCase):
-
   class _TestStreamClientConnection:
-
     def __init__(self):
       self.buffer = BytesIO()
       self.closed = False
 
     def _assert_not_closed(self):
       if self.closed:
-        raise Exception('Connection is closed.')
+        raise Exception("Connection is closed.")
 
     def write(self, v):
       self._assert_not_closed()
@@ -82,8 +86,9 @@
       data = BytesIO(self.buffer.getvalue())
       magic = data.read(len(stream.BUTLER_MAGIC))
       if magic != stream.BUTLER_MAGIC:
-        raise ValueError('Invalid magic value ([%s] != [%s])' % (
-            magic, stream.BUTLER_MAGIC))
+        raise ValueError(
+          "Invalid magic value ([%s] != [%s])" % (magic, stream.BUTLER_MAGIC)
+        )
       length, _ = varint.read_uvarint(data)
       header = data.read(length)
       return json.loads(header), data.read()
@@ -105,7 +110,7 @@
 
   def setUp(self):
     self._registry = stream.StreamProtocolRegistry()
-    self._registry.register_protocol('test', self._TestStreamClient)
+    self._registry.register_protocol("test", self._TestStreamClient)
 
   @staticmethod
   def _split_datagrams(value):
@@ -114,153 +119,172 @@
       size_prefix, _ = varint.read_uvarint(br)
       data = br.read(size_prefix)
       if len(data) != size_prefix:
-        raise ValueError('Expected %d bytes, but only got %d' % (
-            size_prefix, len(data)))
+        raise ValueError(
+          "Expected %d bytes, but only got %d" % (size_prefix, len(data))
+        )
       yield data
 
   def testClientInstantiation(self):
-    client = self._registry.create('test:value')
+    client = self._registry.create("test:value")
     self.assertIsInstance(client, self._TestStreamClient)
-    self.assertEqual(client.value, 'value')
+    self.assertEqual(client.value, "value")
 
   def testTextStream(self):
-    client = self._registry.create('test:value',
-                                   project='test',
-                                   prefix='foo/bar',
-                                   coordinator_host='example.appspot.com')
-    with client.text('mystream') as fd:
+    client = self._registry.create(
+      "test:value",
+      project="test",
+      prefix="foo/bar",
+      coordinator_host="example.appspot.com",
+    )
+    with client.text("mystream") as fd:
       self.assertEqual(
-          fd.path,
-          streamname.StreamPath(prefix='foo/bar', name='mystream'))
+        fd.path, streamname.StreamPath(prefix="foo/bar", name="mystream")
+      )
       self.assertEqual(
-          fd.get_viewer_url(),
-          'https://example.appspot.com/v/?s=test%2Ffoo%2Fbar%2F%2B%2Fmystream')
-      fd.write('text\nstream\nlines\n')
-      fd.write('😄\n😄\n😄')
+        fd.get_viewer_url(),
+        "https://example.appspot.com/v/?s=test%2Ffoo%2Fbar%2F%2B%2Fmystream",
+      )
+      fd.write("text\nstream\nlines\n")
+      fd.write("😄\n😄\n😄")
 
     conn = client.last_conn
     self.assertTrue(conn.closed)
 
     header, data = conn.interpret()
-    self.assertEqual(header, {'name': 'mystream', 'type': 'text'})
-    self.assertEqual(data.decode('utf-8'), 'text\nstream\nlines\n😄\n😄\n😄')
+    self.assertEqual(header, {"name": "mystream", "type": "text"})
+    self.assertEqual(data.decode("utf-8"), "text\nstream\nlines\n😄\n😄\n😄")
 
   def testTextStreamWithParams(self):
-    client = self._registry.create('test:value')
-    with client.text('mystream', content_type='foo/bar',
-                     tags={'foo': 'bar', 'baz': 'qux'}) as fd:
+    client = self._registry.create("test:value")
+    with client.text(
+      "mystream", content_type="foo/bar", tags={"foo": "bar", "baz": "qux"}
+    ) as fd:
       self.assertEqual(
-          fd.params,
-          stream.StreamParams.make(
-              name='mystream',
-              type=stream.StreamParams.TEXT,
-              content_type='foo/bar',
-              tags={'foo': 'bar', 'baz': 'qux'}))
-      fd.write('text!')
+        fd.params,
+        stream.StreamParams.make(
+          name="mystream",
+          type=stream.StreamParams.TEXT,
+          content_type="foo/bar",
+          tags={"foo": "bar", "baz": "qux"},
+        ),
+      )
+      fd.write("text!")
 
     conn = client.last_conn
     self.assertTrue(conn.closed)
 
     header, data = conn.interpret()
-    self.assertEqual(header, {
-        'name': 'mystream',
-        'type': 'text',
-        'contentType': 'foo/bar',
-         'tags': {'foo': 'bar', 'baz': 'qux'},
-    })
-    self.assertEqual(data.decode('utf-8'), 'text!')
+    self.assertEqual(
+      header,
+      {
+        "name": "mystream",
+        "type": "text",
+        "contentType": "foo/bar",
+        "tags": {"foo": "bar", "baz": "qux"},
+      },
+    )
+    self.assertEqual(data.decode("utf-8"), "text!")
 
   def testBinaryStream(self):
-    client = self._registry.create('test:value',
-                                   project='test',
-                                   prefix='foo/bar',
-                                   coordinator_host='example.appspot.com')
-    with client.binary('mystream') as fd:
+    client = self._registry.create(
+      "test:value",
+      project="test",
+      prefix="foo/bar",
+      coordinator_host="example.appspot.com",
+    )
+    with client.binary("mystream") as fd:
       self.assertEqual(
-          fd.path,
-          streamname.StreamPath(prefix='foo/bar', name='mystream'))
+        fd.path, streamname.StreamPath(prefix="foo/bar", name="mystream")
+      )
       self.assertEqual(
-          fd.get_viewer_url(),
-          'https://example.appspot.com/v/?s=test%2Ffoo%2Fbar%2F%2B%2Fmystream')
-      fd.write(b'\x60\x0d\xd0\x65')
+        fd.get_viewer_url(),
+        "https://example.appspot.com/v/?s=test%2Ffoo%2Fbar%2F%2B%2Fmystream",
+      )
+      fd.write(b"\x60\x0d\xd0\x65")
 
     conn = client.last_conn
     self.assertTrue(conn.closed)
 
     header, data = conn.interpret()
-    self.assertEqual(header, {'name': 'mystream', 'type': 'binary'})
-    self.assertEqual(data, b'\x60\x0d\xd0\x65')
+    self.assertEqual(header, {"name": "mystream", "type": "binary"})
+    self.assertEqual(data, b"\x60\x0d\xd0\x65")
 
   def testDatagramStream(self):
-    client = self._registry.create('test:value',
-                                   project='test',
-                                   prefix='foo/bar',
-                                   coordinator_host='example.appspot.com')
-    with client.datagram('mystream') as fd:
+    client = self._registry.create(
+      "test:value",
+      project="test",
+      prefix="foo/bar",
+      coordinator_host="example.appspot.com",
+    )
+    with client.datagram("mystream") as fd:
       self.assertEqual(
-          fd.path,
-          streamname.StreamPath(prefix='foo/bar', name='mystream'))
+        fd.path, streamname.StreamPath(prefix="foo/bar", name="mystream")
+      )
       self.assertEqual(
-          fd.get_viewer_url(),
-          'https://example.appspot.com/v/?s=test%2Ffoo%2Fbar%2F%2B%2Fmystream')
-      fd.send(b'datagram0')
-      fd.send(b'dg1')
-      fd.send(b'')
-      fd.send(b'dg3')
+        fd.get_viewer_url(),
+        "https://example.appspot.com/v/?s=test%2Ffoo%2Fbar%2F%2B%2Fmystream",
+      )
+      fd.send(b"datagram0")
+      fd.send(b"dg1")
+      fd.send(b"")
+      fd.send(b"dg3")
 
     conn = client.last_conn
     self.assertTrue(conn.closed)
 
     header, data = conn.interpret()
-    self.assertEqual(header, {'name': 'mystream', 'type': 'datagram'})
-    self.assertEqual(list(self._split_datagrams(data)),
-        [b'datagram0', b'dg1', b'', b'dg3'])
+    self.assertEqual(header, {"name": "mystream", "type": "datagram"})
+    self.assertEqual(
+      list(self._split_datagrams(data)), [b"datagram0", b"dg1", b"", b"dg3"]
+    )
 
   def testStreamWithoutPrefixCannotGenerateUrls(self):
-    client = self._registry.create('test:value',
-                                   coordinator_host='example.appspot.com')
-    with client.text('mystream') as fd:
+    client = self._registry.create(
+      "test:value", coordinator_host="example.appspot.com"
+    )
+    with client.text("mystream") as fd:
       self.assertRaises(KeyError, fd.get_viewer_url)
 
   def testStreamWithoutInvalidPrefixCannotGenerateUrls(self):
-    client = self._registry.create('test:value',
-                                   project='test',
-                                   prefix='!!! invalid !!!',
-                                   coordinator_host='example.appspot.com')
-    with client.text('mystream') as fd:
+    client = self._registry.create(
+      "test:value",
+      project="test",
+      prefix="!!! invalid !!!",
+      coordinator_host="example.appspot.com",
+    )
+    with client.text("mystream") as fd:
       self.assertRaises(ValueError, fd.get_viewer_url)
 
   def testStreamWithoutProjectCannotGenerateUrls(self):
-    client = self._registry.create('test:value',
-                                   prefix='foo/bar',
-                                   coordinator_host='example.appspot.com')
-    with client.text('mystream') as fd:
+    client = self._registry.create(
+      "test:value", prefix="foo/bar", coordinator_host="example.appspot.com"
+    )
+    with client.text("mystream") as fd:
       self.assertRaises(KeyError, fd.get_viewer_url)
 
   def testStreamWithoutCoordinatorHostCannotGenerateUrls(self):
-    client = self._registry.create('test:value',
-                                   project='test',
-                                   prefix='foo/bar')
-    with client.text('mystream') as fd:
+    client = self._registry.create(
+      "test:value", project="test", prefix="foo/bar"
+    )
+    with client.text("mystream") as fd:
       self.assertRaises(KeyError, fd.get_viewer_url)
 
-
   def testCreatingDuplicateStreamNameRaisesValueError(self):
-    client = self._registry.create('test:value')
-    with client.text('mystream') as fd:
-      fd.write('Using a text stream.')
+    client = self._registry.create("test:value")
+    with client.text("mystream") as fd:
+      fd.write("Using a text stream.")
 
     with self.assertRaises(ValueError):
-      with client.text('mystream') as fd:
-        fd.write('Should not work.')
+      with client.text("mystream") as fd:
+        fd.write("Should not work.")
 
     conn = client.last_conn
     self.assertTrue(conn.closed)
 
     header, data = conn.interpret()
-    self.assertEqual(header, {'name': 'mystream', 'type': 'text'})
-    self.assertEqual(data.decode('utf-8'), 'Using a text stream.')
+    self.assertEqual(header, {"name": "mystream", "type": "text"})
+    self.assertEqual(data.decode("utf-8"), "Using a text stream.")
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
   unittest.main()
diff --git a/libs/logdog/tests/streamname_test.py b/libs/logdog/tests/streamname_test.py
index 45329c0..1e95629 100755
--- a/libs/logdog/tests/streamname_test.py
+++ b/libs/logdog/tests/streamname_test.py
@@ -7,37 +7,44 @@
 import sys
 import unittest
 
-ROOT_DIR = os.path.dirname(os.path.abspath(os.path.join(
-    __file__.decode(sys.getfilesystemencoding()),
-    os.pardir, os.pardir, os.pardir)))
+ROOT_DIR = os.path.dirname(
+  os.path.abspath(
+    os.path.join(
+      __file__.decode(sys.getfilesystemencoding()),
+      os.pardir,
+      os.pardir,
+      os.pardir,
+    )
+  )
+)
 sys.path.insert(0, ROOT_DIR)
 
 # pylint: disable=no-name-in-module
 from utils import tools
+
 tools.force_local_third_party(ROOT_DIR)
 
 from libs.logdog import streamname
 
 
 class StreamNameTestCase(unittest.TestCase):
-
   def testInvalidStreamNamesRaiseValueError(self):
     for name in (
-        '',
-        'a' * (streamname._MAX_STREAM_NAME_LENGTH+1),
-        ' s p a c e s ',
-        '-hyphen',
-        'stream/path/+/not/name',
+      "",
+      "a" * (streamname._MAX_STREAM_NAME_LENGTH + 1),
+      " s p a c e s ",
+      "-hyphen",
+      "stream/path/+/not/name",
     ):
       with self.assertRaises(ValueError):
         streamname.validate_stream_name(name)
 
   def testValidStreamNamesDoNotRaise(self):
     for name in (
-        'a',
-        'a' * (streamname._MAX_STREAM_NAME_LENGTH),
-        'foo/bar',
-        'f123/four/five-_.:',
+      "a",
+      "a" * (streamname._MAX_STREAM_NAME_LENGTH),
+      "foo/bar",
+      "f123/four/five-_.:",
     ):
       raised = False
       try:
@@ -48,87 +55,103 @@
 
   def testNormalizeSegment(self):
     for name, normalized in (
-        ('', 'PFX'),
-        ('     ', 'PFX_____'),
-        ('_invalid_start_char', 'PFX_invalid_start_char'),
-        ('valid_seg.1:2-3', 'valid_seg.1:2-3'),
-        ('some seg (with stuff)', 'some_seg__with_stuff_'),
-        # treat '/' as invalid
-        ('_invalid/se!g/entry', 'PFX_invalid_se_g_entry'),
-        ('/seg/', 'PFX_seg_'),
+      ("", "PFX"),
+      ("     ", "PFX_____"),
+      ("_invalid_start_char", "PFX_invalid_start_char"),
+      ("valid_seg.1:2-3", "valid_seg.1:2-3"),
+      ("some seg (with stuff)", "some_seg__with_stuff_"),
+      # treat '/' as invalid
+      ("_invalid/se!g/entry", "PFX_invalid_se_g_entry"),
+      ("/seg/", "PFX_seg_"),
     ):
       self.assertEqual(
-          streamname.normalize_segment(name, prefix='PFX'), normalized)
+        streamname.normalize_segment(name, prefix="PFX"), normalized
+      )
 
     # Assert that an empty stream name with no prefix will raise a ValueError.
-    self.assertRaises(ValueError, streamname.normalize_segment, '')
+    self.assertRaises(ValueError, streamname.normalize_segment, "")
 
     # Assert that a stream name with an invalid starting character and no prefix
     # will raise a ValueError.
-    self.assertRaises(ValueError, streamname.normalize_segment,
-                      '_invalid_start_char')
+    self.assertRaises(
+      ValueError, streamname.normalize_segment, "_invalid_start_char"
+    )
 
   def testNormalize(self):
     self.assertEqual(
-        streamname.normalize('valid/st:ream/na-me.',), 'valid/st:ream/na-me.')
+      streamname.normalize(
+        "valid/st:ream/na-me.",
+      ),
+      "valid/st:ream/na-me.",
+    )
     self.assertEqual(
-        streamname.normalize('_invalid/st!ream/name entry', prefix='PFX'),
-        'PFX_invalid/st_ream/name_entry')
+      streamname.normalize("_invalid/st!ream/name entry", prefix="PFX"),
+      "PFX_invalid/st_ream/name_entry",
+    )
 
 
 class StreamPathTestCase(unittest.TestCase):
-
   def testParseValidPath(self):
     for path in (
-        'foo/+/bar',
-        'foo/bar/+/baz',
+      "foo/+/bar",
+      "foo/bar/+/baz",
     ):
-      prefix, name = path.split('/+/')
+      prefix, name = path.split("/+/")
       parsed = streamname.StreamPath.parse(path)
-      self.assertEqual(
-          parsed,
-          streamname.StreamPath(prefix=prefix, name=name))
+      self.assertEqual(parsed, streamname.StreamPath(prefix=prefix, name=name))
       self.assertEqual(str(parsed), path)
 
   def testParseInvalidValidPathRaisesValueError(self):
     for path in (
-        '',
-        'foo/+',
-        'foo/+/',
-        '+/bar',
-        '/+/bar',
-        'foo/bar',
-        '!!!invalid!!!/+/bar',
-        'foo/+/!!!invalid!!!',
+      "",
+      "foo/+",
+      "foo/+/",
+      "+/bar",
+      "/+/bar",
+      "foo/bar",
+      "!!!invalid!!!/+/bar",
+      "foo/+/!!!invalid!!!",
     ):
       with self.assertRaises(ValueError):
         streamname.StreamPath.parse(path)
 
   def testLogDogViewerUrl(self):
     for project, path, url in (
-        ('test', streamname.StreamPath(prefix='foo', name='bar/baz'),
-         'https://example.appspot.com/v/?s=test%2Ffoo%2F%2B%2Fbar%2Fbaz'),
-
-        ('test', streamname.StreamPath(prefix='foo', name='bar/**'),
-         'https://example.appspot.com/v/?s=test%2Ffoo%2F%2B%2Fbar%2F%2A%2A'),
-
-        ('test', streamname.StreamPath(prefix='**', name='**'),
-         'https://example.appspot.com/v/?s=test%2F%2A%2A%2F%2B%2F%2A%2A'),
+      (
+        "test",
+        streamname.StreamPath(prefix="foo", name="bar/baz"),
+        "https://example.appspot.com/v/?s=test%2Ffoo%2F%2B%2Fbar%2Fbaz",
+      ),
+      (
+        "test",
+        streamname.StreamPath(prefix="foo", name="bar/**"),
+        "https://example.appspot.com/v/?s=test%2Ffoo%2F%2B%2Fbar%2F%2A%2A",
+      ),
+      (
+        "test",
+        streamname.StreamPath(prefix="**", name="**"),
+        "https://example.appspot.com/v/?s=test%2F%2A%2A%2F%2B%2F%2A%2A",
+      ),
     ):
       self.assertEqual(
-          streamname.get_logdog_viewer_url('example.appspot.com', project,
-                                           path),
-          url)
+        streamname.get_logdog_viewer_url("example.appspot.com", project, path),
+        url,
+      )
 
     # Multiple streams.
     self.assertEqual(
-        streamname.get_logdog_viewer_url('example.appspot.com', 'test',
-            streamname.StreamPath(prefix='foo', name='bar/baz'),
-            streamname.StreamPath(prefix='qux', name='**'),
-        ),
-        ('https://example.appspot.com/v/?s=test%2Ffoo%2F%2B%2Fbar%2Fbaz&'
-         's=test%2Fqux%2F%2B%2F%2A%2A'))
+      streamname.get_logdog_viewer_url(
+        "example.appspot.com",
+        "test",
+        streamname.StreamPath(prefix="foo", name="bar/baz"),
+        streamname.StreamPath(prefix="qux", name="**"),
+      ),
+      (
+        "https://example.appspot.com/v/?s=test%2Ffoo%2F%2B%2Fbar%2Fbaz&"
+        "s=test%2Fqux%2F%2B%2F%2A%2A"
+      ),
+    )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
   unittest.main()
diff --git a/libs/logdog/tests/varint_test.py b/libs/logdog/tests/varint_test.py
index 0f1a51c..a8e6954 100755
--- a/libs/logdog/tests/varint_test.py
+++ b/libs/logdog/tests/varint_test.py
@@ -11,39 +11,51 @@
 import sys
 import unittest
 
-ROOT_DIR = os.path.dirname(os.path.abspath(os.path.join(
-    __file__.decode(sys.getfilesystemencoding()),
-    os.pardir, os.pardir, os.pardir)))
+ROOT_DIR = os.path.dirname(
+  os.path.abspath(
+    os.path.join(
+      __file__.decode(sys.getfilesystemencoding()),
+      os.pardir,
+      os.pardir,
+      os.pardir,
+    )
+  )
+)
 sys.path.insert(0, ROOT_DIR)
 
 from libs.logdog import varint
 
 
 class VarintTestCase(unittest.TestCase):
-
   def testVarintEncodingRaw(self):
     for base, exp in (
-        (0, b'\x00'),
-        (1, b'\x01'),
-        (0x7F, b'\x7f'),
-        (0x80, b'\x80\x01'),
-        (0x81, b'\x81\x01'),
-        (0x18080, b'\x80\x81\x06'),
+      (0, b"\x00"),
+      (1, b"\x01"),
+      (0x7F, b"\x7f"),
+      (0x80, b"\x80\x01"),
+      (0x81, b"\x81\x01"),
+      (0x18080, b"\x80\x81\x06"),
     ):
       bytesIO = BytesIO()
       count = varint.write_uvarint(bytesIO, base)
       act = bytesIO.getvalue()
 
-      self.assertEqual(act, exp,
-          "Encoding for %d (%r) doesn't match expected (%r)" % (base, act, exp))
-      self.assertEqual(count, len(act),
-          "Length of %d (%d) doesn't match encoded length (%d)" % (
-              base, len(act), count))
+      self.assertEqual(
+        act,
+        exp,
+        "Encoding for %d (%r) doesn't match expected (%r)" % (base, act, exp),
+      )
+      self.assertEqual(
+        count,
+        len(act),
+        "Length of %d (%d) doesn't match encoded length (%d)"
+        % (base, len(act), count),
+      )
 
   def testVarintEncodeDecode(self):
-    seed = (b'\x00', b'\x01', b'\x55', b'\x7F', b'\x80', b'\x81', b'\xff')
+    seed = (b"\x00", b"\x01", b"\x55", b"\x7f", b"\x80", b"\x81", b"\xff")
     for perm in itertools.permutations(seed):
-      perm = b''.join(perm)
+      perm = b"".join(perm)
 
       while len(perm) > 0:
         exp = int(binascii.hexlify(perm), 16)
@@ -52,17 +64,23 @@
         bytesIO.seek(0)
         act, count = varint.read_uvarint(bytesIO)
 
-        self.assertEqual(act, exp,
-            "Decoded %r (%d) doesn't match expected (%d)" % (
-                binascii.hexlify(bytesIO.getvalue()), act, exp))
-        self.assertEqual(count, len(bytesIO.getvalue()),
-            "Decoded length (%d) doesn't match expected (%d)" % (
-                count, len(bytesIO.getvalue())))
+        self.assertEqual(
+          act,
+          exp,
+          "Decoded %r (%d) doesn't match expected (%d)"
+          % (binascii.hexlify(bytesIO.getvalue()), act, exp),
+        )
+        self.assertEqual(
+          count,
+          len(bytesIO.getvalue()),
+          "Decoded length (%d) doesn't match expected (%d)"
+          % (count, len(bytesIO.getvalue())),
+        )
 
         if perm == 0:
           break
         perm = perm[1:]
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
   unittest.main()
diff --git a/libs/logdog/varint.py b/libs/logdog/varint.py
index c40bb5f..6e45b39 100644
--- a/libs/logdog/varint.py
+++ b/libs/logdog/varint.py
@@ -20,16 +20,16 @@
     ValueError if 'val' is < 0.
   """
   if val < 0:
-    raise ValueError('Cannot encode negative value, %d' % (val,))
+    raise ValueError("Cannot encode negative value, %d" % (val,))
 
   count = 0
   while val > 0 or count == 0:
-    byte = (val & 0b01111111)
+    byte = val & 0b01111111
     val >>= 7
     if val > 0:
       byte |= 0b10000000
 
-    w.write(struct.pack('B', byte))
+    w.write(struct.pack("B", byte))
     count += 1
   return count
 
@@ -54,10 +54,10 @@
   while True:
     byte = r.read(1)
     if len(byte) == 0:
-      raise ValueError('UVarint was not terminated')
+      raise ValueError("UVarint was not terminated")
 
-    byte = struct.unpack('B', byte)[0]
-    result |= ((byte & 0b01111111) << (7 * count))
+    byte = struct.unpack("B", byte)[0]
+    result |= (byte & 0b01111111) << (7 * count)
     count += 1
     if byte & 0b10000000 == 0:
       break
diff --git a/libs/luci_context/luci_context.py b/libs/luci_context/luci_context.py
index 105d7a0..dbbfca6 100644
--- a/libs/luci_context/luci_context.py
+++ b/libs/luci_context/luci_context.py
@@ -26,7 +26,7 @@
 
 # ENV_KEY is the environment variable that we look for to find out where the
 # LUCI context file is.
-ENV_KEY = 'LUCI_CONTEXT'
+ENV_KEY = "LUCI_CONTEXT"
 
 # _CUR_CONTEXT contains the cached LUCI Context that is currently available to
 # read. A value of None indicates that the value has not yet been populated.
@@ -41,8 +41,9 @@
 @contextlib.contextmanager
 def _tf(data, data_raw=False, leak=False, workdir=None):
   tf = tempfile.NamedTemporaryFile(
-      mode='w', prefix='luci_ctx.', suffix='.json', delete=False, dir=workdir)
-  _LOGGER.debug('Writing LUCI_CONTEXT file %r', tf.name)
+    mode="w", prefix="luci_ctx.", suffix=".json", delete=False, dir=workdir
+  )
+  _LOGGER.debug("Writing LUCI_CONTEXT file %r", tf.name)
   try:
     if not data_raw:
       json.dump(_to_encodable(data), tf)
@@ -56,40 +57,42 @@
       try:
         os.unlink(tf.name)
       except OSError as ex:
-        _LOGGER.error('Failed to delete written LUCI_CONTEXT file %r: %s',
-                      tf.name, ex)
+        _LOGGER.error(
+          "Failed to delete written LUCI_CONTEXT file %r: %s", tf.name, ex
+        )
 
 
 def _to_encodable(obj):
   if isinstance(obj, dict):
     return {
-        _to_encodable(key): _to_encodable(value) for key, value in obj.items()
+      _to_encodable(key): _to_encodable(value) for key, value in obj.items()
     }
   if isinstance(obj, list):
     return [_to_encodable(item) for item in obj]
   if isinstance(obj, bytes):
-    return obj.decode('utf-8')
+    return obj.decode("utf-8")
   return obj
 
 
 class MultipleLUCIContextException(Exception):
   def __init__(self):
     super(MultipleLUCIContextException, self).__init__(
-      'Attempted to write LUCI_CONTEXT in multiple threads')
+      "Attempted to write LUCI_CONTEXT in multiple threads"
+    )
 
 
 def _check_ok(data):
   if not isinstance(data, dict):
     _LOGGER.error(
-      'LUCI_CONTEXT does not contain a dict: %s', type(data).__name__)
+      "LUCI_CONTEXT does not contain a dict: %s", type(data).__name__
+    )
     return False
 
   bad = False
   for k, v in data.items():
     if not isinstance(v, dict):
       bad = True
-      _LOGGER.error(
-        'LUCI_CONTEXT[%r] is not a dict: %s', k, type(v).__name__)
+      _LOGGER.error("LUCI_CONTEXT[%r] is not a dict: %s", k, type(v).__name__)
 
   return not bad
 
@@ -101,16 +104,16 @@
 
   ctx_path = os.environ.get(ENV_KEY)
   if ctx_path:
-    _LOGGER.debug('Loading LUCI_CONTEXT: %r', ctx_path)
+    _LOGGER.debug("Loading LUCI_CONTEXT: %r", ctx_path)
     try:
-      with open(ctx_path, 'r') as f:
+      with open(ctx_path, "r") as f:
         loaded = json.load(f)
         if _check_ok(loaded):
           to_assign = loaded
     except OSError as ex:
-      _LOGGER.error('LUCI_CONTEXT failed to open or read: %s', ex)
+      _LOGGER.error("LUCI_CONTEXT failed to open or read: %s", ex)
     except ValueError as ex:
-      _LOGGER.error('LUCI_CONTEXT failed to decode: %s', ex)
+      _LOGGER.error("LUCI_CONTEXT failed to decode: %s", ex)
 
   _CUR_CONTEXT = to_assign
 
@@ -136,8 +139,9 @@
         changed = True
       new_val[section] = value
     else:
-      raise ValueError('Bad type for LUCI_CONTEXT[%r]: %s' %
-                       (section, type(value).__name__))
+      raise ValueError(
+        "Bad type for LUCI_CONTEXT[%r]: %s" % (section, type(value).__name__)
+      )
   return new_val, changed
 
 
diff --git a/libs/luci_context/luci_context_test.py b/libs/luci_context/luci_context_test.py
index 9f834fc..be9d065 100755
--- a/libs/luci_context/luci_context_test.py
+++ b/libs/luci_context/luci_context_test.py
@@ -9,7 +9,8 @@
 import unittest
 
 ROOT_DIR = os.path.dirname(
-    os.path.abspath(os.path.join(__file__, os.pardir, os.pardir)))
+  os.path.abspath(os.path.join(__file__, os.pardir, os.pardir))
+)
 sys.path.insert(0, ROOT_DIR)
 
 from libs.luci_context import luci_context
@@ -25,27 +26,32 @@
 
   def tearDown(self):
     self.assertNotIn(
-      self.ek, os.environ, '%s in environ (%r)! Possible leak in test?' % (
-        self.ek, os.environ.get(self.ek)))
+      self.ek,
+      os.environ,
+      "%s in environ (%r)! Possible leak in test?"
+      % (self.ek, os.environ.get(self.ek)),
+    )
     luci_context._CUR_CONTEXT = None
 
   def test_ok(self):
-    self.assertFalse(luci_context._check_ok('hi'))
-    self.assertFalse(luci_context._check_ok({'hi': 'there'}))
-    self.assertFalse(luci_context._check_ok({'hi': 'there',
-                                             'ok': {'thing': 'true'}}))
-    self.assertTrue(luci_context._check_ok({'ok': {'thing': 'true'}}))
+    self.assertFalse(luci_context._check_ok("hi"))
+    self.assertFalse(luci_context._check_ok({"hi": "there"}))
+    self.assertFalse(
+      luci_context._check_ok({"hi": "there", "ok": {"thing": "true"}})
+    )
+    self.assertTrue(luci_context._check_ok({"ok": {"thing": "true"}}))
 
   def test_initial_load_dne(self):
     self.assertDictEqual(luci_context.read_full(), {})
     self.assertDictEqual(luci_context._CUR_CONTEXT, {})
 
     def nope():
-      raise Exception('I SHOULD NOT BE CALLED')
+      raise Exception("I SHOULD NOT BE CALLED")
+
     og_load = luci_context._initial_load
     luci_context._initial_load = nope
     try:
-      self.assertIsNone(luci_context.read('section'))
+      self.assertIsNone(luci_context.read("section"))
     finally:
       luci_context._initial_load = og_load
 
@@ -59,7 +65,7 @@
         del os.environ[self.ek]
 
   def test_initial_load_cannot_read(self):
-    with luci_context._tf({'something': {'data': True}}) as name:
+    with luci_context._tf({"something": {"data": True}}) as name:
       os.chmod(name, 0)
       os.environ[self.ek] = name
       try:
@@ -69,7 +75,7 @@
         del os.environ[self.ek]
 
   def test_initial_load_not_dict(self):
-    with luci_context._tf('hi') as name:
+    with luci_context._tf("hi") as name:
       os.environ[self.ek] = name
       try:
         self.assertDictEqual(luci_context.read_full(), {})
@@ -78,7 +84,7 @@
         del os.environ[self.ek]
 
   def test_initial_load_not_subsection_dict(self):
-    with luci_context._tf({'something': 'string'}) as name:
+    with luci_context._tf({"something": "string"}) as name:
       os.environ[self.ek] = name
       try:
         self.assertDictEqual(luci_context.read_full(), {})
@@ -87,72 +93,76 @@
         del os.environ[self.ek]
 
   def test_initial_load_win(self):
-    with luci_context.write(something={'data': True}):
-      self.assertDictEqual(luci_context.read_full(),
-                           {'something': {'data': True}})
-      self.assertDictEqual(luci_context._CUR_CONTEXT,
-                           {'something': {'data': True}})
-      self.assertDictEqual(luci_context.read('something'), {'data': True})
+    with luci_context.write(something={"data": True}):
+      self.assertDictEqual(
+        luci_context.read_full(), {"something": {"data": True}}
+      )
+      self.assertDictEqual(
+        luci_context._CUR_CONTEXT, {"something": {"data": True}}
+      )
+      self.assertDictEqual(luci_context.read("something"), {"data": True})
 
   def test_nested(self):
     w = luci_context.write
     r = luci_context.read
-    with w(something={'data': True}):
-      self.assertIsNone(r('other'))
-      self.assertDictEqual(r('something'), {'data': True})
+    with w(something={"data": True}):
+      self.assertIsNone(r("other"))
+      self.assertDictEqual(r("something"), {"data": True})
 
-      with w(other={'not': 10}, something=None):
-        self.assertIsNone(r('something'))
-        self.assertDictEqual(r('other'), {'not': 10})
+      with w(other={"not": 10}, something=None):
+        self.assertIsNone(r("something"))
+        self.assertDictEqual(r("other"), {"not": 10})
 
-      self.assertIsNone(r('other'))
-      self.assertDictEqual(r('something'), {'data': True})
+      self.assertIsNone(r("other"))
+      self.assertDictEqual(r("something"), {"data": True})
 
-    self.assertIsNone(r('other'))
-    self.assertIsNone(r('something'))
+    self.assertIsNone(r("other"))
+    self.assertIsNone(r("something"))
 
   def test_write_unchanged(self):
-    with luci_context.write(something={'data': True}):
+    with luci_context.write(something={"data": True}):
       path = os.environ.get(self.ek)
       with luci_context.write():
-        self.assertDictEqual(luci_context.read_full(),
-                             {'something': {'data': True}})
+        self.assertDictEqual(
+          luci_context.read_full(), {"something": {"data": True}}
+        )
         self.assertEqual(os.environ.get(self.ek), path)
-      with luci_context.write(something={'data': True}):
+      with luci_context.write(something={"data": True}):
         self.assertEqual(os.environ.get(self.ek), path)
-        self.assertDictEqual(luci_context.read_full(),
-                             {'something': {'data': True}})
-      with luci_context.write(something={'data': False}):
+        self.assertDictEqual(
+          luci_context.read_full(), {"something": {"data": True}}
+        )
+      with luci_context.write(something={"data": False}):
         self.assertNotEqual(os.environ.get(self.ek), path)
 
   def test_stage(self):
     path = None
-    with luci_context.stage(something={'data': True}) as path:
-      with open(path, 'r') as f:
+    with luci_context.stage(something={"data": True}) as path:
+      with open(path, "r") as f:
         self.assertEqual('{"something": {"data": true}}', f.read())
     # The file is gone outside 'with' block.
     self.assertFalse(os.path.exists(path))
 
   def test_stage_unchanged(self):
-    with luci_context.write(something={'data': True}):
+    with luci_context.write(something={"data": True}):
       path = os.environ.get(self.ek)
       with luci_context.stage() as new_path:
         self.assertIsNone(new_path)
-      with luci_context.stage(something={'data': True}) as new_path:
+      with luci_context.stage(something={"data": True}) as new_path:
         self.assertIsNone(new_path)
-      with luci_context.stage(something={'data': False}) as new_path:
+      with luci_context.stage(something={"data": False}) as new_path:
         self.assertNotEqual(new_path, path)
 
   def test_leak(self):
     path = None
-    with luci_context._tf({'something': {'data': True}}, leak=True) as path:
+    with luci_context._tf({"something": {"data": True}}, leak=True) as path:
       self.assertTrue(os.path.exists(path))
     # The file is not deleted after contextmanager exits
     self.assertTrue(os.path.exists(path))
     os.unlink(path)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
   # Pop it out of the environment to make sure we start clean.
   logging.basicConfig()
   os.environ.pop(luci_context.ENV_KEY, None)
diff --git a/swarming.py b/swarming.py
index 314e21b..f5f25d0 100755
--- a/swarming.py
+++ b/swarming.py
@@ -20,7 +20,7 @@
 # >
 # [VPYTHON:END]
 
-__version__ = '1.0'
+__version__ = "1.0"
 
 import json
 import logging
@@ -31,6 +31,7 @@
 import urllib.parse
 
 from utils import tools
+
 tools.force_local_third_party()
 
 # third_party/
@@ -65,20 +66,20 @@
   """
   # Uses the real Cloud Endpoints. This needs to be fixed once the Cloud
   # Endpoints version is turned down.
-  data = net.url_read_json(host + '/_ah/api/discovery/v1/apis')
+  data = net.url_read_json(host + "/_ah/api/discovery/v1/apis")
   if data is None:
-    raise APIError('Failed to discover APIs on %s' % host)
+    raise APIError("Failed to discover APIs on %s" % host)
   out = {}
-  for api in data['items']:
-    if api['id'] == 'discovery:v1':
+  for api in data["items"]:
+    if api["id"] == "discovery:v1":
       continue
     # URL is of the following form:
     # url = host + (
     #   '/_ah/api/discovery/v1/apis/%s/%s/rest' % (api['id'], api['version'])
-    api_data = net.url_read_json(api['discoveryRestUrl'])
+    api_data = net.url_read_json(api["discoveryRestUrl"])
     if api_data is None:
-      raise APIError('Failed to discover %s on %s' % (api['id'], host))
-    out[api['id']] = api_data
+      raise APIError("Failed to discover %s on %s" % (api["id"], host))
+    out[api["id"]] = api_data
   return out
 
 
@@ -88,14 +89,14 @@
 
   url = base_url
   if limit:
-    url += '%slimit=%d' % ('&' if '?' in url else '?', min(CHUNK_SIZE, limit))
+    url += "%slimit=%d" % ("&" if "?" in url else "?", min(CHUNK_SIZE, limit))
   data = net.url_read_json(url)
   if data is None:
     # TODO(maruel): Do basic diagnostic.
-    raise Failure('Failed to access %s' % url)
-  org_cursor = data.pop('cursor', None)
-  org_total = len(data.get('items') or [])
-  logging.info('get_yielder(%s) returning %d items', base_url, org_total)
+    raise Failure("Failed to access %s" % url)
+  org_cursor = data.pop("cursor", None)
+  org_total = len(data.get("items") or [])
+  logging.info("get_yielder(%s) returning %d items", base_url, org_total)
   if not org_cursor or not org_total:
     # This is not an iterable resource.
     return data, lambda: []
@@ -106,18 +107,18 @@
     # Some items support cursors. Try to get automatically if cursors are needed
     # by looking at the 'cursor' items.
     while cursor and (not limit or total < limit):
-      merge_char = '&' if '?' in base_url else '?'
-      url = base_url + '%scursor=%s' % (merge_char, urllib.parse.quote(cursor))
+      merge_char = "&" if "?" in base_url else "?"
+      url = base_url + "%scursor=%s" % (merge_char, urllib.parse.quote(cursor))
       if limit:
-        url += '&limit=%d' % min(CHUNK_SIZE, limit - total)
+        url += "&limit=%d" % min(CHUNK_SIZE, limit - total)
       new = net.url_read_json(url)
       if new is None:
-        raise Failure('Failed to access %s' % url)
-      cursor = new.get('cursor')
-      new_items = new.get('items')
+        raise Failure("Failed to access %s" % url)
+      cursor = new.get("cursor")
+      new_items = new.get("items")
       nb_items = len(new_items or [])
       total += nb_items
-      logging.info('get_yielder(%s) yielding %d items', base_url, nb_items)
+      logging.info("get_yielder(%s) yielding %d items", base_url, nb_items)
       yield new_items
 
   return data, yielder
@@ -126,7 +127,7 @@
 ### Commands.
 
 
-@subcommand.usage('[method name]')
+@subcommand.usage("[method name]")
 def CMDquery(parser, args):
   """Returns raw JSON information via an URL endpoint. Use 'query-list' to
   gather the list of API methods from the server.
@@ -148,37 +149,41 @@
           'tasks/list?tags=os:Ubuntu-14.04&tags=pool:Chrome'
   """
   parser.add_option(
-      '-L',
-      '--limit',
-      type='int',
-      default=200,
-      help='Limit to enforce on limitless items (like number of tasks); '
-      'default=%default')
+    "-L",
+    "--limit",
+    type="int",
+    default=200,
+    help="Limit to enforce on limitless items (like number of tasks); "
+    "default=%default",
+  )
   parser.add_option(
-      '--json', help='Path to JSON output file (otherwise prints to stdout)')
+    "--json", help="Path to JSON output file (otherwise prints to stdout)"
+  )
   parser.add_option(
-      '--progress',
-      action='store_true',
-      help='Prints a dot at each request to show progress')
+    "--progress",
+    action="store_true",
+    help="Prints a dot at each request to show progress",
+  )
   options, args = parser.parse_args(args)
   if len(args) != 1:
     parser.error(
-        'Must specify only method name and optionally query args properly '
-        'escaped.')
-  base_url = options.swarming + '/_ah/api/swarming/v1/' + args[0]
+      "Must specify only method name and optionally query args properly "
+      "escaped."
+    )
+  base_url = options.swarming + "/_ah/api/swarming/v1/" + args[0]
   try:
     data, yielder = get_yielder(base_url, options.limit)
     for items in yielder():
       if items:
-        data['items'].extend(items)
+        data["items"].extend(items)
       if options.progress:
-        sys.stderr.write('.')
+        sys.stderr.write(".")
         sys.stderr.flush()
   except Failure as e:
-    sys.stderr.write('\n%s\n' % e)
+    sys.stderr.write("\n%s\n" % e)
     return 1
   if options.progress:
-    sys.stderr.write('\n')
+    sys.stderr.write("\n")
     sys.stderr.flush()
   if options.json:
     options.json = os.path.abspath(options.json)
@@ -186,7 +191,7 @@
   else:
     try:
       tools.write_json(sys.stdout, data, False)
-      sys.stdout.write('\n')
+      sys.stdout.write("\n")
     except IOError:
       pass
   return 0
@@ -197,10 +202,11 @@
   'query'.
   """
   parser.add_option(
-      '--json', help='Path to JSON output file (otherwise prints to stdout)')
+    "--json", help="Path to JSON output file (otherwise prints to stdout)"
+  )
   options, args = parser.parse_args(args)
   if args:
-    parser.error('No argument allowed.')
+    parser.error("No argument allowed.")
 
   try:
     apis = endpoints_api_discovery_apis(options.swarming)
@@ -208,67 +214,80 @@
     parser.error(str(e))
   if options.json:
     options.json = os.path.abspath(options.json)
-    with fs.open(options.json, 'wb') as f:
+    with fs.open(options.json, "wb") as f:
       json.dump(apis, f)
   else:
     help_url = (
-        'https://apis-explorer.appspot.com/apis-explorer/?base=%s/_ah/api#p/' %
-        options.swarming)
+      "https://apis-explorer.appspot.com/apis-explorer/?base=%s/_ah/api#p/"
+      % options.swarming
+    )
     for i, (api_id, api) in enumerate(sorted(apis.items())):
       if i:
-        print('')
+        print("")
       print(api_id)
-      print('  ' + api['description'].strip())
-      if 'resources' in api:
+      print("  " + api["description"].strip())
+      if "resources" in api:
         # Old.
         # TODO(maruel): Remove.
         # pylint: disable=too-many-nested-blocks
-        for j, (resource_name,
-                resource) in enumerate(sorted(api['resources'].items())):
+        for j, (resource_name, resource) in enumerate(
+          sorted(api["resources"].items())
+        ):
           if j:
-            print('')
-          for method_name, method in sorted(resource['methods'].items()):
+            print("")
+          for method_name, method in sorted(resource["methods"].items()):
             # Only list the GET ones.
-            if method['httpMethod'] != 'GET':
+            if method["httpMethod"] != "GET":
               continue
-            print('- %s.%s: %s' % (resource_name, method_name, method['path']))
-            print('\n'.join('  ' + l for l in textwrap.wrap(
-                method.get('description', 'No description'), 78)))
-            print('  %s%s%s' % (help_url, api['servicePath'], method['id']))
+            print("- %s.%s: %s" % (resource_name, method_name, method["path"]))
+            print(
+              "\n".join(
+                "  " + l
+                for l in textwrap.wrap(
+                  method.get("description", "No description"), 78
+                )
+              )
+            )
+            print("  %s%s%s" % (help_url, api["servicePath"], method["id"]))
       else:
         # New.
-        for method_name, method in sorted(api['methods'].items()):
+        for method_name, method in sorted(api["methods"].items()):
           # Only list the GET ones.
-          if method['httpMethod'] != 'GET':
+          if method["httpMethod"] != "GET":
             continue
-          print('- %s: %s' % (method['id'], method['path']))
-          print('\n'.join(
-              '  ' + l for l in textwrap.wrap(method['description'], 78)))
-          print('  %s%s%s' % (help_url, api['servicePath'], method['id']))
+          print("- %s: %s" % (method["id"], method["path"]))
+          print(
+            "\n".join(
+              "  " + l for l in textwrap.wrap(method["description"], 78)
+            )
+          )
+          print("  %s%s%s" % (help_url, api["servicePath"], method["id"]))
   return 0
 
 
 class OptionParserSwarming(logging_utils.OptionParserWithLogging):
-
   def __init__(self, **kwargs):
     logging_utils.OptionParserWithLogging.__init__(
-        self, prog='swarming.py', **kwargs)
-    self.server_group = optparse.OptionGroup(self, 'Server')
+      self, prog="swarming.py", **kwargs
+    )
+    self.server_group = optparse.OptionGroup(self, "Server")
     self.server_group.add_option(
-        '-S',
-        '--swarming',
-        metavar='URL',
-        default=os.environ.get('SWARMING_SERVER', ''),
-        help='Swarming server to use')
+      "-S",
+      "--swarming",
+      metavar="URL",
+      default=os.environ.get("SWARMING_SERVER", ""),
+      help="Swarming server to use",
+    )
     self.add_option_group(self.server_group)
     auth.add_auth_options(self)
 
   def parse_args(self, *args, **kwargs):
     options, args = logging_utils.OptionParserWithLogging.parse_args(
-        self, *args, **kwargs)
+      self, *args, **kwargs
+    )
     auth.process_auth_options(self, options)
     user = self._process_swarming(options)
-    if hasattr(options, 'user') and not options.user:
+    if hasattr(options, "user") and not options.user:
       options.user = user
     return options, args
 
@@ -278,11 +297,11 @@
     Returns the identity as determined by the server.
     """
     if not options.swarming:
-      self.error('--swarming is required.')
+      self.error("--swarming is required.")
     try:
       options.swarming = net.fix_url(options.swarming)
     except ValueError as e:
-      self.error('--swarming %s' % e)
+      self.error("--swarming %s" % e)
 
     try:
       user = auth.ensure_logged_in(options.swarming)
@@ -296,10 +315,10 @@
   return dispatcher.execute(OptionParserSwarming(version=__version__), args)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
   subprocess42.inhibit_os_error_reporting()
   fix_encoding.fix_encoding()
   tools.disable_buffering()
   colorama.init()
-  net.set_user_agent('swarming.py/' + __version__)
+  net.set_user_agent("swarming.py/" + __version__)
   sys.exit(main(sys.argv[1:]))
diff --git a/test.py b/test.py
index bc03669..9b94837 100755
--- a/test.py
+++ b/test.py
@@ -7,9 +7,9 @@
 import sys
 
 THIS_DIR = os.path.dirname(os.path.abspath(__file__))
-TESTS_DIR = os.path.join(THIS_DIR, 'tests')
+TESTS_DIR = os.path.join(THIS_DIR, "tests")
 LUCI_DIR = os.path.dirname(THIS_DIR)
-COMPONENTS_DIR = os.path.join(LUCI_DIR, 'appengine', 'components')
+COMPONENTS_DIR = os.path.join(LUCI_DIR, "appengine", "components")
 
 
 def main():
@@ -21,22 +21,24 @@
 def run_tests_parralel():
   sys.path.insert(0, TESTS_DIR)
   import test_env
+
   test_env.setup()
 
   # Need to specify config path explicitly
   # because test_env.setup() changes directory
-  cfg = os.path.join(THIS_DIR, 'unittest.cfg')
-  sys.argv.extend(['-c', cfg])
+  cfg = os.path.join(THIS_DIR, "unittest.cfg")
+  sys.argv.extend(["-c", cfg])
 
   # enable plugins only on linux
   plugins = []
-  if sys.platform == 'linux':
-    plugins.append('nose2.plugins.mp')
+  if sys.platform == "linux":
+    plugins.append("nose2.plugins.mp")
 
   # append attribute filter option "--attribute '!no_run'"
   # https://nose2.readthedocs.io/en/latest/plugins/attrib.html
   from test_support import parallel_test_runner
-  sys.argv.extend(['--attribute', '!no_run'])
+
+  sys.argv.extend(["--attribute", "!no_run"])
 
   # execute test runner
   return parallel_test_runner.run_tests(python3=True, plugins=plugins)
@@ -48,15 +50,16 @@
   # or run via test runner
   abs_path = lambda f: os.path.join(THIS_DIR, f)
   test_cmds = [
-      [abs_path('tests/swarming_test.py')],
-      [abs_path('tests/run_isolated_test.py')],
-      [abs_path('tests/logging_utils_test.py')],
+    [abs_path("tests/swarming_test.py")],
+    [abs_path("tests/run_isolated_test.py")],
+    [abs_path("tests/logging_utils_test.py")],
   ]
 
   # execute test runner
   from test_support import sequential_test_runner
+
   return sequential_test_runner.run_tests(test_cmds, python3=True)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
   sys.exit(main())
diff --git a/tests/auth_server_test.py b/tests/auth_server_test.py
index 1f42817..5bb3833 100755
--- a/tests/auth_server_test.py
+++ b/tests/auth_server_test.py
@@ -25,30 +25,31 @@
 
 
 def call_rpc(account_id, scopes=None, audience=None):
-  ctx = luci_context.read('local_auth')
+  ctx = luci_context.read("local_auth")
 
   if audience is None:
     assert scopes
-    method = 'GetOAuthToken'
+    method = "GetOAuthToken"
     body = {
-      'account_id': account_id,
-      'scopes': scopes,
-      'secret': ctx['secret'],
+      "account_id": account_id,
+      "scopes": scopes,
+      "secret": ctx["secret"],
     }
   else:
     assert scopes is None
-    method = 'GetIDToken'
+    method = "GetIDToken"
     body = {
-      'account_id': account_id,
-      'audience': audience,
-      'secret': ctx['secret'],
+      "account_id": account_id,
+      "audience": audience,
+      "secret": ctx["secret"],
     }
 
   r = requests.post(
-      url='http://127.0.0.1:%d/rpc/LuciLocalAuthService.%s' % (
-          ctx['rpc_port'], method),
-      data=json.dumps(body),
-      headers={'Content-Type': 'application/json'})
+    url="http://127.0.0.1:%d/rpc/LuciLocalAuthService.%s"
+    % (ctx["rpc_port"], method),
+    data=json.dumps(body),
+    headers={"Content-Type": "application/json"},
+  )
 
   return r.json()
 
@@ -58,17 +59,19 @@
   class MockedProvider:
     def generate_access_token(self, account_id, scopes):
       return token_cb(account_id, scopes=scopes)
+
     def generate_id_token(self, account_id, audience):
       return token_cb(account_id, audience=audience)
 
-  acc = lambda aid: auth_server.Account(id=aid, email=aid+'@example.com')
+  acc = lambda aid: auth_server.Account(id=aid, email=aid + "@example.com")
 
   s = auth_server.LocalAuthServer()
   try:
     local_auth = s.start(
-        token_provider=MockedProvider(),
-        accounts=(acc('acc_1'), acc('acc_2'), acc('acc_3')),
-        default_account_id=default_account_id)
+      token_provider=MockedProvider(),
+      accounts=(acc("acc_1"), acc("acc_2"), acc("acc_3")),
+      default_account_id=default_account_id,
+    )
     local_auth.update(overrides)
     with luci_context.write(local_auth=local_auth):
       yield
@@ -84,293 +87,298 @@
     self.mock_time(0)
 
   def mock_time(self, delta):
-    self.mock(time, 'time', lambda: self.epoch + delta)
+    self.mock(time, "time", lambda: self.epoch + delta)
 
   def test_accounts_in_ctx(self):
     def token_gen(_account_id, **_kwargs):
-      self.fail('must not be called')
-    with local_auth_server(token_gen, 'acc_1'):
-      ctx = luci_context.read('local_auth')
-      ctx.pop('rpc_port')
-      ctx.pop('secret')
-      self.assertEqual({
-          'accounts': [
-              {'email': 'acc_1@example.com', 'id': 'acc_1'},
-              {'email': 'acc_2@example.com', 'id': 'acc_2'},
-              {'email': 'acc_3@example.com', 'id': 'acc_3'},
+      self.fail("must not be called")
+
+    with local_auth_server(token_gen, "acc_1"):
+      ctx = luci_context.read("local_auth")
+      ctx.pop("rpc_port")
+      ctx.pop("secret")
+      self.assertEqual(
+        {
+          "accounts": [
+            {"email": "acc_1@example.com", "id": "acc_1"},
+            {"email": "acc_2@example.com", "id": "acc_2"},
+            {"email": "acc_3@example.com", "id": "acc_3"},
           ],
-         'default_account_id': 'acc_1',
-      }, ctx)
+          "default_account_id": "acc_1",
+        },
+        ctx,
+      )
 
   def test_access_tokens(self):
     calls = []
+
     def token_gen(account_id, scopes=None, audience=None):
       assert audience is None
       calls.append((account_id, scopes))
-      return auth_server.AccessToken('tok_%s' % account_id, time.time() + 300)
+      return auth_server.AccessToken("tok_%s" % account_id, time.time() + 300)
 
-    with local_auth_server(token_gen, 'acc_1'):
+    with local_auth_server(token_gen, "acc_1"):
       # Grab initial token.
-      resp = call_rpc('acc_1', scopes=['B', 'B', 'A', 'C'])
-      self.assertEqual({
-          'access_token': 'tok_acc_1',
-          'expiry': self.epoch + 300
-      }, resp)
-      self.assertEqual([('acc_1', ('A', 'B', 'C'))], calls)
+      resp = call_rpc("acc_1", scopes=["B", "B", "A", "C"])
+      self.assertEqual(
+        {"access_token": "tok_acc_1", "expiry": self.epoch + 300}, resp
+      )
+      self.assertEqual([("acc_1", ("A", "B", "C"))], calls)
       del calls[:]
 
       # Reuses cached token until it is close to expiration.
       self.mock_time(60)
-      resp = call_rpc('acc_1', scopes=['B', 'A', 'C'])
-      self.assertEqual({
-          'access_token': 'tok_acc_1',
-          'expiry': self.epoch + 300
-      }, resp)
+      resp = call_rpc("acc_1", scopes=["B", "A", "C"])
+      self.assertEqual(
+        {"access_token": "tok_acc_1", "expiry": self.epoch + 300}, resp
+      )
       self.assertFalse(calls)
 
       # Asking for different account gives another token.
-      resp = call_rpc('acc_2', scopes=['B', 'B', 'A', 'C'])
-      self.assertEqual({
-          'access_token': 'tok_acc_2',
-          'expiry': self.epoch + 360
-      }, resp)
-      self.assertEqual([('acc_2', ('A', 'B', 'C'))], calls)
+      resp = call_rpc("acc_2", scopes=["B", "B", "A", "C"])
+      self.assertEqual(
+        {"access_token": "tok_acc_2", "expiry": self.epoch + 360}, resp
+      )
+      self.assertEqual([("acc_2", ("A", "B", "C"))], calls)
       del calls[:]
 
       # First token has expired. Generated new one.
       self.mock_time(300)
-      resp = call_rpc('acc_1', scopes=['A', 'B', 'C'])
-      self.assertEqual({
-          'access_token': 'tok_acc_1',
-          'expiry': self.epoch + 600
-      }, resp)
-      self.assertEqual([('acc_1', ('A', 'B', 'C'))], calls)
+      resp = call_rpc("acc_1", scopes=["A", "B", "C"])
+      self.assertEqual(
+        {"access_token": "tok_acc_1", "expiry": self.epoch + 600}, resp
+      )
+      self.assertEqual([("acc_1", ("A", "B", "C"))], calls)
 
   def test_id_tokens(self):
     calls = []
+
     def token_gen(account_id, scopes=None, audience=None):
       assert scopes is None
       calls.append((account_id, audience))
-      return auth_server.AccessToken('tok_%s' % account_id, time.time() + 300)
+      return auth_server.AccessToken("tok_%s" % account_id, time.time() + 300)
 
-    with local_auth_server(token_gen, 'acc_1'):
+    with local_auth_server(token_gen, "acc_1"):
       # Grab initial token.
-      resp = call_rpc('acc_1', audience='some-audience')
-      self.assertEqual({
-          'id_token': 'tok_acc_1',
-          'expiry': self.epoch + 300
-      }, resp)
-      self.assertEqual([('acc_1', 'some-audience')], calls)
+      resp = call_rpc("acc_1", audience="some-audience")
+      self.assertEqual(
+        {"id_token": "tok_acc_1", "expiry": self.epoch + 300}, resp
+      )
+      self.assertEqual([("acc_1", "some-audience")], calls)
       del calls[:]
 
       # Reuses cached token until it is close to expiration.
       self.mock_time(60)
-      resp = call_rpc('acc_1', audience='some-audience')
-      self.assertEqual({
-          'id_token': 'tok_acc_1',
-          'expiry': self.epoch + 300
-      }, resp)
+      resp = call_rpc("acc_1", audience="some-audience")
+      self.assertEqual(
+        {"id_token": "tok_acc_1", "expiry": self.epoch + 300}, resp
+      )
       self.assertFalse(calls)
 
       # Asking for different audience gives another token.
-      resp = call_rpc('acc_1', audience='another-audience')
-      self.assertEqual({
-          'id_token': 'tok_acc_1',
-          'expiry': self.epoch + 360
-      }, resp)
-      self.assertEqual([('acc_1', 'another-audience')], calls)
+      resp = call_rpc("acc_1", audience="another-audience")
+      self.assertEqual(
+        {"id_token": "tok_acc_1", "expiry": self.epoch + 360}, resp
+      )
+      self.assertEqual([("acc_1", "another-audience")], calls)
       del calls[:]
 
       # Asking for different account gives another token.
-      resp = call_rpc('acc_2', audience='some-audience')
-      self.assertEqual({
-          'id_token': 'tok_acc_2',
-          'expiry': self.epoch + 360
-      }, resp)
-      self.assertEqual([('acc_2', 'some-audience')], calls)
+      resp = call_rpc("acc_2", audience="some-audience")
+      self.assertEqual(
+        {"id_token": "tok_acc_2", "expiry": self.epoch + 360}, resp
+      )
+      self.assertEqual([("acc_2", "some-audience")], calls)
       del calls[:]
 
       # First token has expired. Generated new one.
       self.mock_time(300)
-      resp = call_rpc('acc_1', audience='some-audience')
-      self.assertEqual({
-          'id_token': 'tok_acc_1',
-          'expiry': self.epoch + 600
-      }, resp)
-      self.assertEqual([('acc_1', 'some-audience')], calls)
+      resp = call_rpc("acc_1", audience="some-audience")
+      self.assertEqual(
+        {"id_token": "tok_acc_1", "expiry": self.epoch + 600}, resp
+      )
+      self.assertEqual([("acc_1", "some-audience")], calls)
 
   def test_handles_token_errors(self):
     calls = []
+
     def token_gen(_account_id, **_kwargs):
       calls.append(1)
-      raise auth_server.TokenError(123, 'error message')
+      raise auth_server.TokenError(123, "error message")
 
-    with local_auth_server(token_gen, 'acc_1'):
-      self.assertEqual({
-          'error_code': 123,
-          'error_message': 'error message'
-      }, call_rpc('acc_1', scopes=['B', 'B', 'A', 'C']))
+    with local_auth_server(token_gen, "acc_1"):
+      self.assertEqual(
+        {"error_code": 123, "error_message": "error message"},
+        call_rpc("acc_1", scopes=["B", "B", "A", "C"]),
+      )
       self.assertEqual(1, len(calls))
 
       # Errors are cached. Same error is returned.
-      self.assertEqual({
-          'error_code': 123,
-          'error_message': 'error message'
-      }, call_rpc('acc_1', scopes=['B', 'B', 'A', 'C']))
+      self.assertEqual(
+        {"error_code": 123, "error_message": "error message"},
+        call_rpc("acc_1", scopes=["B", "B", "A", "C"]),
+      )
       self.assertEqual(1, len(calls))
 
   def test_http_level_errors(self):
     def token_gen(_account_id, **_kwargs):
-      self.fail('must not be called')
+      self.fail("must not be called")
 
-    with local_auth_server(token_gen, 'acc_1'):
+    with local_auth_server(token_gen, "acc_1"):
       # Wrong URL.
-      ctx = luci_context.read('local_auth')
+      ctx = luci_context.read("local_auth")
       r = requests.post(
-          url='http://127.0.0.1:%d/blah/LuciLocalAuthService.GetOAuthToken' %
-              ctx['rpc_port'],
-          data=json.dumps({
-            'account_id': 'acc_1',
-            'scopes': ['A', 'B', 'C'],
-            'secret': ctx['secret'],
-          }),
-          headers={'Content-Type': 'application/json'})
+        url="http://127.0.0.1:%d/blah/LuciLocalAuthService.GetOAuthToken"
+        % ctx["rpc_port"],
+        data=json.dumps(
+          {
+            "account_id": "acc_1",
+            "scopes": ["A", "B", "C"],
+            "secret": ctx["secret"],
+          }
+        ),
+        headers={"Content-Type": "application/json"},
+      )
       self.assertEqual(404, r.status_code)
 
       # Wrong HTTP method.
       r = requests.get(
-          url='http://127.0.0.1:%d/rpc/LuciLocalAuthService.GetOAuthToken' %
-              ctx['rpc_port'],
-          data=json.dumps({
-            'account_id': 'acc_1',
-            'scopes': ['A', 'B', 'C'],
-            'secret': ctx['secret'],
-          }),
-          headers={'Content-Type': 'application/json'})
+        url="http://127.0.0.1:%d/rpc/LuciLocalAuthService.GetOAuthToken"
+        % ctx["rpc_port"],
+        data=json.dumps(
+          {
+            "account_id": "acc_1",
+            "scopes": ["A", "B", "C"],
+            "secret": ctx["secret"],
+          }
+        ),
+        headers={"Content-Type": "application/json"},
+      )
       self.assertEqual(501, r.status_code)
 
       # Wrong content type.
       r = requests.post(
-          url='http://127.0.0.1:%d/rpc/LuciLocalAuthService.GetOAuthToken' %
-              ctx['rpc_port'],
-          data=json.dumps({
-            'account_id': 'acc_1',
-            'scopes': ['A', 'B', 'C'],
-            'secret': ctx['secret'],
-          }),
-          headers={'Content-Type': 'application/xml'})
+        url="http://127.0.0.1:%d/rpc/LuciLocalAuthService.GetOAuthToken"
+        % ctx["rpc_port"],
+        data=json.dumps(
+          {
+            "account_id": "acc_1",
+            "scopes": ["A", "B", "C"],
+            "secret": ctx["secret"],
+          }
+        ),
+        headers={"Content-Type": "application/xml"},
+      )
       self.assertEqual(400, r.status_code)
 
       # Bad JSON.
       r = requests.post(
-          url='http://127.0.0.1:%d/rpc/LuciLocalAuthService.GetOAuthToken' %
-              ctx['rpc_port'],
-          data='not a json',
-          headers={'Content-Type': 'application/json'})
+        url="http://127.0.0.1:%d/rpc/LuciLocalAuthService.GetOAuthToken"
+        % ctx["rpc_port"],
+        data="not a json",
+        headers={"Content-Type": "application/json"},
+      )
       self.assertEqual(400, r.status_code)
 
   def test_validation(self):
     def token_gen(_account_id, **_kwargs):
-      self.fail('must not be called')
+      self.fail("must not be called")
 
-    with local_auth_server(token_gen, 'acc_1'):
-      ctx = luci_context.read('local_auth')
+    with local_auth_server(token_gen, "acc_1"):
+      ctx = luci_context.read("local_auth")
 
       def must_fail(method, body, err, code):
-        for m in ['GetOAuthToken', 'GetIDToken'] if method == '*' else [method]:
+        for m in ["GetOAuthToken", "GetIDToken"] if method == "*" else [method]:
           r = requests.post(
-              url='http://127.0.0.1:%d/rpc/LuciLocalAuthService.%s' % (
-                  ctx['rpc_port'], m),
-              data=json.dumps(body),
-              headers={'Content-Type': 'application/json'})
+            url="http://127.0.0.1:%d/rpc/LuciLocalAuthService.%s"
+            % (ctx["rpc_port"], m),
+            data=json.dumps(body),
+            headers={"Content-Type": "application/json"},
+          )
           self.assertEqual(code, r.status_code)
           self.assertIn(err, r.text)
 
       cases = [
         # account_id
         (
-          '*',
+          "*",
           {},
           '"account_id" is required',
           400,
         ),
         (
-          '*',
-          {'account_id': 123},
+          "*",
+          {"account_id": 123},
           '"account_id" must be a string',
           400,
         ),
-
         # secret
         (
-          '*',
-          {'account_id': 'acc_1', 'scopes': ['a']},
+          "*",
+          {"account_id": "acc_1", "scopes": ["a"]},
           '"secret" is required',
           400,
         ),
         (
-          '*',
-          {'account_id': 'acc_1', 'scopes': ['a'], 'secret': 123},
+          "*",
+          {"account_id": "acc_1", "scopes": ["a"], "secret": 123},
           '"secret" must be a string',
           400,
         ),
         (
-          '*',
-          {'account_id': 'acc_1', 'scopes': ['a'], 'secret': 'abc'},
+          "*",
+          {"account_id": "acc_1", "scopes": ["a"], "secret": "abc"},
           'Invalid "secret"',
           403,
         ),
-
         # The account is known.
         (
-          '*',
-          {'account_id': 'zzz', 'scopes': ['a'], 'secret': ctx['secret']},
-          'Unrecognized account ID',
+          "*",
+          {"account_id": "zzz", "scopes": ["a"], "secret": ctx["secret"]},
+          "Unrecognized account ID",
           404,
         ),
-
         # scopes
         (
-          'GetOAuthToken',
-          {'account_id': 'acc_1', 'secret': ctx['secret']},
+          "GetOAuthToken",
+          {"account_id": "acc_1", "secret": ctx["secret"]},
           '"scopes" is required',
           400,
         ),
         (
-          'GetOAuthToken',
-          {'account_id': 'acc_1', 'secret': ctx['secret'], 'scopes': []},
+          "GetOAuthToken",
+          {"account_id": "acc_1", "secret": ctx["secret"], "scopes": []},
           '"scopes" is required',
           400,
         ),
         (
-          'GetOAuthToken',
-          {'account_id': 'acc_1', 'secret': ctx['secret'], 'scopes': 'abc'},
+          "GetOAuthToken",
+          {"account_id": "acc_1", "secret": ctx["secret"], "scopes": "abc"},
           '"scopes" must be a list of strings',
           400,
         ),
         (
-          'GetOAuthToken',
-          {'account_id': 'acc_1', 'secret': ctx['secret'], 'scopes': [1]},
+          "GetOAuthToken",
+          {"account_id": "acc_1", "secret": ctx["secret"], "scopes": [1]},
           '"scopes" must be a list of strings',
           400,
         ),
-
         # audience
         (
-          'GetIDToken',
-          {'account_id': 'acc_1', 'secret': ctx['secret']},
+          "GetIDToken",
+          {"account_id": "acc_1", "secret": ctx["secret"]},
           '"audience" is required',
           400,
         ),
         (
-          'GetIDToken',
-          {'account_id': 'acc_1', 'secret': ctx['secret'], 'audience': ''},
+          "GetIDToken",
+          {"account_id": "acc_1", "secret": ctx["secret"], "audience": ""},
           '"audience" is required',
           400,
         ),
         (
-          'GetIDToken',
-          {'account_id': 'acc_1', 'secret': ctx['secret'], 'audience': 123},
+          "GetIDToken",
+          {"account_id": "acc_1", "secret": ctx["secret"], "audience": 123},
           '"audience" must be a string',
           400,
         ),
@@ -381,6 +389,7 @@
 
 class LocalAuthHttpServiceTest(auto_stub.TestCase):
   """Tests for LocalAuthServer and LuciContextAuthenticator."""
+
   epoch = 12345678
 
   def setUp(self):
@@ -388,30 +397,29 @@
     self.mock_time(0)
 
   def mock_time(self, delta):
-    self.mock(time, 'time', lambda: self.epoch + delta)
+    self.mock(time, "time", lambda: self.epoch + delta)
 
   @staticmethod
-  def mocked_http_service(
-      url='http://example.com',
-      perform_request=None):
+  def mocked_http_service(url="http://example.com", perform_request=None):
 
     class MockedRequestEngine:
       def perform_request(self, request):
         return perform_request(request) if perform_request else None
 
     return net.HttpService(
-        url,
-        authenticator=authenticators.LuciContextAuthenticator(),
-        engine=MockedRequestEngine())
+      url,
+      authenticator=authenticators.LuciContextAuthenticator(),
+      engine=MockedRequestEngine(),
+    )
 
   def test_works(self):
-    service_url = 'http://example.com'
-    request_url = '/some_request'
-    response = b'True'
-    token = 'notasecret'
+    service_url = "http://example.com"
+    request_url = "/some_request"
+    response = b"True"
+    token = "notasecret"
 
     def token_gen(account_id, scopes=None, audience=None):
-      self.assertEqual('acc_1', account_id)
+      self.assertEqual("acc_1", account_id)
       self.assertEqual(1, len(scopes))
       self.assertEqual(oauth.OAUTH_SCOPES, scopes[0])
       self.assertIsNone(audience)
@@ -419,42 +427,44 @@
 
     def handle_request(request):
       self.assertTrue(
-          request.get_full_url().startswith(service_url + request_url))
-      self.assertEqual(b'', request.body)
-      self.assertEqual('Bearer %s' % token, request.headers['Authorization'])
+        request.get_full_url().startswith(service_url + request_url)
+      )
+      self.assertEqual(b"", request.body)
+      self.assertEqual("Bearer %s" % token, request.headers["Authorization"])
       return net_utils.make_fake_response(response, request.get_full_url())
 
-    with local_auth_server(token_gen, 'acc_1'):
+    with local_auth_server(token_gen, "acc_1"):
       service = self.mocked_http_service(perform_request=handle_request)
       self.assertEqual(service.request(request_url, data={}).read(), response)
 
   def test_bad_secret(self):
-    service_url = 'http://example.com'
-    request_url = '/some_request'
-    response = b'False'
+    service_url = "http://example.com"
+    request_url = "/some_request"
+    response = b"False"
 
     def token_gen(_account_id, **_kwargs):
-      self.fail('must not be called')
+      self.fail("must not be called")
 
     def handle_request(request):
       self.assertTrue(
-          request.get_full_url().startswith(service_url + request_url))
-      self.assertEqual(b'', request.body)
-      self.assertIsNone(request.headers.get('Authorization'))
+        request.get_full_url().startswith(service_url + request_url)
+      )
+      self.assertEqual(b"", request.body)
+      self.assertIsNone(request.headers.get("Authorization"))
       return net_utils.make_fake_response(response, request.get_full_url())
 
-    with local_auth_server(token_gen, 'acc_1', secret='invalid'):
+    with local_auth_server(token_gen, "acc_1", secret="invalid"):
       service = self.mocked_http_service(perform_request=handle_request)
       self.assertEqual(service.request(request_url, data={}).read(), response)
 
   def test_bad_port(self):
-    request_url = '/some_request'
+    request_url = "/some_request"
 
     def token_gen(_account_id, **_kwargs):
-      self.fail('must not be called')
+      self.fail("must not be called")
 
     def handle_request(_request):
-      self.fail('must not be called')
+      self.fail("must not be called")
 
     # This little dance should pick an unused port, bind it and then close it,
     # trusting that the OS will not reallocate it between now and when the http
@@ -462,22 +472,22 @@
     # picking a static port number, as there's at least some guarantee that the
     # port WASN'T in use before this test ran.
     sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-    sock.bind(('localhost', 0))
+    sock.bind(("localhost", 0))
     port = sock.getsockname()[1]
     sock.close()
-    with local_auth_server(token_gen, 'acc_1', rpc_port=port):
+    with local_auth_server(token_gen, "acc_1", rpc_port=port):
       service = self.mocked_http_service(perform_request=handle_request)
       with self.assertRaises(ConnectionRefusedError):
         self.assertRaises(service.request(request_url, data={}).read())
 
   def test_expired_token(self):
-    service_url = 'http://example.com'
-    request_url = '/some_request'
-    response = b'False'
-    token = 'notasecret'
+    service_url = "http://example.com"
+    request_url = "/some_request"
+    response = b"False"
+    token = "notasecret"
 
     def token_gen(account_id, scopes=None, audience=None):
-      self.assertEqual('acc_1', account_id)
+      self.assertEqual("acc_1", account_id)
       self.assertEqual(1, len(scopes))
       self.assertEqual(oauth.OAUTH_SCOPES, scopes[0])
       self.assertIsNone(audience)
@@ -485,17 +495,18 @@
 
     def handle_request(request):
       self.assertTrue(
-          request.get_full_url().startswith(service_url + request_url))
-      self.assertEqual(b'', request.body)
-      self.assertIsNone(request.headers.get('Authorization'))
+        request.get_full_url().startswith(service_url + request_url)
+      )
+      self.assertEqual(b"", request.body)
+      self.assertIsNone(request.headers.get("Authorization"))
       return net_utils.make_fake_response(response, request.get_full_url())
 
-    with local_auth_server(token_gen, 'acc_1'):
+    with local_auth_server(token_gen, "acc_1"):
       service = self.mocked_http_service(perform_request=handle_request)
       self.assertEqual(service.request(request_url, data={}).read(), response)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
   # Terminate HTTP server in tests 50x faster. Impacts performance though so
   # do it only in tests.
   auth_server._HTTPServer.poll_interval = 0.01
diff --git a/tests/auth_test.py b/tests/auth_test.py
index b99ea45..57e1ffc 100755
--- a/tests/auth_test.py
+++ b/tests/auth_test.py
@@ -13,6 +13,7 @@
 import test_env
 
 from utils import tools
+
 tools.force_local_third_party()
 
 # third_party/
@@ -28,20 +29,23 @@
     class MockLuciContextServer:
       @staticmethod
       def request(uri=None, method=None, body=None, headers=None):
-        self.assertEqual('POST', method)
+        self.assertEqual("POST", method)
         self.assertEqual(
-            'http://127.0.0.1:0/rpc/LuciLocalAuthService.GetOAuthToken', uri)
-        self.assertEqual({'Content-Type': 'application/json'}, headers)
+          "http://127.0.0.1:0/rpc/LuciLocalAuthService.GetOAuthToken", uri
+        )
+        self.assertEqual({"Content-Type": "application/json"}, headers)
         data = json.loads(body)
-        self.assertEqual('secret', data['secret'])
-        self.assertEqual(1, len(data['scopes']))
-        self.assertEqual('acc_a', data['account_id'])
-        self.assertEqual('https://www.googleapis.com/auth/userinfo.email',
-                         data['scopes'][0])
-        response = collections.namedtuple('HttpResponse', ['status'])
+        self.assertEqual("secret", data["secret"])
+        self.assertEqual(1, len(data["scopes"]))
+        self.assertEqual("acc_a", data["account_id"])
+        self.assertEqual(
+          "https://www.googleapis.com/auth/userinfo.email", data["scopes"][0]
+        )
+        response = collections.namedtuple("HttpResponse", ["status"])
         response.status = response_code
         content = json.dumps(token_response)
         return response, content
+
     self.mock_local_auth(MockLuciContextServer())
     yield
 
@@ -52,41 +56,45 @@
   def mock_local_auth(self, server):
     def load_local_auth():
       return oauth.LocalAuthParameters(
-          rpc_port=0,
-          secret='secret',
-          accounts=[oauth.LocalAuthAccount('acc_a')],
-          default_account_id='acc_a')
-    self.mock(oauth, '_load_local_auth', load_local_auth)
+        rpc_port=0,
+        secret="secret",
+        accounts=[oauth.LocalAuthAccount("acc_a")],
+        default_account_id="acc_a",
+      )
+
+    self.mock(oauth, "_load_local_auth", load_local_auth)
+
     def http_server():
       return server
-    self.mock(httplib2, 'Http', http_server)
+
+    self.mock(httplib2, "Http", http_server)
 
   def mock_time(self, delta):
-    self.mock(time, 'time', lambda: delta)
+    self.mock(time, "time", lambda: delta)
 
   def _utc_datetime(self, delta):
     return datetime.datetime.utcfromtimestamp(delta)
 
   def test_get_access_token(self):
     t_expire = 100
-    with self.lucicontext({'access_token': 'notasecret', 'expiry': t_expire}):
+    with self.lucicontext({"access_token": "notasecret", "expiry": t_expire}):
       token = oauth._get_luci_context_access_token(oauth._load_local_auth())
-    self.assertEqual('notasecret', token.token)
+    self.assertEqual("notasecret", token.token)
     self.assertEqual(self._utc_datetime(t_expire), token.expires_at)
 
   def test_get_missing_token(self):
     t_expire = 100
-    with self.lucicontext({'expiry': t_expire}):
+    with self.lucicontext({"expiry": t_expire}):
       token = oauth._get_luci_context_access_token(oauth._load_local_auth())
     self.assertIsNone(token)
 
   def test_get_missing_expiry(self):
-    with self.lucicontext({'access_token': 'notasecret'}):
+    with self.lucicontext({"access_token": "notasecret"}):
       token = oauth._get_luci_context_access_token(oauth._load_local_auth())
     self.assertIsNone(token)
 
   def test_get_access_token_with_errors(self):
-    with self.lucicontext({'error_code': 5, 'error_msg': 'fail'}):
+    with self.lucicontext({"error_code": 5, "error_msg": "fail"}):
       token = oauth._get_luci_context_access_token(oauth._load_local_auth())
     self.assertIsNone(token)
 
@@ -94,29 +102,27 @@
     t_expire = self._utc_datetime(120)
     good_token = oauth.AccessToken("secret", t_expire)
     self.assertEqual(
-        True,
-        oauth._validate_luci_context_access_token(good_token))
+      True, oauth._validate_luci_context_access_token(good_token)
+    )
     no_token = oauth.AccessToken("", t_expire)
+    self.assertEqual(False, oauth._validate_luci_context_access_token(no_token))
+    not_a_token = {"token": "secret", "expires_at": t_expire}
     self.assertEqual(
-        False,
-        oauth._validate_luci_context_access_token(no_token))
-    not_a_token = {'token': "secret", 'expires_at': t_expire}
-    self.assertEqual(
-        False,
-        oauth._validate_luci_context_access_token(not_a_token))
+      False, oauth._validate_luci_context_access_token(not_a_token)
+    )
 
     self.mock_time(50)
 
     self.assertEqual(
-        True,
-        oauth._validate_luci_context_access_token(good_token))
+      True, oauth._validate_luci_context_access_token(good_token)
+    )
 
     self.mock_time(100)
 
     self.assertEqual(
-        False,
-        oauth._validate_luci_context_access_token(good_token))
+      False, oauth._validate_luci_context_access_token(good_token)
+    )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
   test_env.main()
diff --git a/tests/cas_util.py b/tests/cas_util.py
index 2067b5f..10a834f 100644
--- a/tests/cas_util.py
+++ b/tests/cas_util.py
@@ -13,18 +13,17 @@
 import time
 
 
-
 CLIENT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 LUCI_DIR = os.path.dirname(CLIENT_DIR)
-FAKECAS_BIN = os.path.join(LUCI_DIR, 'luci-go', 'fakecas')
-CAS_CLI = os.path.join(LUCI_DIR, 'luci-go', 'cas')
+FAKECAS_BIN = os.path.join(LUCI_DIR, "luci-go", "fakecas")
+CAS_CLI = os.path.join(LUCI_DIR, "luci-go", "cas")
 
 
 def extend(path):
   """Opens a file with extended path on Windows."""
-  if sys.platform != 'win32':
+  if sys.platform != "win32":
     return path
-  prefix = '\\\\?\\'
+  prefix = "\\\\?\\"
   return path if path.startswith(prefix) else prefix + path
 
 
@@ -41,30 +40,31 @@
 
   @property
   def _log_path(self):
-    return os.path.join(self._root, 'cas.log')
+    return os.path.join(self._root, "cas.log")
 
   def start(self):
     if not os.path.exists(self._root):
       os.makedirs(self._root)
-    self._log = open(self._log_path, 'wb')
-    addr_file = os.path.join(self._root, 'addr')
+    self._log = open(self._log_path, "wb")
+    addr_file = os.path.join(self._root, "addr")
     cmd = [
-        FAKECAS_BIN,
-        '-port',
-        '0',
-        '-addr-file',
-        addr_file,
+      FAKECAS_BIN,
+      "-port",
+      "0",
+      "-addr-file",
+      addr_file,
     ]
-    self._proc = subprocess.Popen(cmd,
-                                  stdout=self._log,
-                                  stderr=subprocess.STDOUT)
+    self._proc = subprocess.Popen(
+      cmd, stdout=self._log, stderr=subprocess.STDOUT
+    )
     while not os.path.exists(addr_file):
-      logging.info('Waiting cas to start...')
+      logging.info("Waiting cas to start...")
       time.sleep(0.1)
     with open(addr_file) as f:
       self._addr = f.read()
-    logging.info('Launched cas local at %s, log is %s', self._addr,
-                 self._log_path)
+    logging.info(
+      "Launched cas local at %s, log is %s", self._addr, self._log_path
+    )
 
   def stop(self):
     if self._proc:
@@ -82,7 +82,7 @@
         if not os.path.exists(pdir):
           os.makedirs(pdir)
 
-        with open(extend(path), 'wb') as f:
+        with open(extend(path), "wb") as f:
           f.write(content)
       return self.archive_dir(tmpdir)
     finally:
@@ -92,27 +92,28 @@
     """Uploads directory to the local CAS server"""
     tmpdir = tempfile.mkdtemp()
     try:
-      digest_dump = os.path.join(tmpdir, 'digest')
+      digest_dump = os.path.join(tmpdir, "digest")
       cmd = [
-          CAS_CLI,
-          'archive',
-          '-cas-addr',
-          self.address,
-          '-paths',
-          upload_dir + ':.',
-          '-dump-digest',
-          digest_dump,
-          '-log-level',
-          'debug',
+        CAS_CLI,
+        "archive",
+        "-cas-addr",
+        self.address,
+        "-paths",
+        upload_dir + ":.",
+        "-dump-digest",
+        digest_dump,
+        "-log-level",
+        "debug",
       ]
-      proc = subprocess.Popen(cmd,
-                              stdout=subprocess.PIPE,
-                              stderr=subprocess.STDOUT)
+      proc = subprocess.Popen(
+        cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT
+      )
       out = proc.communicate()[0]
       if proc.returncode:
         raise Exception(
-            'Failed to run cas archive. exit_code=%d, cmd="%s"\n%s' %
-            (proc.returncode, ' '.join(cmd), out.decode('unicode-escape')))
+          'Failed to run cas archive. exit_code=%d, cmd="%s"\n%s'
+          % (proc.returncode, " ".join(cmd), out.decode("unicode-escape"))
+        )
       with open(digest_dump) as f:
         return f.read()
     finally:
@@ -121,28 +122,30 @@
   def download(self, digest, dest):
     """Download directory from the local CAS server"""
     cmd = [
-        CAS_CLI,
-        'download',
-        '-cas-addr',
-        self.address,
-        '-digest',
-        digest,
-        '-dir',
-        dest,
+      CAS_CLI,
+      "download",
+      "-cas-addr",
+      self.address,
+      "-digest",
+      digest,
+      "-dir",
+      dest,
     ]
-    proc = subprocess.Popen(cmd,
-                            stdout=subprocess.PIPE,
-                            stderr=subprocess.STDOUT)
+    proc = subprocess.Popen(
+      cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT
+    )
     out = proc.communicate()[0]
     if proc.returncode:
       raise Exception(
-          'Failed to run cas download. exit_code=%d, cmd="%s"\n%s' %
-          (proc.returncode, ' '.join(cmd), out.decode('unicode-escape')))
+        'Failed to run cas download. exit_code=%d, cmd="%s"\n%s'
+        % (proc.returncode, " ".join(cmd), out.decode("unicode-escape"))
+      )
 
 
 def filter_out_go_logs(output):
-  return '\n'.join(
-      [o for o in output.split('\n') if not re.match('^.* \S+\.go:\d+\]', o)])
+  return "\n".join(
+    [o for o in output.split("\n") if not re.match("^.* \S+\.go:\d+\]", o)]
+  )
 
 
 def cache_hash(contents):
diff --git a/tests/cipdserver_fake.py b/tests/cipdserver_fake.py
index a22188f..8565e30 100644
--- a/tests/cipdserver_fake.py
+++ b/tests/cipdserver_fake.py
@@ -19,41 +19,52 @@
   ### HTTP Methods
 
   def do_GET(self):
-    logging.info('GET %s', self.path)
-    if self.path == '/auth/api/v1/server/oauth_config':
-      self.send_json({
-        'client_id': 'c',
-        'client_not_so_secret': 's',
-        'primary_url': self.server.url})
-    elif self.path.startswith('/_ah/api/repo/v1/instance/resolve?'):
-      self.send_json({
-        'status': 'SUCCESS',
-        'instance_id': 'a' * 40,
-      })
-    elif self.path.startswith('/_ah/api/repo/v1/client?'):
+    logging.info("GET %s", self.path)
+    if self.path == "/auth/api/v1/server/oauth_config":
+      self.send_json(
+        {
+          "client_id": "c",
+          "client_not_so_secret": "s",
+          "primary_url": self.server.url,
+        }
+      )
+    elif self.path.startswith("/_ah/api/repo/v1/instance/resolve?"):
+      self.send_json(
+        {
+          "status": "SUCCESS",
+          "instance_id": "a" * 40,
+        }
+      )
+    elif self.path.startswith("/_ah/api/repo/v1/client?"):
       qs = urllib.parse.parse_qs(urllib.parse.urlparse(self.path).query)
-      pkg_name = qs.get('package_name', [])
+      pkg_name = qs.get("package_name", [])
       if not pkg_name:
-        self.send_json({
-          'status': 'FAILED',
-          'error_message': 'package_name not specified',
-        })
-      if '$' in pkg_name[0]:
-        self.send_json({
-          'status': 'FAILED',
-          'error_message': 'unknown package %r' % pkg_name[0],
-        })
+        self.send_json(
+          {
+            "status": "FAILED",
+            "error_message": "package_name not specified",
+          }
+        )
+      if "$" in pkg_name[0]:
+        self.send_json(
+          {
+            "status": "FAILED",
+            "error_message": "unknown package %r" % pkg_name[0],
+          }
+        )
       else:
-        self.send_json({
-          'status': 'SUCCESS',
-          'client_binary': {
-            'fetch_url': self.server.url + '/fake_google_storage/cipd_client',
-          },
-        })
-    elif self.path == '/fake_google_storage/cipd_client':
+        self.send_json(
+          {
+            "status": "SUCCESS",
+            "client_binary": {
+              "fetch_url": self.server.url + "/fake_google_storage/cipd_client",
+            },
+          }
+        )
+    elif self.path == "/fake_google_storage/cipd_client":
       # The content is not actually used because run_isolated_test.py
       # mocks popen.
-      self.send_octet_stream(b'#!/usr/sh\n')
+      self.send_octet_stream(b"#!/usr/sh\n")
     else:
       raise NotImplementedError(self.path)
 
diff --git a/tests/file_path_test.py b/tests/file_path_test.py
index 78457ff..ddcce6b 100755
--- a/tests/file_path_test.py
+++ b/tests/file_path_test.py
@@ -26,7 +26,7 @@
 
 
 def write_content(filepath, content):
-  with fs.open(filepath, 'wb') as f:
+  with fs.open(filepath, "wb") as f:
     f.write(content)
 
 
@@ -39,7 +39,8 @@
     try:
       if self._tempdir:
         for dirpath, dirnames, filenames in fs.walk(
-            self._tempdir, topdown=True):
+          self._tempdir, topdown=True
+        ):
           for filename in filenames:
             file_path.set_read_only(os.path.join(dirpath, filename), False)
           for dirname in dirnames:
@@ -51,49 +52,48 @@
   @property
   def tempdir(self):
     if not self._tempdir:
-      self._tempdir = tempfile.mkdtemp(prefix='file_path_test')
+      self._tempdir = tempfile.mkdtemp(prefix="file_path_test")
     return self._tempdir
 
   def test_atomic_replace_new_file(self):
-    path = os.path.join(self.tempdir, 'new_file')
-    file_path.atomic_replace(path, b'blah')
-    with open(path, 'rb') as f:
-      self.assertEqual(b'blah', f.read())
-    self.assertEqual(['new_file'], os.listdir(self.tempdir))
+    path = os.path.join(self.tempdir, "new_file")
+    file_path.atomic_replace(path, b"blah")
+    with open(path, "rb") as f:
+      self.assertEqual(b"blah", f.read())
+    self.assertEqual(["new_file"], os.listdir(self.tempdir))
 
   def test_atomic_replace_existing_file(self):
-    path = os.path.join(self.tempdir, 'existing_file')
-    with open(path, 'wb') as f:
-      f.write(b'existing body')
-    file_path.atomic_replace(path, b'new body')
-    with open(path, 'rb') as f:
-      self.assertEqual(b'new body', f.read())
-    self.assertEqual(['existing_file'], os.listdir(self.tempdir))
+    path = os.path.join(self.tempdir, "existing_file")
+    with open(path, "wb") as f:
+      f.write(b"existing body")
+    file_path.atomic_replace(path, b"new body")
+    with open(path, "rb") as f:
+      self.assertEqual(b"new body", f.read())
+    self.assertEqual(["existing_file"], os.listdir(self.tempdir))
 
   def assertFileMode(self, filepath, mode, umask=None):
     umask = test_env.umask() if umask is None else umask
     actual = fs.stat(filepath).st_mode
     expected = mode & ~umask  # pylint: disable=invalid-unary-operand-type
     self.assertEqual(
-        expected,
-        actual,
-        (filepath, oct(expected), oct(actual), oct(umask)))
+      expected, actual, (filepath, oct(expected), oct(actual), oct(umask))
+    )
 
   def assertMaskedFileMode(self, filepath, mode):
     """It's usually when the file was first marked read only."""
-    self.assertFileMode(filepath, mode, 0 if sys.platform == 'win32' else 0o77)
+    self.assertFileMode(filepath, mode, 0 if sys.platform == "win32" else 0o77)
 
   def test_delete_wd_rf(self):
     # Confirms that a RO file in a RW directory can be deleted on non-Windows.
-    dir_foo = os.path.join(self.tempdir, 'foo')
-    file_bar = os.path.join(dir_foo, 'bar')
+    dir_foo = os.path.join(self.tempdir, "foo")
+    file_bar = os.path.join(dir_foo, "bar")
     fs.mkdir(dir_foo, 0o777)
-    write_content(file_bar, b'bar')
+    write_content(file_bar, b"bar")
     file_path.set_read_only(dir_foo, False)
     file_path.set_read_only(file_bar, True)
     self.assertFileMode(dir_foo, 0o40777)
     self.assertMaskedFileMode(file_bar, 0o100444)
-    if sys.platform == 'win32':
+    if sys.platform == "win32":
       # On Windows, a read-only file can't be deleted.
       with self.assertRaises(OSError):
         fs.remove(file_bar)
@@ -102,15 +102,15 @@
 
   def test_delete_rd_wf(self):
     # Confirms that a Rw file in a RO directory can be deleted on Windows only.
-    dir_foo = os.path.join(self.tempdir, 'foo')
-    file_bar = os.path.join(dir_foo, 'bar')
+    dir_foo = os.path.join(self.tempdir, "foo")
+    file_bar = os.path.join(dir_foo, "bar")
     fs.mkdir(dir_foo, 0o777)
-    write_content(file_bar, b'bar')
+    write_content(file_bar, b"bar")
     file_path.set_read_only(dir_foo, True)
     file_path.set_read_only(file_bar, False)
     self.assertMaskedFileMode(dir_foo, 0o40555)
     self.assertFileMode(file_bar, 0o100666)
-    if sys.platform == 'win32':
+    if sys.platform == "win32":
       # A read-only directory has a convoluted meaning on Windows, it means that
       # the directory is "personalized". This is used as a signal by Windows
       # Explorer to tell it to look into the directory for desktop.ini.
@@ -125,10 +125,10 @@
 
   def test_delete_rd_rf(self):
     # Confirms that a RO file in a RO directory can't be deleted.
-    dir_foo = os.path.join(self.tempdir, 'foo')
-    file_bar = os.path.join(dir_foo, 'bar')
+    dir_foo = os.path.join(self.tempdir, "foo")
+    file_bar = os.path.join(dir_foo, "bar")
     fs.mkdir(dir_foo, 0o777)
-    write_content(file_bar, b'bar')
+    write_content(file_bar, b"bar")
     file_path.set_read_only(dir_foo, True)
     file_path.set_read_only(file_bar, True)
     self.assertMaskedFileMode(dir_foo, 0o40555)
@@ -141,11 +141,11 @@
   def test_hard_link_mode(self):
     # Creates a hard link, see if the file mode changed on the node or the
     # directory entry.
-    dir_foo = os.path.join(self.tempdir, 'foo')
-    file_bar = os.path.join(dir_foo, 'bar')
-    file_link = os.path.join(dir_foo, 'link')
+    dir_foo = os.path.join(self.tempdir, "foo")
+    file_bar = os.path.join(dir_foo, "bar")
+    file_link = os.path.join(dir_foo, "link")
     fs.mkdir(dir_foo, 0o777)
-    write_content(file_bar, b'bar')
+    write_content(file_bar, b"bar")
     file_path.hardlink(file_bar, file_link)
     self.assertFileMode(file_bar, 0o100666)
     self.assertFileMode(file_link, 0o100666)
@@ -158,7 +158,7 @@
     # directory entry.
 
   def test_ensure_tree(self):
-    dir_foo = os.path.join(self.tempdir, 'foo')
+    dir_foo = os.path.join(self.tempdir, "foo")
     file_path.ensure_tree(dir_foo, 0o777)
 
     self.assertTrue(os.path.isdir(dir_foo))
@@ -167,21 +167,21 @@
     file_path.ensure_tree(dir_foo, 0o777)
 
   def _make_tree(self):
-    root = os.path.join(self.tempdir, 'root')
-    child_dir = os.path.join(root, 'child')
-    grand_child_dir = os.path.join(child_dir, 'grand_child')
+    root = os.path.join(self.tempdir, "root")
+    child_dir = os.path.join(root, "child")
+    grand_child_dir = os.path.join(child_dir, "grand_child")
     dirs = [root, child_dir, grand_child_dir]
     os.makedirs(grand_child_dir)
     files = [
-        os.path.join(root, 'file1'),
-        os.path.join(child_dir, 'file2'),
-        os.path.join(grand_child_dir, 'file3'),
+      os.path.join(root, "file1"),
+      os.path.join(child_dir, "file2"),
+      os.path.join(grand_child_dir, "file3"),
     ]
     for f in files:
-      open(f, 'w').close()
+      open(f, "w").close()
     return root, dirs, files
 
-  @unittest.skipIf(sys.platform == 'win32', 'posix only')
+  @unittest.skipIf(sys.platform == "win32", "posix only")
   def test_rmtree(self):
     root, dirs, _ = self._make_tree()
 
@@ -196,15 +196,15 @@
     def chmod_mock(path, _mode):
       can_delete.add(path)
 
-    self.mock(fs, 'rmtree', fs_rmtree_mock)
-    if hasattr(os, 'lchmod'):
-      self.mock(fs, 'lchmod', chmod_mock)
+    self.mock(fs, "rmtree", fs_rmtree_mock)
+    if hasattr(os, "lchmod"):
+      self.mock(fs, "lchmod", chmod_mock)
     else:
-      self.mock(fs, 'chmod', chmod_mock)
+      self.mock(fs, "chmod", chmod_mock)
 
     file_path.rmtree(root)
 
-  @unittest.skipIf(sys.platform == 'win32', 'posix only')
+  @unittest.skipIf(sys.platform == "win32", "posix only")
   def test_rmtree_with_sudo_chmod(self):
     root, dirs, _ = self._make_tree()
 
@@ -216,29 +216,31 @@
         if d not in can_delete:
           onerror(None, None, (None, None, None))
 
-    self.mock(fs, 'rmtree', fs_rmtree_mock)
+    self.mock(fs, "rmtree", fs_rmtree_mock)
 
     # pylint: disable=unused-argument
     def subprocess_mock(cmd, stdin=None):
       path = cmd[4]
       can_delete.add(path)
 
-    self.mock(file_path, 'set_read_only_swallow', lambda *_: OSError('error'))
-    self.mock(subprocess42, 'call', subprocess_mock)
+    self.mock(file_path, "set_read_only_swallow", lambda *_: OSError("error"))
+    self.mock(subprocess42, "call", subprocess_mock)
 
     file_path.rmtree(root)
 
   def test_rmtree_unicode(self):
-    subdir = os.path.join(self.tempdir, 'hi')
+    subdir = os.path.join(self.tempdir, "hi")
     fs.mkdir(subdir)
-    filepath = os.path.join(subdir,
-                            '\u0627\u0644\u0635\u064A\u0646\u064A\u0629')
-    with fs.open(filepath, 'wb') as f:
-      f.write(b'hi')
+    filepath = os.path.join(
+      subdir, "\u0627\u0644\u0635\u064a\u0646\u064a\u0629"
+    )
+    with fs.open(filepath, "wb") as f:
+      f.write(b"hi")
     # In particular, it fails when the input argument is a str.
     file_path.rmtree(str(subdir))
 
-  if sys.platform == 'win32':
+  if sys.platform == "win32":
+
     def test_rmtree_win(self):
       root, _, files = self._make_tree()
 
@@ -253,32 +255,33 @@
       def chmod_mock(path, _mode):
         can_delete.add(path)
 
-      self.mock(fs, 'rmtree', fs_rmtree_mock)
-      self.mock(fs, 'chmod', chmod_mock)
+      self.mock(fs, "rmtree", fs_rmtree_mock)
+      self.mock(fs, "chmod", chmod_mock)
 
       file_path.rmtree(root)
 
     def test_rmtree_outliving_processes(self):
       # Mock our sleep for faster test case execution.
       sleeps = []
-      self.mock(time, 'sleep', sleeps.append)
-      self.mock(sys, 'stderr', io.StringIO())
+      self.mock(time, "sleep", sleeps.append)
+      self.mock(sys, "stderr", io.StringIO())
 
       # Open a child process, so the file is locked.
-      subdir = os.path.join(self.tempdir, 'to_be_deleted')
+      subdir = os.path.join(self.tempdir, "to_be_deleted")
       fs.mkdir(subdir)
-      script = 'import time; open(\'a\', \'w\'); time.sleep(60)'
-      proc = subprocess.Popen([sys.executable, '-c', script], cwd=subdir)
+      script = "import time; open('a', 'w'); time.sleep(60)"
+      proc = subprocess.Popen([sys.executable, "-c", script], cwd=subdir)
       try:
         # Wait until the file exist.
-        while not fs.isfile(os.path.join(subdir, 'a')):
+        while not fs.isfile(os.path.join(subdir, "a")):
           self.assertEqual(None, proc.poll())
         file_path.rmtree(subdir)
         # rmtree will first try to change the tree permission and sleep for
         # 4, 6, 8, and 10 seconds for tries 2 through 5 on Windows, max_tries=6
         # The last 2 seconds is for kill_children_processes.
-        expected_sleeps = [4, 6, 8, 10, 2
-                           ] if sys.platform == 'win32' else [4, 6, 2]
+        expected_sleeps = (
+          [4, 6, 8, 10, 2] if sys.platform == "win32" else [4, 6, 2]
+        )
         self.assertEqual(expected_sleeps, sleeps)
         # sys.stderr.getvalue() would return a fair amount of output but it is
         # not completely deterministic so we're not testing it here.
@@ -288,43 +291,48 @@
     def test_filter_processes_dir_win(self):
       python_dir = os.path.dirname(sys.executable)
       processes = file_path._filter_processes_dir_win(
-          file_path._enum_processes_win(), python_dir)
+        file_path._enum_processes_win(), python_dir
+      )
       self.assertTrue(processes)
       proc_names = [proc.ExecutablePath for proc in processes]
       # Try to find at least one python process.
       self.assertTrue(
-          any(proc == sys.executable for proc in proc_names), proc_names)
+        any(proc == sys.executable for proc in proc_names), proc_names
+      )
 
     def test_filter_processes_tree_win(self):
       # Create a grand-child.
       script = (
-        'import subprocess,sys;'
-        'proc = subprocess.Popen('
-          '[sys.executable, \'-u\', \'-c\', \'import time; print(1); '
-          'time.sleep(60)\'], stdout=subprocess.PIPE); '
+        "import subprocess,sys;"
+        "proc = subprocess.Popen("
+        "[sys.executable, '-u', '-c', 'import time; print(1); "
+        "time.sleep(60)'], stdout=subprocess.PIPE); "
         # Signal grand child is ready.
-        'print(proc.stdout.read(1)); '
+        "print(proc.stdout.read(1)); "
         # Wait for parent to have completed the test.
-        'sys.stdin.read(1); '
-        'proc.kill()'
+        "sys.stdin.read(1); "
+        "proc.kill()"
       )
       proc = subprocess.Popen(
-          [sys.executable, '-u', '-c', script],
-          stdin=subprocess.PIPE,
-          stdout=subprocess.PIPE)
+        [sys.executable, "-u", "-c", script],
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+      )
       try:
         proc.stdout.read(1)
         processes = file_path.filter_processes_tree_win(
-            file_path._enum_processes_win())
+          file_path._enum_processes_win()
+        )
         self.assertEqual(3, len(processes), processes)
-        proc.stdin.write('a')
+        proc.stdin.write("a")
         proc.wait()
       except Exception:
         proc.kill()
       finally:
         proc.wait()
 
-  if sys.platform != 'win32':
+  if sys.platform != "win32":
+
     def test_symlink(self):
       # This test will fail if the checkout is in a symlink.
       actual = file_path.split_at_symlink(None, test_env.CLIENT_DIR)
@@ -332,50 +340,58 @@
       self.assertEqual(expected, actual)
 
       actual = file_path.split_at_symlink(
-          None, os.path.join(test_env.TESTS_DIR, 'trace_inputs'))
-      expected = (os.path.join(test_env.TESTS_DIR, 'trace_inputs'), None, None)
+        None, os.path.join(test_env.TESTS_DIR, "trace_inputs")
+      )
+      expected = (os.path.join(test_env.TESTS_DIR, "trace_inputs"), None, None)
       self.assertEqual(expected, actual)
 
       actual = file_path.split_at_symlink(
-          None, os.path.join(test_env.TESTS_DIR, 'trace_inputs', 'files2'))
+        None, os.path.join(test_env.TESTS_DIR, "trace_inputs", "files2")
+      )
       expected = (
-          os.path.join(test_env.TESTS_DIR, 'trace_inputs'), 'files2', '')
+        os.path.join(test_env.TESTS_DIR, "trace_inputs"),
+        "files2",
+        "",
+      )
       self.assertEqual(expected, actual)
 
       actual = file_path.split_at_symlink(
-          test_env.CLIENT_DIR, os.path.join('tests', 'trace_inputs', 'files2'))
-      expected = (
-          os.path.join('tests', 'trace_inputs'), 'files2', '')
+        test_env.CLIENT_DIR, os.path.join("tests", "trace_inputs", "files2")
+      )
+      expected = (os.path.join("tests", "trace_inputs"), "files2", "")
       self.assertEqual(expected, actual)
       actual = file_path.split_at_symlink(
-          test_env.CLIENT_DIR,
-          os.path.join('tests', 'trace_inputs', 'files2', 'bar'))
-      expected = (os.path.join('tests', 'trace_inputs'), 'files2', '/bar')
+        test_env.CLIENT_DIR,
+        os.path.join("tests", "trace_inputs", "files2", "bar"),
+      )
+      expected = (os.path.join("tests", "trace_inputs"), "files2", "/bar")
       self.assertEqual(expected, actual)
 
   else:
 
     def test_undeleteable_chmod(self):
       # Create a file and a directory with an empty ACL. Then try to delete it.
-      dirpath = os.path.join(self.tempdir, 'd')
-      filepath = os.path.join(dirpath, 'f')
+      dirpath = os.path.join(self.tempdir, "d")
+      filepath = os.path.join(dirpath, "f")
       os.mkdir(dirpath)
-      with open(filepath, 'w') as f:
-        f.write('hi')
+      with open(filepath, "w") as f:
+        f.write("hi")
       os.chmod(filepath, 0)
       os.chmod(dirpath, 0)
       file_path.rmtree(dirpath)
 
     def test_undeleteable_owner(self):
       # Create a file and a directory with an empty ACL. Then try to delete it.
-      dirpath = os.path.join(self.tempdir, 'd')
-      filepath = os.path.join(dirpath, 'f')
+      dirpath = os.path.join(self.tempdir, "d")
+      filepath = os.path.join(dirpath, "f")
       os.mkdir(dirpath)
-      with open(filepath, 'w') as f:
-        f.write('hi')
+      with open(filepath, "w") as f:
+        f.write("hi")
       import win32security
+
       user, _domain, _type = win32security.LookupAccountName(
-          '', getpass.getuser())
+        "", getpass.getuser()
+      )
       sd = win32security.SECURITY_DESCRIPTOR()
       sd.Initialize()
       sd.SetSecurityDescriptorOwner(user, False)
@@ -384,62 +400,73 @@
       dacl.Initialize()
       sd.SetSecurityDescriptorDacl(1, dacl, 0)
       win32security.SetFileSecurity(
-          fs.extend(filepath), win32security.DACL_SECURITY_INFORMATION, sd)
+        fs.extend(filepath), win32security.DACL_SECURITY_INFORMATION, sd
+      )
       win32security.SetFileSecurity(
-          fs.extend(dirpath), win32security.DACL_SECURITY_INFORMATION, sd)
+        fs.extend(dirpath), win32security.DACL_SECURITY_INFORMATION, sd
+      )
       file_path.rmtree(dirpath)
 
-  def _check_get_recursive_size(self, symlink='symlink'):
+  def _check_get_recursive_size(self, symlink="symlink"):
     # Test that _get_recursive_size calculates file size recursively.
-    with open(os.path.join(self.tempdir, '1'), 'w') as f:
-      f.write('0')
+    with open(os.path.join(self.tempdir, "1"), "w") as f:
+      f.write("0")
     self.assertEqual(file_path.get_recursive_size(self.tempdir), 1)
 
-    with open(os.path.join(self.tempdir, '2'), 'w') as f:
-      f.write('01')
+    with open(os.path.join(self.tempdir, "2"), "w") as f:
+      f.write("01")
     self.assertEqual(file_path.get_recursive_size(self.tempdir), 3)
 
-    nested_dir = os.path.join(self.tempdir, 'dir1', 'dir2')
+    nested_dir = os.path.join(self.tempdir, "dir1", "dir2")
     os.makedirs(nested_dir)
-    with open(os.path.join(nested_dir, '4'), 'w') as f:
-      f.write('0123')
+    with open(os.path.join(nested_dir, "4"), "w") as f:
+      f.write("0123")
     self.assertEqual(file_path.get_recursive_size(self.tempdir), 7)
 
     # Add an unreadable directory.
-    secure_dir = os.path.join(self.tempdir, 'dir_secure')
+    secure_dir = os.path.join(self.tempdir, "dir_secure")
     os.makedirs(secure_dir, mode=0o000)
     self.assertEqual(file_path.get_recursive_size(self.tempdir), 7)
 
-    symlink_dir = os.path.join(self.tempdir, 'symlink_dir')
-    symlink_file = os.path.join(self.tempdir, 'symlink_file')
-    if symlink == 'symlink':
-
-      if sys.platform == 'win32':
-        subprocess.check_call('cmd /c mklink /d %s %s' %
-                              (symlink_dir, nested_dir))
-        subprocess.check_call('cmd /c mklink %s %s' %
-                              (symlink_file, os.path.join(self.tempdir, '1')))
+    symlink_dir = os.path.join(self.tempdir, "symlink_dir")
+    symlink_file = os.path.join(self.tempdir, "symlink_file")
+    if symlink == "symlink":
+      if sys.platform == "win32":
+        subprocess.check_call(
+          "cmd /c mklink /d %s %s" % (symlink_dir, nested_dir)
+        )
+        subprocess.check_call(
+          "cmd /c mklink %s %s"
+          % (symlink_file, os.path.join(self.tempdir, "1"))
+        )
       else:
         os.symlink(nested_dir, symlink_dir)
-        os.symlink(os.path.join(self.tempdir, '1'), symlink_file)
+        os.symlink(os.path.join(self.tempdir, "1"), symlink_file)
 
-    elif symlink == 'junction':
+    elif symlink == "junction":
       # junction should be ignored.
-      subprocess.check_call('cmd /c mklink /j %s %s' %
-                            (symlink_dir, nested_dir))
+      subprocess.check_call(
+        "cmd /c mklink /j %s %s" % (symlink_dir, nested_dir)
+      )
 
       # This is invalid junction, junction can be made only for directory.
-      subprocess.check_call('cmd /c mklink /j %s %s' %
-                            (symlink_file, os.path.join(self.tempdir, '1')))
-    elif symlink == 'hardlink':
+      subprocess.check_call(
+        "cmd /c mklink /j %s %s"
+        % (symlink_file, os.path.join(self.tempdir, "1"))
+      )
+    elif symlink == "hardlink":
       # hardlink can be made only for file.
-      subprocess.check_call('cmd /c mklink /h %s %s' %
-                            (symlink_file, os.path.join(self.tempdir, '1')))
+      subprocess.check_call(
+        "cmd /c mklink /h %s %s"
+        % (symlink_file, os.path.join(self.tempdir, "1"))
+      )
     else:
-      assert False, ("symlink should be one of symlink, "
-                     "junction or hardlink, but: %s" % symlink)
+      assert False, (
+        "symlink should be one of symlink, "
+        "junction or hardlink, but: %s" % symlink
+      )
 
-    if symlink == 'hardlink':
+    if symlink == "hardlink":
       # hardlinked file is double counted.
       self.assertEqual(file_path.get_recursive_size(self.tempdir), 8)
     else:
@@ -449,23 +476,41 @@
   def test_get_recursive_size(self):
     self._check_get_recursive_size()
 
-  @unittest.skipUnless(sys.platform == 'win32', 'Windows specific')
+  @unittest.skipUnless(sys.platform == "win32", "Windows specific")
   def test_get_recursive_size_win_junction(self):
-    self._check_get_recursive_size(symlink='junction')
+    self._check_get_recursive_size(symlink="junction")
 
-  @unittest.skipUnless(sys.platform == 'win32', 'Windows specific')
+  @unittest.skipUnless(sys.platform == "win32", "Windows specific")
   def test_get_recursive_size_win_hardlink(self):
-    self._check_get_recursive_size(symlink='hardlink')
+    self._check_get_recursive_size(symlink="hardlink")
 
-  @unittest.skipUnless(sys.platform == 'win32', 'Windows specific')
+  @unittest.skipUnless(sys.platform == "win32", "Windows specific")
   def test_scan_large_directory(self):
     path_fragment = "woof" * 50
     # self.tempdir doesn't end with a \.
-    parent_dir = (self.tempdir + "\\" + path_fragment + "\\" + path_fragment +
-                  "\\" + path_fragment + "\\" + path_fragment + "\\" +
-                  path_fragment + "\\" + path_fragment + "\\" + path_fragment +
-                  "\\" + path_fragment + "\\" + path_fragment + "\\" +
-                  path_fragment)
+    parent_dir = (
+      self.tempdir
+      + "\\"
+      + path_fragment
+      + "\\"
+      + path_fragment
+      + "\\"
+      + path_fragment
+      + "\\"
+      + path_fragment
+      + "\\"
+      + path_fragment
+      + "\\"
+      + path_fragment
+      + "\\"
+      + path_fragment
+      + "\\"
+      + path_fragment
+      + "\\"
+      + path_fragment
+      + "\\"
+      + path_fragment
+    )
     child_dir = f"{parent_dir}\\{path_fragment}"
     grandchild = f"{parent_dir}\\{path_fragment}\\{path_fragment}.txt"
     # Write a file in a temporary temporary directory
@@ -475,9 +520,10 @@
     os.makedirs(fs.extend(child_dir), exist_ok=True)
     shutil.move(self.tempdir + "\\" + "a.txt", fs.extend(grandchild))
     # See if this raises an exception
-    self.assertEqual(file_path._get_recur_size_with_scandir(parent_dir),
-                     (1, 1, 1, 0, 0))
+    self.assertEqual(
+      file_path._get_recur_size_with_scandir(parent_dir), (1, 1, 1, 0, 0)
+    )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
   test_env.main()
diff --git a/tests/fs_test.py b/tests/fs_test.py
index 897436c..01e2a4b 100755
--- a/tests/fs_test.py
+++ b/tests/fs_test.py
@@ -17,7 +17,7 @@
 
 
 def write_content(path, content):
-  with fs.open(path, 'wb') as f:
+  with fs.open(path, "wb") as f:
     f.write(content)
 
 
@@ -25,7 +25,7 @@
   @classmethod
   def setUpClass(cls):
     if not file_path.enable_symlink():
-      raise Exception('Failed to enable symlink support')
+      raise Exception("Failed to enable symlink support")
 
   def setUp(self):
     super(FSTest, self).setUp()
@@ -41,7 +41,7 @@
   @property
   def tempdir(self):
     if not self._tempdir:
-      self._tempdir = tempfile.mkdtemp(prefix='fs_test')
+      self._tempdir = tempfile.mkdtemp(prefix="fs_test")
     return self._tempdir
 
   def test_symlink_relative(self):
@@ -50,30 +50,30 @@
     # /dir/file
     # /ld -> /dir
     # /lf -> /ld/file
-    dirpath = os.path.join(self.tempdir, 'dir')
-    filepath = os.path.join(dirpath, 'file')
+    dirpath = os.path.join(self.tempdir, "dir")
+    filepath = os.path.join(dirpath, "file")
     fs.mkdir(dirpath)
-    write_content(filepath, b'hello')
+    write_content(filepath, b"hello")
 
-    linkfile = os.path.join(self.tempdir, 'lf')
-    linkdir = os.path.join(self.tempdir, 'ld')
-    dstfile = os.path.join('ld', 'file')
+    linkfile = os.path.join(self.tempdir, "lf")
+    linkdir = os.path.join(self.tempdir, "ld")
+    dstfile = os.path.join("ld", "file")
     fs.symlink(dstfile, linkfile)
-    fs.symlink('dir', linkdir)
+    fs.symlink("dir", linkdir)
 
     self.assertEqual(True, fs.islink(linkfile))
     self.assertEqual(True, fs.islink(linkdir))
     self.assertEqual(dstfile, fs.readlink(linkfile))
-    self.assertEqual('dir', fs.readlink(linkdir))
-    self.assertEqual(['file'], fs.listdir(linkdir))
+    self.assertEqual("dir", fs.readlink(linkdir))
+    self.assertEqual(["file"], fs.listdir(linkdir))
     # /lf resolves to /dir/file.
     with fs.open(linkfile) as f:
-      self.assertEqual('hello', f.read())
+      self.assertEqual("hello", f.read())
 
     # Ensures that followlinks is respected in walk().
     expected = [
-      (self.tempdir, ['dir', 'ld'], ['lf']),
-      (dirpath, [], ['file']),
+      (self.tempdir, ["dir", "ld"], ["lf"]),
+      (dirpath, [], ["file"]),
     ]
     actual = [
       (r, sorted(d), sorted(f))
@@ -81,9 +81,9 @@
     ]
     self.assertEqual(expected, actual)
     expected = [
-      (self.tempdir, ['dir', 'ld'], ['lf']),
-      (dirpath, [], ['file']),
-      (linkdir, [], ['file']),
+      (self.tempdir, ["dir", "ld"], ["lf"]),
+      (dirpath, [], ["file"]),
+      (linkdir, [], ["file"]),
     ]
     actual = [
       (r, sorted(d), sorted(f))
@@ -97,14 +97,14 @@
     # /dir/file
     # /ld -> /dir
     # /lf -> /ld/file
-    dirpath = os.path.join(self.tempdir, 'dir')
-    filepath = os.path.join(dirpath, 'file')
+    dirpath = os.path.join(self.tempdir, "dir")
+    filepath = os.path.join(dirpath, "file")
     fs.mkdir(dirpath)
-    write_content(filepath, b'hello')
+    write_content(filepath, b"hello")
 
-    linkfile = os.path.join(self.tempdir, 'lf')
-    linkdir = os.path.join(self.tempdir, 'ld')
-    dstfile = os.path.join(linkdir, 'file')
+    linkfile = os.path.join(self.tempdir, "lf")
+    linkdir = os.path.join(self.tempdir, "ld")
+    dstfile = os.path.join(linkdir, "file")
     fs.symlink(dstfile, linkfile)
     fs.symlink(dirpath, linkdir)
 
@@ -112,15 +112,15 @@
     self.assertEqual(True, fs.islink(linkdir))
     self.assertEqual(dstfile, fs.readlink(linkfile))
     self.assertEqual(dirpath, fs.readlink(linkdir))
-    self.assertEqual(['file'], fs.listdir(linkdir))
+    self.assertEqual(["file"], fs.listdir(linkdir))
     # /lf resolves to /dir/file.
     with fs.open(linkfile) as f:
-      self.assertEqual('hello', f.read())
+      self.assertEqual("hello", f.read())
 
     # Ensures that followlinks is respected in walk().
     expected = [
-      (self.tempdir, ['dir', 'ld'], ['lf']),
-      (dirpath, [], ['file']),
+      (self.tempdir, ["dir", "ld"], ["lf"]),
+      (dirpath, [], ["file"]),
     ]
     actual = [
       (r, sorted(d), sorted(f))
@@ -128,9 +128,9 @@
     ]
     self.assertEqual(expected, actual)
     expected = [
-      (self.tempdir, ['dir', 'ld'], ['lf']),
-      (dirpath, [], ['file']),
-      (linkdir, [], ['file']),
+      (self.tempdir, ["dir", "ld"], ["lf"]),
+      (dirpath, [], ["file"]),
+      (linkdir, [], ["file"]),
     ]
     actual = [
       (r, sorted(d), sorted(f))
@@ -140,8 +140,8 @@
 
   def test_symlink_missing_destination_rel(self):
     # A symlink to a missing destination is valid and can be read back.
-    filepath = 'file'
-    linkfile = os.path.join(self.tempdir, 'lf')
+    filepath = "file"
+    linkfile = os.path.join(self.tempdir, "lf")
     fs.symlink(filepath, linkfile)
 
     self.assertEqual(True, fs.islink(linkfile))
@@ -149,8 +149,8 @@
 
   def test_symlink_missing_destination_abs(self):
     # A symlink to a missing destination is valid and can be read back.
-    filepath = os.path.join(self.tempdir, 'file')
-    linkfile = os.path.join(self.tempdir, 'lf')
+    filepath = os.path.join(self.tempdir, "file")
+    linkfile = os.path.join(self.tempdir, "lf")
     fs.symlink(filepath, linkfile)
 
     self.assertEqual(True, fs.islink(linkfile))
@@ -158,9 +158,9 @@
 
   def test_symlink_existing(self):
     # Creating a symlink that overrides a file fails.
-    filepath = os.path.join(self.tempdir, 'file')
-    linkfile = os.path.join(self.tempdir, 'lf')
-    write_content(linkfile, b'hello')
+    filepath = os.path.join(self.tempdir, "file")
+    linkfile = os.path.join(self.tempdir, "lf")
+    write_content(linkfile, b"hello")
     with self.assertRaises(OSError):
       fs.symlink(filepath, linkfile)
 
@@ -168,14 +168,14 @@
     # Reading a non-existing symlink fails. Obvious but it's to make sure the
     # Windows part acts the same.
     with self.assertRaises(OSError):
-      fs.readlink(os.path.join(self.tempdir, 'not_there'))
+      fs.readlink(os.path.join(self.tempdir, "not_there"))
 
   def test_remove_invalid_symlink(self):
-    src = os.path.join(self.tempdir, 'src')
-    dst = os.path.join(self.tempdir, 'dst')
+    src = os.path.join(self.tempdir, "src")
+    dst = os.path.join(self.tempdir, "dst")
     os.symlink(src, dst)  # This is invalid symlink.
     fs.remove(dst)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
   test_env.main()
diff --git a/tests/httpserver.py b/tests/httpserver.py
index 3e68e3a..6904527 100644
--- a/tests/httpserver.py
+++ b/tests/httpserver.py
@@ -9,7 +9,7 @@
 from six.moves import BaseHTTPServer
 from six.moves import http_client
 
-_STOP_EVENT = '/fakeserver/__stop__'
+_STOP_EVENT = "/fakeserver/__stop__"
 
 
 class Handler(BaseHTTPServer.BaseHTTPRequestHandler):
@@ -20,14 +20,14 @@
   def send_json(self, data):
     """Sends a JSON response."""
     self.send_response(200)
-    self.send_header('Content-type', 'application/json')
+    self.send_header("Content-type", "application/json")
     self.end_headers()
     self.wfile.write(json.dumps(data).encode())
 
   def send_octet_stream(self, data, headers=None):
     """Sends a binary response."""
     self.send_response(200)
-    self.send_header('Content-type', 'application/octet-stream')
+    self.send_header("Content-type", "application/octet-stream")
     for key, value in (headers or {}).items():
       self.send_header(key, value)
     self.end_headers()
@@ -35,11 +35,11 @@
 
   def read_body(self):
     """Reads the request body."""
-    return self.rfile.read(int(self.headers['Content-Length']))
+    return self.rfile.read(int(self.headers["Content-Length"]))
 
   def yield_body(self):
     """Yields the request body as 4kiB chunks."""
-    size = int(self.headers['Content-Length'])
+    size = int(self.headers["Content-Length"])
     while size:
       chunk = min(4096, size)
       yield self.rfile.read(chunk)
@@ -50,16 +50,20 @@
   def do_OPTIONS(self):
     if self.path == _STOP_EVENT:
       self.server.parent._stopped = True
-    self.send_octet_stream(b'')
+    self.send_octet_stream(b"")
 
   def log_message(self, fmt, *args):
     logging.info(
-        '%s - - [%s] %s', self.address_string(), self.log_date_time_string(),
-        fmt % args)
+      "%s - - [%s] %s",
+      self.address_string(),
+      self.log_date_time_string(),
+      fmt % args,
+    )
 
 
 class Server:
   """Server implements a simple HTTP server to implement a fake."""
+
   _HANDLER_CLS = None
 
   def __init__(self):
@@ -67,14 +71,16 @@
     self._closed = False
     self._stopped = False
     self._server = BaseHTTPServer.HTTPServer(
-        ('127.0.0.1', 0), self._HANDLER_CLS)
+      ("127.0.0.1", 0), self._HANDLER_CLS
+    )
     self._server.parent = self
-    self._server.url = self.url = 'http://127.0.0.1:%d' % (
-        self._server.server_port)
-    self._thread = threading.Thread(target=self._run, name='httpd')
+    self._server.url = self.url = "http://127.0.0.1:%d" % (
+      self._server.server_port
+    )
+    self._thread = threading.Thread(target=self._run, name="httpd")
     self._thread.daemon = True
     self._thread.start()
-    logging.info('%s', self.url)
+    logging.info("%s", self.url)
 
   def close(self):
     assert not self._closed
@@ -89,9 +95,10 @@
 
   def _send_event(self, path):
     conn = http_client.HTTPConnection(
-        '127.0.0.1:%d' % self._server.server_port, timeout=60)
+      "127.0.0.1:%d" % self._server.server_port, timeout=60
+    )
     try:
-      conn.request('OPTIONS', path)
+      conn.request("OPTIONS", path)
       conn.getresponse()
     finally:
       conn.close()
diff --git a/tests/large_test.py b/tests/large_test.py
index 326b02e..9faf850 100755
--- a/tests/large_test.py
+++ b/tests/large_test.py
@@ -34,9 +34,9 @@
     self.assertEqual(array, large.unpack(data))
 
   def test_empty(self):
-    self.assertEqual(b'', large.pack([]))
-    self.assertEqual([], large.unpack(b''))
+    self.assertEqual(b"", large.pack([]))
+    self.assertEqual([], large.unpack(b""))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
   test_env.main()
diff --git a/tests/local_caching_test.py b/tests/local_caching_test.py
index 4627480..fd4d68e 100755
--- a/tests/local_caching_test.py
+++ b/tests/local_caching_test.py
@@ -27,12 +27,12 @@
 
 
 def write_file(path, contents):
-  with fs.open(path, 'wb') as f:
+  with fs.open(path, "wb") as f:
     f.write(contents)
 
 
 def read_file(path):
-  with fs.open(path, 'rb') as f:
+  with fs.open(path, "rb") as f:
     return f.read()
 
 
@@ -55,21 +55,22 @@
 class TestCase(auto_stub.TestCase):
   def setUp(self):
     super(TestCase, self).setUp()
-    self.tempdir = tempfile.mkdtemp(prefix='local_caching')
+    self.tempdir = tempfile.mkdtemp(prefix="local_caching")
     self._algo = hashlib.sha256
     # Time mocking.
     self._now = 1000
-    self.mock(time, 'time', lambda: float(self._now))
+    self.mock(time, "time", lambda: float(self._now))
 
     # Free disk space mocking.
     self._free_disk = 1000
-    self.mock(file_path, 'get_free_space', lambda _: self._free_disk)
+    self.mock(file_path, "get_free_space", lambda _: self._free_disk)
 
     # Named cache works with directories.
     def rmtree(p):
       self._free_disk += file_path.get_recursive_size(p)
       return old_rmtree(p)
-    old_rmtree = self.mock(file_path, 'rmtree', rmtree)
+
+    old_rmtree = self.mock(file_path, "rmtree", rmtree)
 
     # Isolated cache works with files.
     def try_remove(p):
@@ -78,7 +79,8 @@
       except OSError:
         pass
       return old_try_remove(p)
-    old_try_remove = self.mock(file_path, 'try_remove', try_remove)
+
+    old_try_remove = self.mock(file_path, "try_remove", try_remove)
 
   def tearDown(self):
     try:
@@ -87,8 +89,7 @@
       super(TestCase, self).tearDown()
 
   def _add_one_item(self, cache, size):
-    """Adds one item of |size| bytes in the cache and returns the created name.
-    """
+    """Adds one item of |size| bytes in the cache and returns the created name."""
     # Don't allow 0 byte items here. This doesn't work for named cache.
     self.assertTrue(size)
     data = _gen_data(size)
@@ -98,32 +99,35 @@
       return cache.write(self._algo(data).hexdigest(), [data])
     if isinstance(cache, local_caching.NamedCache):
       # In this case, map a named cache, add a file, unmap it.
-      dest_dir = os.path.join(self.tempdir, 'dest')
+      dest_dir = os.path.join(self.tempdir, "dest")
       self.assertFalse(fs.exists(dest_dir))
       name = str(size)
       cache.install(dest_dir, name)
       # Put a file in there named 'hello', otherwise it'll stay empty.
-      with fs.open(os.path.join(dest_dir, 'hello'), 'wb') as f:
+      with fs.open(os.path.join(dest_dir, "hello"), "wb") as f:
         f.write(data)
       cache.uninstall(dest_dir, name)
       self.assertFalse(fs.exists(dest_dir))
       return name
-    self.fail('Unexpected cache type %r' % cache)
+    self.fail("Unexpected cache type %r" % cache)
     return None
 
 
 def _get_policies(
-    max_cache_size=0, min_free_space=0, max_items=0, max_age_secs=0):
+  max_cache_size=0, min_free_space=0, max_items=0, max_age_secs=0
+):
   """Returns a CachePolicies with only the policy we want to enforce."""
   return local_caching.CachePolicies(
-      max_cache_size=max_cache_size,
-      min_free_space=min_free_space,
-      max_items=max_items,
-      max_age_secs=max_age_secs)
+    max_cache_size=max_cache_size,
+    min_free_space=min_free_space,
+    max_items=max_items,
+    max_age_secs=max_age_secs,
+  )
 
 
 class CacheTestMixin:
   """Adds testing for the Cache interface."""
+
   # pylint: disable=no-member
 
   def get_cache(self, policies):
@@ -131,9 +135,9 @@
 
   def test_contains(self):
     cache = self.get_cache(_get_policies())
-    self.assertFalse('foo' in cache)
+    self.assertFalse("foo" in cache)
     name = self._add_one_item(cache, 1)
-    self.assertFalse('foo' in cache)
+    self.assertFalse("foo" in cache)
     self.assertTrue(name in cache)
 
   def test_iter(self):
@@ -209,6 +213,7 @@
 
 class ContentAddressedCacheTestMixin(CacheTestMixin):
   """Add testing for the ContentAddressedCache interface."""
+
   # pylint: disable=abstract-method
   _now = 0
 
@@ -232,12 +237,12 @@
     cache = self.get_cache(_get_policies())
     h = self._add_one_item(cache, 1)
     with cache.getfileobj(h) as f:
-      self.assertEqual(b'0', f.read())
+      self.assertEqual(b"0", f.read())
 
   def test_getfileobj_complete_miss(self):
     cache = self.get_cache(_get_policies())
     with self.assertRaises(local_caching.CacheMiss):
-      cache.getfileobj('0'*40)
+      cache.getfileobj("0" * 40)
 
   def test_getfileobj_cache_state_missing(self):
     # Put the file in the cache, but do NOT save cache state.
@@ -267,11 +272,12 @@
     self.assertEqual(True, file_path.enable_symlink())
 
   def cache_dir(self):
-    return os.path.join(self.tempdir, 'cache')
+    return os.path.join(self.tempdir, "cache")
 
   def get_cache(self, policies):
     return local_caching.DiskContentAddressedCache(
-        self.cache_dir(), policies, trim=True)
+      self.cache_dir(), policies, trim=True
+    )
 
   def test_write_policies_free_disk(self):
     cache = self.get_cache(_get_policies(min_free_space=1000))
@@ -305,28 +311,33 @@
     # Mapping more content than the amount of free disk required.
     with self.assertRaises(local_caching.NoMoreSpace) as cm:
       self._add_one_item(cache, 1)
-    expected = ('Not enough space to fetch the whole isolated tree.\n '
-                'CachePolicies(max_cache_size=0 (0.000 GiB); max_items=0; '
-                'min_free_space=1000 (0.000 GiB); max_age_secs=0)\n  '
-                'cache=6 bytes (0.000 GiB), 3 items; '
-                '999 bytes (0.000 GiB) free_space')
+    expected = (
+      "Not enough space to fetch the whole isolated tree.\n "
+      "CachePolicies(max_cache_size=0 (0.000 GiB); max_items=0; "
+      "min_free_space=1000 (0.000 GiB); max_age_secs=0)\n  "
+      "cache=6 bytes (0.000 GiB), 3 items; "
+      "999 bytes (0.000 GiB) free_space"
+    )
 
     self.assertEqual(expected, str(cm.exception))
 
   def test_save_disk(self):
     cache = self.get_cache(_get_policies())
     self.assertEqual(
-        sorted([cache.STATE_FILE]), sorted(fs.listdir(cache.cache_dir)))
+      sorted([cache.STATE_FILE]), sorted(fs.listdir(cache.cache_dir))
+    )
 
     h = self._add_one_item(cache, 2)
     self.assertEqual(
-        sorted([h, cache.STATE_FILE]), sorted(fs.listdir(cache.cache_dir)))
+      sorted([h, cache.STATE_FILE]), sorted(fs.listdir(cache.cache_dir))
+    )
     items = lru.LRUDict.load(os.path.join(cache.cache_dir, cache.STATE_FILE))
     self.assertEqual(0, len(items))
 
     cache.save()
     self.assertEqual(
-        sorted([h, cache.STATE_FILE]), sorted(fs.listdir(cache.cache_dir)))
+      sorted([h, cache.STATE_FILE]), sorted(fs.listdir(cache.cache_dir))
+    )
     items = lru.LRUDict.load(os.path.join(cache.cache_dir, cache.STATE_FILE))
     self.assertEqual(1, len(items))
     self.assertEqual((h, [2, 1000]), items.get_oldest())
@@ -336,14 +347,14 @@
     # cleanup.
     self._free_disk = 1003
     cache = self.get_cache(_get_policies(min_free_space=1000))
-    h_foo = self._algo(b'foo').hexdigest()
+    h_foo = self._algo(b"foo").hexdigest()
     self.assertEqual([], sorted(cache._lru._items.items()))
-    cache.write(h_foo, [b'foo'])
+    cache.write(h_foo, [b"foo"])
     self.assertEqual([], cache.trim())
     self.assertEqual([h_foo], [i[0] for i in cache._lru._items.items()])
 
-    h_a = self._algo(b'a').hexdigest()
-    local_caching.file_write(os.path.join(cache.cache_dir, h_a), [b'a'])
+    h_a = self._algo(b"a").hexdigest()
+    local_caching.file_write(os.path.join(cache.cache_dir, h_a), [b"a"])
 
     # file_path.remove() explicitly handle the +R bit on Windows.
     file_path.remove(os.path.join(cache.cache_dir, h_foo))
@@ -351,7 +362,8 @@
     # Still hasn't realized that the file is missing.
     self.assertEqual([h_foo], [i[0] for i in cache._lru._items.items()])
     self.assertEqual(
-        sorted([h_a, cache.STATE_FILE]), sorted(fs.listdir(cache.cache_dir)))
+      sorted([h_a, cache.STATE_FILE]), sorted(fs.listdir(cache.cache_dir))
+    )
     cache.cleanup()
     self.assertEqual([cache.STATE_FILE], fs.listdir(cache.cache_dir))
 
@@ -360,67 +372,73 @@
     cache = self.get_cache(_get_policies(min_free_space=1000))
 
     # add a corrupted item
-    h_a = self._algo(b'a').hexdigest()
-    cache.write(h_a, [b'A'])
-    h_b = self._algo(b'b').hexdigest()
-    cache.write(h_b, [b'b'])
+    h_a = self._algo(b"a").hexdigest()
+    cache.write(h_a, [b"A"])
+    h_b = self._algo(b"b").hexdigest()
+    cache.write(h_b, [b"b"])
 
     mtime_a = self._now
     mtime_b = self._now
+
     def _get_mtime(h):
       if h == h_a:
         return mtime_a
       if h == h_b:
         return mtime_b
 
-    self.mock(cache, '_get_mtime', _get_mtime)
-    self.assertEqual([(h_a, (1, mtime_a)), (h_b, (1, mtime_b))],
-                     list(cache._lru._items.items()))
-    self.assertCountEqual(([h_a, h_b, cache.STATE_FILE]),
-                          (fs.listdir(cache.cache_dir)))
+    self.mock(cache, "_get_mtime", _get_mtime)
+    self.assertEqual(
+      [(h_a, (1, mtime_a)), (h_b, (1, mtime_b))],
+      list(cache._lru._items.items()),
+    )
+    self.assertCountEqual(
+      ([h_a, h_b, cache.STATE_FILE]), (fs.listdir(cache.cache_dir))
+    )
 
     # if the mtime is same with the timestamp in state.json,
     # the varification won't run.
     cache.cleanup()
-    self.assertCountEqual(([h_a, h_b, cache.STATE_FILE]),
-                          (fs.listdir(cache.cache_dir)))
+    self.assertCountEqual(
+      ([h_a, h_b, cache.STATE_FILE]), (fs.listdir(cache.cache_dir))
+    )
 
     # if the mtime is after the timestamp in the state.json
     # the varification will run and removed the corrupted file.
     mtime_a += 1
     mtime_b += 1
-    self.mock(cache._lru, 'time_fn', lambda: mtime_b)
+    self.mock(cache._lru, "time_fn", lambda: mtime_b)
     cache.cleanup()
-    self.assertCountEqual(([h_b, cache.STATE_FILE]),
-                          (fs.listdir(cache.cache_dir)))
+    self.assertCountEqual(
+      ([h_b, cache.STATE_FILE]), (fs.listdir(cache.cache_dir))
+    )
     self.assertCountEqual([(h_b, (1, mtime_b))], cache._lru._items.items())
 
   def test_policies_active_trimming(self):
     # Start with a larger cache, add many object.
     # Reload the cache with smaller policies, the cache should be trimmed on
     # load.
-    h_a = self._algo(b'a').hexdigest()
-    h_b = self._algo(b'b').hexdigest()
-    h_c = self._algo(b'c').hexdigest()
-    large = b'b' * 99
+    h_a = self._algo(b"a").hexdigest()
+    h_b = self._algo(b"b").hexdigest()
+    h_c = self._algo(b"c").hexdigest()
+    large = b"b" * 99
     h_large = self._algo(large).hexdigest()
 
     def assertItems(expected):
       actual = [
-        (digest, size) for digest, (size, _) in cache._lru._items.items()]
+        (digest, size) for digest, (size, _) in cache._lru._items.items()
+      ]
       self.assertEqual(expected, actual)
 
     self._free_disk = 1101
-    cache = self.get_cache(_get_policies(
-        max_cache_size=100,
-        max_items=2,
-        min_free_space=1000))
-    cache.write(h_a, [b'a'])
+    cache = self.get_cache(
+      _get_policies(max_cache_size=100, max_items=2, min_free_space=1000)
+    )
+    cache.write(h_a, [b"a"])
     cache.write(h_large, [large])
     # Cache (size and # items) is not enforced while adding items. The
     # rationale is that a task may request more data than the size of the
     # cache policies. As long as there is free space, this is fine.
-    cache.write(h_b, [b'b'])
+    cache.write(h_b, [b"b"])
     assertItems([(h_a, 1), (h_large, len(large)), (h_b, 1)])
     self.assertEqual(h_a, cache._protected)
     self.assertEqual(1000, cache._free_disk)
@@ -428,35 +446,37 @@
     # be able to start. In this case, it throws an exception since all items
     # are protected. The item is added since it's detected after the fact.
     with self.assertRaises(local_caching.NoMoreSpace):
-      cache.write(h_c, [b'c'])
+      cache.write(h_c, [b"c"])
     self.assertEqual([1, 99], cache.trim())
 
     # At this point, after the implicit trim in __exit__(), h_a and h_large were
     # evicted.
-    self.assertEqual(sorted([h_b, h_c, cache.STATE_FILE]),
-                     sorted(fs.listdir(cache.cache_dir)))
+    self.assertEqual(
+      sorted([h_b, h_c, cache.STATE_FILE]), sorted(fs.listdir(cache.cache_dir))
+    )
 
     # Allow 3 items and 101 bytes so h_large is kept.
-    cache = self.get_cache(_get_policies(
-        max_cache_size=101,
-        min_free_space=1000,
-        max_items=3,
-        max_age_secs=0))
+    cache = self.get_cache(
+      _get_policies(
+        max_cache_size=101, min_free_space=1000, max_items=3, max_age_secs=0
+      )
+    )
     cache.write(h_large, [large])
     self.assertEqual(3, len(cache))
     self.assertEqual(101, cache.total_size)
     self.assertEqual([], cache.trim())
 
     self.assertEqual(
-        sorted([h_b, h_c, h_large, cache.STATE_FILE]),
-        sorted(fs.listdir(cache.cache_dir)))
+      sorted([h_b, h_c, h_large, cache.STATE_FILE]),
+      sorted(fs.listdir(cache.cache_dir)),
+    )
 
     # Assert that trimming is done in constructor too.
-    cache = self.get_cache(_get_policies(
-        max_cache_size=100,
-        min_free_space=1000,
-        max_items=2,
-        max_age_secs=0))
+    cache = self.get_cache(
+      _get_policies(
+        max_cache_size=100, min_free_space=1000, max_items=2, max_age_secs=0
+      )
+    )
     assertItems([(h_c, 1), (h_large, len(large))])
     self.assertEqual(None, cache._protected)
     self.assertEqual(1202, cache._free_disk)
@@ -467,25 +487,28 @@
   def test_trim_policies_trim_old(self):
     # Add two items, one 3 weeks and one minute old, one recent, make sure the
     # old one is trimmed.
-    cache = self.get_cache(_get_policies(
+    cache = self.get_cache(
+      _get_policies(
         max_cache_size=1000,
         min_free_space=0,
         max_items=1000,
-        max_age_secs=21*24*60*60))
+        max_age_secs=21 * 24 * 60 * 60,
+      )
+    )
     self._now = 100
     # Test the very limit of 3 weeks:
-    cache.write(self._algo(b'old').hexdigest(), [b'old'])
+    cache.write(self._algo(b"old").hexdigest(), [b"old"])
     self._now += 1
-    cache.write(self._algo(b'recent').hexdigest(), [b'recent'])
-    self._now += 21*24*60*60
+    cache.write(self._algo(b"recent").hexdigest(), [b"recent"])
+    self._now += 21 * 24 * 60 * 60
     self.assertEqual([3], cache.trim())
-    self.assertEqual([self._algo(b'recent').hexdigest()], list(cache))
+    self.assertEqual([self._algo(b"recent").hexdigest()], list(cache))
 
   def test_some_file_brutally_deleted(self):
-    h_a = self._algo(b'a').hexdigest()
+    h_a = self._algo(b"a").hexdigest()
     self._free_disk = 1100
     cache = self.get_cache(_get_policies())
-    cache.write(h_a, [b'a'])
+    cache.write(h_a, [b"a"])
     self.assertTrue(cache.touch(h_a, local_caching.UNKNOWN_FILE_SIZE))
     self.assertTrue(cache.touch(h_a, 1))
     self.assertEqual([], cache.trim())
@@ -504,21 +527,22 @@
 
   def test_invalid_state(self):
     file_path.ensure_tree(self.cache_dir())
-    statefile = os.path.join(self.cache_dir(),
-                             local_caching.DiskContentAddressedCache.STATE_FILE)
-    with open(statefile, 'w') as f:
-      f.write('invalid')
-    with open(os.path.join(self.cache_dir(), 'invalid'), 'w') as f:
-      f.write('invalid')
+    statefile = os.path.join(
+      self.cache_dir(), local_caching.DiskContentAddressedCache.STATE_FILE
+    )
+    with open(statefile, "w") as f:
+      f.write("invalid")
+    with open(os.path.join(self.cache_dir(), "invalid"), "w") as f:
+      f.write("invalid")
 
     _ = self.get_cache(_get_policies())
-    self.assertEqual(fs.listdir(self.cache_dir()), ['state.json'])
+    self.assertEqual(fs.listdir(self.cache_dir()), ["state.json"])
 
 
 class NamedCacheTest(TestCase, CacheTestMixin):
   def setUp(self):
     super(NamedCacheTest, self).setUp()
-    self.cache_dir = os.path.join(self.tempdir, 'cache')
+    self.cache_dir = os.path.join(self.tempdir, "cache")
 
   def get_cache(self, policies):
     return local_caching.NamedCache(self.cache_dir, policies)
@@ -527,139 +551,156 @@
     return local_caching.NamedCache(self.cache_dir, policies, keep=keep)
 
   def test_clean_cache(self):
-    dest_dir = os.path.join(self.tempdir, 'dest')
+    dest_dir = os.path.join(self.tempdir, "dest")
     cache = self.get_cache(_get_policies())
     self.assertEqual([], fs.listdir(cache.cache_dir))
 
-    a_path = os.path.join(dest_dir, 'a')
-    b_path = os.path.join(dest_dir, 'b')
+    a_path = os.path.join(dest_dir, "a")
+    b_path = os.path.join(dest_dir, "b")
 
-    self.assertEqual(0, cache.install(a_path, '1'))
-    self.assertEqual(0, cache.install(b_path, '2'))
+    self.assertEqual(0, cache.install(a_path, "1"))
+    self.assertEqual(0, cache.install(b_path, "2"))
     self.assertEqual(
-        False, fs.exists(os.path.join(cache.cache_dir, cache.NAMED_DIR)))
+      False, fs.exists(os.path.join(cache.cache_dir, cache.NAMED_DIR))
+    )
 
-    self.assertEqual({'a', 'b'}, set(fs.listdir(dest_dir)))
+    self.assertEqual({"a", "b"}, set(fs.listdir(dest_dir)))
     self.assertFalse(cache.available)
     self.assertEqual([cache.STATE_FILE], fs.listdir(cache.cache_dir))
 
-    write_file(os.path.join(a_path, 'x'), b'x')
-    write_file(os.path.join(b_path, 'y'), b'y')
+    write_file(os.path.join(a_path, "x"), b"x")
+    write_file(os.path.join(b_path, "y"), b"y")
 
-    self.assertEqual(1, cache.uninstall(a_path, '1'))
-    self.assertEqual(1, cache.uninstall(b_path, '2'))
+    self.assertEqual(1, cache.uninstall(a_path, "1"))
+    self.assertEqual(1, cache.uninstall(b_path, "2"))
 
     self.assertEqual(4, len(fs.listdir(cache.cache_dir)))
-    path1 = os.path.join(cache.cache_dir, cache._lru['1'][0])
-    self.assertEqual(b'x', read_file(os.path.join(path1, 'x')))
-    path2 = os.path.join(cache.cache_dir, cache._lru['2'][0])
-    self.assertEqual(b'y', read_file(os.path.join(path2, 'y')))
-    self.assertEqual(os.path.join('..', cache._lru['1'][0]),
-                     fs.readlink(cache._get_named_path('1')))
-    self.assertEqual(os.path.join('..', cache._lru['2'][0]),
-                     fs.readlink(cache._get_named_path('2')))
+    path1 = os.path.join(cache.cache_dir, cache._lru["1"][0])
+    self.assertEqual(b"x", read_file(os.path.join(path1, "x")))
+    path2 = os.path.join(cache.cache_dir, cache._lru["2"][0])
+    self.assertEqual(b"y", read_file(os.path.join(path2, "y")))
     self.assertEqual(
-        ['1', '2'],
-        sorted(fs.listdir(os.path.join(cache.cache_dir, cache.NAMED_DIR))))
+      os.path.join("..", cache._lru["1"][0]),
+      fs.readlink(cache._get_named_path("1")),
+    )
+    self.assertEqual(
+      os.path.join("..", cache._lru["2"][0]),
+      fs.readlink(cache._get_named_path("2")),
+    )
+    self.assertEqual(
+      ["1", "2"],
+      sorted(fs.listdir(os.path.join(cache.cache_dir, cache.NAMED_DIR))),
+    )
 
   def test_existing_cache(self):
     # Ensures that the code does what is expected under number use.
-    dest_dir = os.path.join(self.tempdir, 'dest')
+    dest_dir = os.path.join(self.tempdir, "dest")
     cache = self.get_cache(_get_policies())
     # Assume test_clean passes.
-    a_path = os.path.join(dest_dir, 'a')
-    b_path = os.path.join(dest_dir, 'b')
+    a_path = os.path.join(dest_dir, "a")
+    b_path = os.path.join(dest_dir, "b")
 
-    self.assertEqual(0, cache.install(a_path, '1'))
-    write_file(os.path.join(dest_dir, 'a', 'x'), b'x')
-    self.assertEqual(1, cache.uninstall(a_path, '1'))
+    self.assertEqual(0, cache.install(a_path, "1"))
+    write_file(os.path.join(dest_dir, "a", "x"), b"x")
+    self.assertEqual(1, cache.uninstall(a_path, "1"))
 
     # Test starts here.
-    self.assertEqual(1, cache.install(a_path, '1'))
-    self.assertEqual(0, cache.install(b_path, '2'))
-    self.assertEqual({'a', 'b'}, set(fs.listdir(dest_dir)))
+    self.assertEqual(1, cache.install(a_path, "1"))
+    self.assertEqual(0, cache.install(b_path, "2"))
+    self.assertEqual({"a", "b"}, set(fs.listdir(dest_dir)))
     self.assertFalse(cache.available)
     self.assertEqual(
-        sorted([cache.NAMED_DIR, cache.STATE_FILE]),
-        sorted(fs.listdir(cache.cache_dir)))
+      sorted([cache.NAMED_DIR, cache.STATE_FILE]),
+      sorted(fs.listdir(cache.cache_dir)),
+    )
     self.assertEqual(
-        [], fs.listdir(os.path.join(cache.cache_dir, cache.NAMED_DIR)))
+      [], fs.listdir(os.path.join(cache.cache_dir, cache.NAMED_DIR))
+    )
 
-    self.assertEqual(b'x', read_file(os.path.join(dest_dir, 'a', 'x')))
-    write_file(os.path.join(a_path, 'x'), b'x2')
-    write_file(os.path.join(b_path, 'y'), b'y')
+    self.assertEqual(b"x", read_file(os.path.join(dest_dir, "a", "x")))
+    write_file(os.path.join(a_path, "x"), b"x2")
+    write_file(os.path.join(b_path, "y"), b"y")
 
-    self.assertEqual(2, cache.uninstall(a_path, '1'))
-    self.assertEqual(1, cache.uninstall(b_path, '2'))
+    self.assertEqual(2, cache.uninstall(a_path, "1"))
+    self.assertEqual(1, cache.uninstall(b_path, "2"))
 
     self.assertEqual(4, len(fs.listdir(cache.cache_dir)))
-    path1 = os.path.join(cache.cache_dir, cache._lru['1'][0])
-    self.assertEqual(b'x2', read_file(os.path.join(path1, 'x')))
-    path2 = os.path.join(cache.cache_dir, cache._lru['2'][0])
-    self.assertEqual(b'y', read_file(os.path.join(path2, 'y')))
-    self.assertEqual(os.path.join('..', cache._lru['1'][0]),
-                     fs.readlink(cache._get_named_path('1')))
-    self.assertEqual(os.path.join('..', cache._lru['2'][0]),
-                     fs.readlink(cache._get_named_path('2')))
+    path1 = os.path.join(cache.cache_dir, cache._lru["1"][0])
+    self.assertEqual(b"x2", read_file(os.path.join(path1, "x")))
+    path2 = os.path.join(cache.cache_dir, cache._lru["2"][0])
+    self.assertEqual(b"y", read_file(os.path.join(path2, "y")))
     self.assertEqual(
-        ['1', '2'],
-        sorted(fs.listdir(os.path.join(cache.cache_dir, cache.NAMED_DIR))))
+      os.path.join("..", cache._lru["1"][0]),
+      fs.readlink(cache._get_named_path("1")),
+    )
+    self.assertEqual(
+      os.path.join("..", cache._lru["2"][0]),
+      fs.readlink(cache._get_named_path("2")),
+    )
+    self.assertEqual(
+      ["1", "2"],
+      sorted(fs.listdir(os.path.join(cache.cache_dir, cache.NAMED_DIR))),
+    )
 
   def test_install_throws(self):
     old_isdir = None
     banged = []
+
     # Crashes, but only on the first call.
     def bang(path):
       if not banged:
         banged.append(True)
-        raise IOError('fake')
+        raise IOError("fake")
       return old_isdir(path)
 
     cache = self.get_cache(_get_policies())
-    dest_dir = os.path.join(self.tempdir, 'dest')
+    dest_dir = os.path.join(self.tempdir, "dest")
 
     # fs.isdir() happens to be the first function called.
-    old_isdir = self.mock(fs, 'isdir', bang)
+    old_isdir = self.mock(fs, "isdir", bang)
     with self.assertRaises(local_caching.NamedCacheError):
-      cache.install(dest_dir, '1')
+      cache.install(dest_dir, "1")
 
   def test_uninstall_throws(self):
     old_isdir = None
     banged = []
+
     # Crashes, but only on the first call.
     def bang(path):
       if not banged:
         banged.append(True)
-        raise IOError('fake')
+        raise IOError("fake")
       return old_isdir(path)
 
     cache = self.get_cache(_get_policies())
-    dest_dir = os.path.join(self.tempdir, 'dest')
-    self.assertEqual(0, cache.install(dest_dir, '1'))
+    dest_dir = os.path.join(self.tempdir, "dest")
+    self.assertEqual(0, cache.install(dest_dir, "1"))
 
     # fs.isdir() happens to be the first function called.
-    old_isdir = self.mock(fs, 'isdir', bang)
+    old_isdir = self.mock(fs, "isdir", bang)
     with self.assertRaises(local_caching.NamedCacheError):
-      cache.uninstall(dest_dir, '1')
+      cache.uninstall(dest_dir, "1")
 
   def test_cycle_twice(self):
     # Ensure that named symlink works.
     cache = self.get_cache(_get_policies())
-    dest_dir = os.path.join(self.tempdir, 'dest')
-    self.assertEqual(0, cache.install(dest_dir, '1'))
-    with fs.open(os.path.join(dest_dir, 'hi'), 'wb') as f:
-      f.write(b'hello')
-    self.assertEqual(5, cache.uninstall(dest_dir, '1'))
-    self.assertEqual(['1'],
-                     fs.listdir(os.path.join(cache.cache_dir, cache.NAMED_DIR)))
+    dest_dir = os.path.join(self.tempdir, "dest")
+    self.assertEqual(0, cache.install(dest_dir, "1"))
+    with fs.open(os.path.join(dest_dir, "hi"), "wb") as f:
+      f.write(b"hello")
+    self.assertEqual(5, cache.uninstall(dest_dir, "1"))
+    self.assertEqual(
+      ["1"], fs.listdir(os.path.join(cache.cache_dir, cache.NAMED_DIR))
+    )
     self.assertEqual(True, cache.cleanup())
-    self.assertEqual(5, cache.install(dest_dir, '1'))
-    self.assertEqual(5, cache.uninstall(dest_dir, '1'))
-    self.assertEqual(['1'],
-                     fs.listdir(os.path.join(cache.cache_dir, cache.NAMED_DIR)))
-    self.assertEqual(['hi'],
-                     fs.listdir(
-                         os.path.join(cache.cache_dir, cache.NAMED_DIR, '1')))
+    self.assertEqual(5, cache.install(dest_dir, "1"))
+    self.assertEqual(5, cache.uninstall(dest_dir, "1"))
+    self.assertEqual(
+      ["1"], fs.listdir(os.path.join(cache.cache_dir, cache.NAMED_DIR))
+    )
+    self.assertEqual(
+      ["hi"], fs.listdir(os.path.join(cache.cache_dir, cache.NAMED_DIR, "1"))
+    )
 
   def test_save_named(self):
     cache = self.get_cache(_get_policies())
@@ -675,13 +716,15 @@
     # This depends on the inner format as generated by NamedCache.
     entry_dir_name = v[0]
     self.assertEqual(
-        sorted([entry_dir_name, cache.NAMED_DIR, cache.STATE_FILE]),
-        sorted(fs.listdir(cache.cache_dir)))
+      sorted([entry_dir_name, cache.NAMED_DIR, cache.STATE_FILE]),
+      sorted(fs.listdir(cache.cache_dir)),
+    )
 
     cache.save()
     self.assertEqual(
-        sorted([entry_dir_name, cache.NAMED_DIR, cache.STATE_FILE]),
-        sorted(fs.listdir(cache.cache_dir)))
+      sorted([entry_dir_name, cache.NAMED_DIR, cache.STATE_FILE]),
+      sorted(fs.listdir(cache.cache_dir)),
+    )
     with fs.open(os.path.join(cache.cache_dir, cache.STATE_FILE)) as f:
       new_content = json.load(f)
     # That's because uninstall() called from self._add_one_item()
@@ -703,16 +746,17 @@
     cache = self.get_cache(_get_policies(max_items=2))
     item_count = 12
     for i in range(item_count):
-      self._add_one_item(cache, i+1)
+      self._add_one_item(cache, i + 1)
     self.assertEqual(len(cache), item_count)
     self.assertEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], cache.trim())
     self.assertEqual(len(cache), 2)
     self.assertEqual(
-        ['11', '12'],
-        sorted(fs.listdir(os.path.join(cache.cache_dir, cache.NAMED_DIR))))
+      ["11", "12"],
+      sorted(fs.listdir(os.path.join(cache.cache_dir, cache.NAMED_DIR))),
+    )
 
   def test_trim_with_keep(self):
-    cache = self.get_named_cache(_get_policies(max_items=2), keep=['1', '2'])
+    cache = self.get_named_cache(_get_policies(max_items=2), keep=["1", "2"])
     item_count = 12
     for i in range(item_count):
       self._add_one_item(cache, i + 1)
@@ -720,8 +764,9 @@
     self.assertEqual([3, 4, 5, 6, 7, 8, 9, 10, 11, 12], cache.trim())
     self.assertEqual(len(cache), 2)
     self.assertEqual(
-        ['1', '2'],
-        sorted(fs.listdir(os.path.join(cache.cache_dir, cache.NAMED_DIR))))
+      ["1", "2"],
+      sorted(fs.listdir(os.path.join(cache.cache_dir, cache.NAMED_DIR))),
+    )
 
   def test_trim_ignores_policy_for_keep_items(self):
     """
@@ -731,8 +776,9 @@
     Under these circumstances, trim will remove items until only the 3 items
     remain.
     """
-    cache = self.get_named_cache(_get_policies(max_items=2),
-                                 keep=['1', '2', '3'])
+    cache = self.get_named_cache(
+      _get_policies(max_items=2), keep=["1", "2", "3"]
+    )
     item_count = 12
     for i in range(item_count):
       self._add_one_item(cache, i + 1)
@@ -740,14 +786,15 @@
     self.assertEqual([4, 5, 6, 7, 8, 9, 10, 11, 12], cache.trim())
     self.assertEqual(len(cache), 3)
     self.assertEqual(
-        ['1', '2', '3'],
-        sorted(fs.listdir(os.path.join(cache.cache_dir, cache.NAMED_DIR))))
+      ["1", "2", "3"],
+      sorted(fs.listdir(os.path.join(cache.cache_dir, cache.NAMED_DIR))),
+    )
 
   def test_trim_ignores_irrelevant_keep_items(self):
     """
     Ignore dont evict if none of its items are in the cache.
     """
-    cache = self.get_named_cache(_get_policies(max_items=2), keep=['a', 'b'])
+    cache = self.get_named_cache(_get_policies(max_items=2), keep=["a", "b"])
     item_count = 12
     for i in range(item_count):
       self._add_one_item(cache, i + 1)
@@ -755,52 +802,58 @@
     self.assertEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], cache.trim())
     self.assertEqual(len(cache), 2)
     self.assertEqual(
-        ['11', '12'],
-        sorted(fs.listdir(os.path.join(cache.cache_dir, cache.NAMED_DIR))))
+      ["11", "12"],
+      sorted(fs.listdir(os.path.join(cache.cache_dir, cache.NAMED_DIR))),
+    )
 
   def test_load_corrupted_state(self):
     # cleanup() handles a broken state file.
     fs.mkdir(self.cache_dir)
     c = local_caching.NamedCache
-    with fs.open(os.path.join(self.cache_dir, c.STATE_FILE), 'w') as f:
-      f.write('}}}}')
-    fs.makedirs(os.path.join(self.cache_dir, '1'), 0o777)
+    with fs.open(os.path.join(self.cache_dir, c.STATE_FILE), "w") as f:
+      f.write("}}}}")
+    fs.makedirs(os.path.join(self.cache_dir, "1"), 0o777)
 
     cache = self.get_cache(_get_policies())
     self._add_one_item(cache, 1)
     self.assertTrue(
-        fs.exists(os.path.join(cache.cache_dir, cache.NAMED_DIR, '1')))
+      fs.exists(os.path.join(cache.cache_dir, cache.NAMED_DIR, "1"))
+    )
     self.assertTrue(
-        fs.islink(os.path.join(cache.cache_dir, cache.NAMED_DIR, '1')))
+      fs.islink(os.path.join(cache.cache_dir, cache.NAMED_DIR, "1"))
+    )
     self.assertEqual([], cache.trim())
     self.assertTrue(
-        fs.exists(os.path.join(cache.cache_dir, cache.NAMED_DIR, '1')))
+      fs.exists(os.path.join(cache.cache_dir, cache.NAMED_DIR, "1"))
+    )
     self.assertTrue(
-        fs.islink(os.path.join(cache.cache_dir, cache.NAMED_DIR, '1')))
+      fs.islink(os.path.join(cache.cache_dir, cache.NAMED_DIR, "1"))
+    )
     self.assertEqual(True, cache.cleanup())
     self.assertEqual(
-        sorted([cache.NAMED_DIR, cache.STATE_FILE, cache._lru['1'][0]]),
-        sorted(fs.listdir(cache.cache_dir)))
+      sorted([cache.NAMED_DIR, cache.STATE_FILE, cache._lru["1"][0]]),
+      sorted(fs.listdir(cache.cache_dir)),
+    )
 
-  @unittest.skipIf(sys.platform == 'win32', 'crbug.com/1148174')
+  @unittest.skipIf(sys.platform == "win32", "crbug.com/1148174")
   def test_cleanup_missing(self):
     # cleanup() detects a missing item.
     cache = self.get_cache(_get_policies())
     self._add_one_item(cache, 1)
-    file_path.rmtree(os.path.join(cache.cache_dir, cache._lru['1'][0]))
+    file_path.rmtree(os.path.join(cache.cache_dir, cache._lru["1"][0]))
 
     cache = self.get_cache(_get_policies())
-    self.assertEqual(['1'], list(cache))
+    self.assertEqual(["1"], list(cache))
     self.assertEqual(True, cache.cleanup())
     self.assertEqual([], list(cache))
 
   def test_cleanup_unexpected(self):
     # cleanup() delete unexpected file in the cache directory.
     fs.mkdir(self.cache_dir)
-    with fs.open(os.path.join(self.cache_dir, 'junk'), 'w') as f:
-      f.write('random')
+    with fs.open(os.path.join(self.cache_dir, "junk"), "w") as f:
+      f.write("random")
     cache = self.get_cache(_get_policies())
-    self.assertEqual(['junk'], fs.listdir(cache.cache_dir))
+    self.assertEqual(["junk"], fs.listdir(cache.cache_dir))
     self.assertEqual(True, cache.cleanup())
     self.assertEqual([cache.STATE_FILE], fs.listdir(cache.cache_dir))
 
@@ -809,88 +862,103 @@
     fs.mkdir(self.cache_dir)
     c = local_caching.NamedCache
     fs.mkdir(os.path.join(self.cache_dir, c.NAMED_DIR))
-    p = os.path.join(self.cache_dir, c.NAMED_DIR, 'junk_file')
-    with fs.open(p, 'w') as f:
-      f.write('random')
-    fs.mkdir(os.path.join(self.cache_dir, c.NAMED_DIR, 'junk_dir'))
-    fs.symlink('invalid_dest',
-               os.path.join(self.cache_dir, c.NAMED_DIR, 'junk_link'))
+    p = os.path.join(self.cache_dir, c.NAMED_DIR, "junk_file")
+    with fs.open(p, "w") as f:
+      f.write("random")
+    fs.mkdir(os.path.join(self.cache_dir, c.NAMED_DIR, "junk_dir"))
+    fs.symlink(
+      "invalid_dest", os.path.join(self.cache_dir, c.NAMED_DIR, "junk_link")
+    )
 
     cache = self.get_cache(_get_policies())
     self.assertEqual([cache.NAMED_DIR], fs.listdir(cache.cache_dir))
     self.assertEqual(
-        ['junk_dir', 'junk_file', 'junk_link'],
-        sorted(fs.listdir(os.path.join(cache.cache_dir, cache.NAMED_DIR))))
+      ["junk_dir", "junk_file", "junk_link"],
+      sorted(fs.listdir(os.path.join(cache.cache_dir, cache.NAMED_DIR))),
+    )
     self.assertEqual(True, cache.cleanup())
     self.assertEqual(
-        [cache.NAMED_DIR, cache.STATE_FILE],
-        sorted(fs.listdir(cache.cache_dir)))
+      [cache.NAMED_DIR, cache.STATE_FILE], sorted(fs.listdir(cache.cache_dir))
+    )
     self.assertEqual(
-        [], fs.listdir(os.path.join(cache.cache_dir, cache.NAMED_DIR)))
+      [], fs.listdir(os.path.join(cache.cache_dir, cache.NAMED_DIR))
+    )
 
   def test_cleanup_incorrect_link(self):
     # cleanup() repairs broken symlink in named/.
     cache = self.get_cache(_get_policies())
     self._add_one_item(cache, 1)
     self._add_one_item(cache, 2)
-    fs.remove(os.path.join(self.cache_dir, cache.NAMED_DIR, '1'))
-    fs.remove(os.path.join(self.cache_dir, cache.NAMED_DIR, '2'))
-    fs.symlink('invalid_dest', os.path.join(self.cache_dir, cache.NAMED_DIR,
-                                            '1'))
-    fs.mkdir(os.path.join(self.cache_dir, cache.NAMED_DIR, '2'))
+    fs.remove(os.path.join(self.cache_dir, cache.NAMED_DIR, "1"))
+    fs.remove(os.path.join(self.cache_dir, cache.NAMED_DIR, "2"))
+    fs.symlink(
+      "invalid_dest", os.path.join(self.cache_dir, cache.NAMED_DIR, "1")
+    )
+    fs.mkdir(os.path.join(self.cache_dir, cache.NAMED_DIR, "2"))
 
     cache = self.get_cache(_get_policies())
     self.assertEqual(
-        ['1', '2'],
-        sorted(fs.listdir(os.path.join(cache.cache_dir, cache.NAMED_DIR))))
+      ["1", "2"],
+      sorted(fs.listdir(os.path.join(cache.cache_dir, cache.NAMED_DIR))),
+    )
     self.assertEqual(True, cache.cleanup())
     self.assertEqual(
-        [], fs.listdir(os.path.join(cache.cache_dir, cache.NAMED_DIR)))
+      [], fs.listdir(os.path.join(cache.cache_dir, cache.NAMED_DIR))
+    )
 
   def test_upgrade(self):
     # Make sure upgrading works. This is temporary as eventually all bots will
     # be updated.
     now = time.time()
     fs.mkdir(self.cache_dir)
-    fs.mkdir(os.path.join(self.cache_dir, 'f1'))
-    with fs.open(os.path.join(self.cache_dir, 'f1', 'hello'), 'wb') as f:
-      f.write(b'world')
+    fs.mkdir(os.path.join(self.cache_dir, "f1"))
+    with fs.open(os.path.join(self.cache_dir, "f1", "hello"), "wb") as f:
+      f.write(b"world")
     # v1
     old = {
-        'version': lru.CURRENT_VERSION,
-        'items': [['cache1', [['f1', len('world')], now]],],
+      "version": lru.CURRENT_VERSION,
+      "items": [
+        ["cache1", [["f1", len("world")], now]],
+      ],
     }
     c = local_caching.NamedCache
-    with fs.open(os.path.join(self.cache_dir, c.STATE_FILE), 'w') as f:
+    with fs.open(os.path.join(self.cache_dir, c.STATE_FILE), "w") as f:
       json.dump(old, f)
     # It automatically upgrades to v2.
     cache = self.get_cache(_get_policies())
-    expected = {'cache1': [['f1', len('world')], now]}
+    expected = {"cache1": [["f1", len("world")], now]}
     self.assertEqual(expected, dict(cache._lru._items.items()))
-    self.assertEqual(['f1', cache.STATE_FILE],
-                     sorted(fs.listdir(cache.cache_dir)))
+    self.assertEqual(
+      ["f1", cache.STATE_FILE], sorted(fs.listdir(cache.cache_dir))
+    )
 
 
 def _gen_state(items):
-  state = {'items': items, 'version': lru.CURRENT_VERSION}
-  return json.dumps(
-      state, sort_keys=True, separators=(',', ':')).encode('utf-8')
+  state = {"items": items, "version": lru.CURRENT_VERSION}
+  return json.dumps(state, sort_keys=True, separators=(",", ":")).encode(
+    "utf-8"
+  )
 
 
 class FnTest(TestCase):
   """Test functions that leverage both DiskContentAddressedCache and
   NamedCache.
   """
+
   def setUp(self):
     super(FnTest, self).setUp()
+
     # Simulate that the memory cache used disk space.
     def remove_oldest(c):
       s = old_remove_oldest(c)
       self._free_disk += s
       return s
 
-    old_remove_oldest = self.mock(local_caching.MemoryContentAddressedCache,
-                                  'remove_oldest_evictable_item', remove_oldest)
+    old_remove_oldest = self.mock(
+      local_caching.MemoryContentAddressedCache,
+      "remove_oldest_evictable_item",
+      remove_oldest,
+    )
 
   def _prepare_cache(self, cache):
     now = self._now
@@ -907,12 +975,14 @@
   def _verify_isolated_cache(self, cache, items):
     # Isolated cache verification.
     expected = {
-        self._algo(_gen_data(n)).hexdigest(): _gen_data(n)
-        for n in items
+      self._algo(_gen_data(n)).hexdigest(): _gen_data(n) for n in items
     }
     expected[cache.STATE_FILE] = _gen_state(
-        [[self._algo(_gen_data(n)).hexdigest(), [n, self._now + n - 1]]
-         for n in items])
+      [
+        [self._algo(_gen_data(n)).hexdigest(), [n, self._now + n - 1]]
+        for n in items
+      ]
+    )
     self.assertEqual(expected, read_tree(cache.cache_dir))
 
   def _prepare_named_cache(self, cache):
@@ -920,9 +990,10 @@
     # Figure out the short names via the symlinks.
     items = range(1, 11)
     short_names = {
-        n: os.path.basename(
-            fs.readlink(os.path.join(cache.cache_dir, cache.NAMED_DIR, str(n))))
-        for n in items
+      n: os.path.basename(
+        fs.readlink(os.path.join(cache.cache_dir, cache.NAMED_DIR, str(n)))
+      )
+      for n in items
     }
     self._verify_named_cache(cache, short_names, items)
     return short_names
@@ -932,11 +1003,11 @@
     actual = read_tree(cache.cache_dir)
     # There's assumption about json encoding format but here it's good enough.
     expected = {
-        os.path.join(short_names[n], 'hello'): _gen_data(n)
-        for n in items
+      os.path.join(short_names[n], "hello"): _gen_data(n) for n in items
     }
     expected[cache.STATE_FILE] = _gen_state(
-        [[str(n), [[short_names[n], n], self._now + n - 1]] for n in items])
+      [[str(n), [[short_names[n], n], self._now + n - 1]] for n in items]
+    )
     self.assertEqual(expected, actual)
 
   def test_clean_caches_disk(self):
@@ -948,21 +1019,24 @@
     # Setup caches.
     policies = _get_policies(min_free_space=1000)
     named_cache = local_caching.NamedCache(
-        tempfile.mkdtemp(dir=self.tempdir, prefix='nc'), policies)
+      tempfile.mkdtemp(dir=self.tempdir, prefix="nc"), policies
+    )
     short_names = self._prepare_named_cache(named_cache)
 
     isolated_cache = local_caching.DiskContentAddressedCache(
-        tempfile.mkdtemp(dir=self.tempdir, prefix='ic'), policies, trim=False)
+      tempfile.mkdtemp(dir=self.tempdir, prefix="ic"), policies, trim=False
+    )
     self._prepare_isolated_cache(isolated_cache)
     self.assertEqual(now, self._now)
 
     # Request trimming.
     self._free_disk = 950
     trimmed = local_caching.trim_caches(
-        [isolated_cache, named_cache],
-        self.tempdir,
-        min_free_space=policies.min_free_space,
-        max_age_secs=policies.max_age_secs)
+      [isolated_cache, named_cache],
+      self.tempdir,
+      min_free_space=policies.min_free_space,
+      max_age_secs=policies.max_age_secs,
+    )
     # Enough to free 50 bytes. The following sums to 56.
     expected = [1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7]
     self.assertEqual(expected, trimmed)
@@ -975,15 +1049,18 @@
     """Give a named cache where every entry is on the keep list. Trim must
     deal with this by trimming nothing."""
     policies = _get_policies(min_free_space=1)
-    named_cache = local_caching.NamedCache(tempfile.mkdtemp(dir=self.tempdir,
-                                                            prefix='nc'),
-                                           policies,
-                                           keep=[str(x) for x in range(1, 12)])
+    named_cache = local_caching.NamedCache(
+      tempfile.mkdtemp(dir=self.tempdir, prefix="nc"),
+      policies,
+      keep=[str(x) for x in range(1, 12)],
+    )
     self._prepare_named_cache(named_cache)
-    trimmed = local_caching.trim_caches([named_cache],
-                                        self.tempdir,
-                                        min_free_space=policies.min_free_space,
-                                        max_age_secs=policies.max_age_secs)
+    trimmed = local_caching.trim_caches(
+      [named_cache],
+      self.tempdir,
+      min_free_space=policies.min_free_space,
+      max_age_secs=policies.max_age_secs,
+    )
     self.assertEqual([], trimmed)
 
   def _get_5_caches(self):
@@ -996,7 +1073,7 @@
       local_caching.MemoryContentAddressedCache(),
     ]
     for i in range(100):
-      self._add_one_item(caches[random.randint(0, len(caches)-1)], i+1)
+      self._add_one_item(caches[random.randint(0, len(caches) - 1)], i + 1)
       self._now += 1
     return caches
 
@@ -1007,10 +1084,8 @@
     # 100 bytes must be freed.
     self._free_disk = 900
     trimmed = local_caching.trim_caches(
-        caches,
-        self.tempdir,
-        min_free_space=1000,
-        max_age_secs=0)
+      caches, self.tempdir, min_free_space=1000, max_age_secs=0
+    )
     # sum(range(1, 15)) == 105, the first value after 100.
     self.assertEqual(list(range(1, 15)), trimmed)
 
@@ -1018,15 +1093,13 @@
     # Test that cleaning is correctly distributed independent of the cache
     # location.
     caches = self._get_5_caches()
-    self.mock(time, 'time', lambda: self._now)
+    self.mock(time, "time", lambda: self._now)
     trimmed = local_caching.trim_caches(
-        caches,
-        self.tempdir,
-        min_free_space=0,
-        max_age_secs=10)
+      caches, self.tempdir, min_free_space=0, max_age_secs=10
+    )
     # Only the last 10 items are kept. The first 90 items were trimmed.
     self.assertEqual(list(range(1, 91)), trimmed)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
   test_env.main()
diff --git a/tests/logging_utils/phase1.py b/tests/logging_utils/phase1.py
index 38fa5f1..58fd255 100755
--- a/tests/logging_utils/phase1.py
+++ b/tests/logging_utils/phase1.py
@@ -11,14 +11,14 @@
 THIS_DIR = os.path.dirname(os.path.abspath(__file__))
 CLIENT_DIR = os.path.dirname(os.path.dirname(THIS_DIR))
 sys.path.insert(0, CLIENT_DIR)
-sys.path.insert(0, os.path.join(CLIENT_DIR, 'third_party'))
+sys.path.insert(0, os.path.join(CLIENT_DIR, "third_party"))
 
 from utils import logging_utils
 
 dst = sys.argv[1]
 
-logging_utils.prepare_logging(os.path.join(dst, 'shared.log'))
-logging.info('Parent1')
-r = subprocess.call([sys.executable, '-u', 'phase2.py', dst], cwd=THIS_DIR)
-logging.info('Parent2')
+logging_utils.prepare_logging(os.path.join(dst, "shared.log"))
+logging.info("Parent1")
+r = subprocess.call([sys.executable, "-u", "phase2.py", dst], cwd=THIS_DIR)
+logging.info("Parent2")
 sys.exit(r)
diff --git a/tests/logging_utils/phase2.py b/tests/logging_utils/phase2.py
index c24ab66..72a01c4 100755
--- a/tests/logging_utils/phase2.py
+++ b/tests/logging_utils/phase2.py
@@ -10,14 +10,14 @@
 THIS_DIR = os.path.dirname(os.path.abspath(__file__))
 CLIENT_DIR = os.path.dirname(os.path.dirname(THIS_DIR))
 sys.path.insert(0, CLIENT_DIR)
-sys.path.insert(0, os.path.join(CLIENT_DIR, 'third_party'))
+sys.path.insert(0, os.path.join(CLIENT_DIR, "third_party"))
 
 from utils import logging_utils
 
 dst = sys.argv[1]
 
 # Simulate rotating the log.
-logging_utils.prepare_logging(os.path.join(dst, 'shared.log'))
-logging.info('Child1')
-os.rename(os.path.join(dst, 'shared.log'), os.path.join(dst, 'shared.1.log'))
-logging.info('Child2')
+logging_utils.prepare_logging(os.path.join(dst, "shared.log"))
+logging.info("Child1")
+os.rename(os.path.join(dst, "shared.log"), os.path.join(dst, "shared.1.log"))
+logging.info("Child2")
diff --git a/tests/logging_utils_test.py b/tests/logging_utils_test.py
index 2274f7c..2a42289 100755
--- a/tests/logging_utils_test.py
+++ b/tests/logging_utils_test.py
@@ -21,8 +21,9 @@
 
 
 # PID YYYY-MM-DD HH:MM:SS.MMM
-_LOG_HEADER = r'^%d \d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d\.\d\d\d' % os.getpid()
-_LOG_HEADER_PID = r'^\d+ \d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d\.\d\d\d'
+_LOG_HEADER = r"^%d \d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d\.\d\d\d" % os.getpid()
+_LOG_HEADER_PID = r"^\d+ \d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d\.\d\d\d"
+
 
 class Test(unittest.TestCase):
   # This test fails when running via test runner
@@ -31,7 +32,7 @@
 
   def setUp(self):
     super(Test, self).setUp()
-    self.tmp = tempfile.mkdtemp(prefix='logging_utils')
+    self.tmp = tempfile.mkdtemp(prefix="logging_utils")
 
   def tearDown(self):
     try:
@@ -40,18 +41,18 @@
       super(Test, self).tearDown()
 
   def test_user_logs_function(self):
-    with mock.patch('sys.stdout', new=StringIO()) as fake_stdout:
+    with mock.patch("sys.stdout", new=StringIO()) as fake_stdout:
       logger = logging.Logger(name="relevance_logger")
       logging_utils.set_user_level_logging(logger)
 
-      with mock.patch('logging.root', new=logger):
+      with mock.patch("logging.root", new=logger):
         message = "I'm sorry %s"
         logging_utils.user_logs(message, "dave")
 
       self.assertTrue(fake_stdout.getvalue().endswith(message % "dave\n"))
 
   def test_user_logs_filter(self):
-    with mock.patch('sys.stdout', new=StringIO()) as fake_stdout:
+    with mock.patch("sys.stdout", new=StringIO()) as fake_stdout:
       logger = logging.Logger(name="relevance_logger")
       logging_utils.set_user_level_logging(logger)
 
@@ -70,27 +71,29 @@
 
   def test_capture(self):
     root = logging.RootLogger(logging.DEBUG)
-    with logging_utils.CaptureLogs('foo', root) as log:
-      root.debug('foo')
+    with logging_utils.CaptureLogs("foo", root) as log:
+      root.debug("foo")
       result = log.read()
-    expected = _LOG_HEADER + ': DEBUG foo\n$'
-    if sys.platform == 'win32':
-      expected = expected.replace('\n', '\r\n')
+    expected = _LOG_HEADER + ": DEBUG foo\n$"
+    if sys.platform == "win32":
+      expected = expected.replace("\n", "\r\n")
     self.assertTrue(
-        re.match(expected.encode('utf-8'), result), (expected, result))
+      re.match(expected.encode("utf-8"), result), (expected, result)
+    )
 
   def test_prepare_logging(self):
     root = logging.RootLogger(logging.DEBUG)
-    filepath = os.path.join(self.tmp, 'test.log')
+    filepath = os.path.join(self.tmp, "test.log")
     logging_utils.prepare_logging(filepath, root)
-    root.debug('foo')
-    with open(filepath, 'rb') as f:
+    root.debug("foo")
+    with open(filepath, "rb") as f:
       result = f.read()
     # It'd be nice to figure out a way to ensure it's properly in UTC but it's
     # tricky to do reliably.
-    expected = _LOG_HEADER + ' D: foo\n$'
+    expected = _LOG_HEADER + " D: foo\n$"
     self.assertTrue(
-        re.match(expected.encode('utf-8'), result), (expected, result))
+      re.match(expected.encode("utf-8"), result), (expected, result)
+    )
 
   def test_rotating(self):
     # Create a rotating log. Create a subprocess then delete the file. Make sure
@@ -98,23 +101,24 @@
     # Everything is done in a child process because the called functions mutate
     # the global state.
     r = subprocess.call(
-        [sys.executable, '-u', 'phase1.py', self.tmp],
-        cwd=os.path.join(test_env.TESTS_DIR, 'logging_utils'))
+      [sys.executable, "-u", "phase1.py", self.tmp],
+      cwd=os.path.join(test_env.TESTS_DIR, "logging_utils"),
+    )
     self.assertEqual(0, r)
-    self.assertEqual({'shared.1.log'}, set(os.listdir(self.tmp)))
-    with open(os.path.join(self.tmp, 'shared.1.log'), 'rb') as f:
+    self.assertEqual({"shared.1.log"}, set(os.listdir(self.tmp)))
+    with open(os.path.join(self.tmp, "shared.1.log"), "rb") as f:
       lines = f.read().splitlines()
     expected = [
-      r' I: Parent1',
-      r' I: Child1',
-      r' I: Child2',
-      r' I: Parent2',
+      r" I: Parent1",
+      r" I: Child1",
+      r" I: Child2",
+      r" I: Parent2",
     ]
     for e, l in zip(expected, lines):
-      ex = _LOG_HEADER_PID + e + '$'
-      self.assertTrue(re.match(ex.encode('utf-8'), l), (ex, l))
+      ex = _LOG_HEADER_PID + e + "$"
+      self.assertTrue(re.match(ex.encode("utf-8"), l), (ex, l))
     self.assertEqual(len(expected), len(lines))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
   test_env.main()
diff --git a/tests/lru_test.py b/tests/lru_test.py
index 4563167..c1c4764 100755
--- a/tests/lru_test.py
+++ b/tests/lru_test.py
@@ -16,10 +16,10 @@
 
 def _load_from_raw(state_text):
   """Makes a LRUDict by loading the given JSON from a file."""
-  handle, tmp_name = tempfile.mkstemp(prefix='lru_test')
+  handle, tmp_name = tempfile.mkstemp(prefix="lru_test")
   os.close(handle)
   try:
-    with open(tmp_name, 'w') as f:
+    with open(tmp_name, "w") as f:
       f.write(state_text)
     return lru.LRUDict.load(tmp_name)
   finally:
@@ -31,7 +31,7 @@
 
 def _save_and_load(lru_dict):
   """Saves then reloads a LRUDict instance."""
-  handle, tmp_name = tempfile.mkstemp(prefix='lru_test')
+  handle, tmp_name = tempfile.mkstemp(prefix="lru_test")
   os.close(handle)
   try:
     lru_dict.save(tmp_name)
@@ -81,47 +81,47 @@
     """Tests __nonzero__, __iter, __len__, __getitem__ and __contains__."""
     # Dict with one item.
     lru_dict = lru.LRUDict()
-    lru_dict.add(1, 'one')
+    lru_dict.add(1, "one")
     self.assertTrue(lru_dict)
     self.assertEqual(len(lru_dict), 1)
     self.assertTrue(1 in lru_dict)
     self.assertFalse(2 in lru_dict)
     self.assertTrue(list(lru_dict))
-    self.assertEqual('one', lru_dict[1])
+    self.assertEqual("one", lru_dict[1])
 
   def test_add(self):
-    lru_dict = _prepare_lru_dict([(1, 'one'), (2, 'two'), (3, 'three')])
-    lru_dict.add(1, 'one!!!')
-    expected = [(2, 'two'), (3, 'three'), (1, 'one!!!')]
+    lru_dict = _prepare_lru_dict([(1, "one"), (2, "two"), (3, "three")])
+    lru_dict.add(1, "one!!!")
+    expected = [(2, "two"), (3, "three"), (1, "one!!!")]
     self.assert_same_data(expected, lru_dict)
-    lru_dict.add(0, 'zero')
-    expected = [(2, 'two'), (3, 'three'), (1, 'one!!!'), (0, 'zero')]
+    lru_dict.add(0, "zero")
+    expected = [(2, "two"), (3, "three"), (1, "one!!!"), (0, "zero")]
     self.assert_same_data(expected, lru_dict)
 
   def test_pop_first(self):
-    lru_dict = _prepare_lru_dict([(1, 'one'), (2, 'two'), (3, 'three')])
+    lru_dict = _prepare_lru_dict([(1, "one"), (2, "two"), (3, "three")])
     lru_dict.pop(1)
-    self.assert_same_data([(2, 'two'), (3, 'three')], lru_dict)
+    self.assert_same_data([(2, "two"), (3, "three")], lru_dict)
 
   def test_pop_middle(self):
-    lru_dict = _prepare_lru_dict([(1, 'one'), (2, 'two'), (3, 'three')])
+    lru_dict = _prepare_lru_dict([(1, "one"), (2, "two"), (3, "three")])
     lru_dict.pop(2)
-    self.assert_same_data([(1, 'one'), (3, 'three')], lru_dict)
+    self.assert_same_data([(1, "one"), (3, "three")], lru_dict)
 
   def test_pop_last(self):
-    lru_dict = _prepare_lru_dict([(1, 'one'), (2, 'two'), (3, 'three')])
+    lru_dict = _prepare_lru_dict([(1, "one"), (2, "two"), (3, "three")])
     lru_dict.pop(3)
-    self.assert_same_data([(1, 'one'), (2, 'two')], lru_dict)
+    self.assert_same_data([(1, "one"), (2, "two")], lru_dict)
 
   def test_pop_missing(self):
-    lru_dict = _prepare_lru_dict([(1, 'one'), (2, 'two'), (3, 'three')])
+    lru_dict = _prepare_lru_dict([(1, "one"), (2, "two"), (3, "three")])
     with self.assertRaises(KeyError):
       lru_dict.pop(4)
 
   def test_touch(self):
-    lru_dict = _prepare_lru_dict([(1, 'one'), (2, 'two'), (3, 'three')])
+    lru_dict = _prepare_lru_dict([(1, "one"), (2, "two"), (3, "three")])
     lru_dict.touch(2)
-    self.assert_same_data([(1, 'one'), (3, 'three'), (2, 'two')], lru_dict)
+    self.assert_same_data([(1, "one"), (3, "three"), (2, "two")], lru_dict)
     with self.assertRaises(KeyError):
       lru_dict.touch(4)
 
@@ -132,23 +132,23 @@
     now = 0
     lru_dict.time_fn = lambda: now
 
-    lru_dict.add('ka', 'va')
+    lru_dict.add("ka", "va")
     now += 1
 
-    lru_dict.add('kb', 'vb')
+    lru_dict.add("kb", "vb")
     now += 1
 
-    self.assertEqual(lru_dict.get_oldest(), ('ka', ('va', 0)))
-    self.assertEqual(lru_dict.pop_oldest(), ('ka', ('va', 0)))
-    self.assertEqual(lru_dict.get_oldest(), ('kb', ('vb', 1)))
-    self.assertEqual(lru_dict.pop_oldest(), ('kb', ('vb', 1)))
+    self.assertEqual(lru_dict.get_oldest(), ("ka", ("va", 0)))
+    self.assertEqual(lru_dict.pop_oldest(), ("ka", ("va", 0)))
+    self.assertEqual(lru_dict.get_oldest(), ("kb", ("vb", 1)))
+    self.assertEqual(lru_dict.pop_oldest(), ("kb", ("vb", 1)))
 
   def test_transform(self):
     lru_dict = lru.LRUDict()
-    lru_dict.add('ka', 'va')
-    lru_dict.add('kb', 'vb')
-    lru_dict.transform(lambda k, v: v + '*')
-    self.assert_same_data([('ka', 'va*'), ('kb', 'vb*')], lru_dict)
+    lru_dict.add("ka", "va")
+    lru_dict.add("kb", "vb")
+    lru_dict.transform(lambda k, v: v + "*")
+    self.assert_same_data([("ka", "va*"), ("kb", "vb*")], lru_dict)
 
   def test_load_save_empty(self):
     self.assertFalse(_save_and_load(lru.LRUDict()))
@@ -181,37 +181,48 @@
   def test_corrupted_state_file(self):
     # Loads correct state just fine.
     s = _load_from_raw(
-        json.dumps({
-            'version': lru.CURRENT_VERSION,
-            'items': [
-                ['key1', ['value1', 1]],
-                ['key2', ['value2', 2]],
-            ],
-        }))
+      json.dumps(
+        {
+          "version": lru.CURRENT_VERSION,
+          "items": [
+            ["key1", ["value1", 1]],
+            ["key2", ["value2", 2]],
+          ],
+        }
+      )
+    )
     self.assertIsNotNone(s)
     self.assertEqual(2, len(s))
 
     # Not a json.
     with self.assertRaises(ValueError):
-      _load_from_raw('garbage, not a state')
+      _load_from_raw("garbage, not a state")
 
     # Not a list.
     with self.assertRaises(ValueError):
-      _load_from_raw('{}')
+      _load_from_raw("{}")
 
     # Not a list of pairs.
     with self.assertRaises(ValueError):
-      _load_from_raw(json.dumps([
-          ['key', 'value', 'and whats this?'],
-      ]))
+      _load_from_raw(
+        json.dumps(
+          [
+            ["key", "value", "and whats this?"],
+          ]
+        )
+      )
 
     # Duplicate keys.
     with self.assertRaises(ValueError):
-      _load_from_raw(json.dumps([
-          ['key', 'value'],
-          ['key', 'another_value'],
-      ]))
+      _load_from_raw(
+        json.dumps(
+          [
+            ["key", "value"],
+            ["key", "another_value"],
+          ]
+        )
+      )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
   test_env.main()
diff --git a/tests/net_test.py b/tests/net_test.py
index 7004d97..b60e18b 100755
--- a/tests/net_test.py
+++ b/tests/net_test.py
@@ -29,9 +29,9 @@
   def setUp(self):
     super(RetryLoopMockedTest, self).setUp()
     self._retry_attemps_cls = net.RetryAttempt
-    self.mock(net, 'sleep_before_retry', self.mocked_sleep_before_retry)
-    self.mock(net, 'current_time', self.mocked_current_time)
-    self.mock(net, 'RetryAttempt', self.mocked_retry_attempt)
+    self.mock(net, "sleep_before_retry", self.mocked_sleep_before_retry)
+    self.mock(net, "current_time", self.mocked_current_time)
+    self.mock(net, "RetryAttempt", self.mocked_retry_attempt)
     self.sleeps = []
     self.attempts = []
 
@@ -77,43 +77,53 @@
 class HttpErrorTest(unittest.TestCase):
   def test_description_simple(self):
     e = net_utils.make_fake_error(
-        code=404,
-        url='/url',
-        content=b'Response\nBody',
-        headers={
-            'Header-A': 'value-a',
-            'X-Skipped': 'zzz'
-        })
-    self.assertEqual(e.description(False), 'Server returned HTTP code 404')
-    self.assertEqual(e.description(True), '\n'.join([
-        'Server returned HTTP code 404',
-        '----------',
-        'Content-length: 13',
-        'Header-a: value-a',
-        '',
-        'Response',
-        'Body',
-        '----------',
-    ]))
+      code=404,
+      url="/url",
+      content=b"Response\nBody",
+      headers={"Header-A": "value-a", "X-Skipped": "zzz"},
+    )
+    self.assertEqual(e.description(False), "Server returned HTTP code 404")
+    self.assertEqual(
+      e.description(True),
+      "\n".join(
+        [
+          "Server returned HTTP code 404",
+          "----------",
+          "Content-length: 13",
+          "Header-a: value-a",
+          "",
+          "Response",
+          "Body",
+          "----------",
+        ]
+      ),
+    )
 
   def test_description_json_good(self):
     e = net_utils.make_fake_error(
-        code=404,
-        url='/url',
-        content=b'{"error": "inner error message"}',
-        headers={'Content-Type': 'application/json'})
+      code=404,
+      url="/url",
+      content=b'{"error": "inner error message"}',
+      headers={"Content-Type": "application/json"},
+    )
     self.assertEqual(
-        e.description(False),
-        'Server returned HTTP code 404 - inner error message')
-    self.assertEqual(e.description(True), '\n'.join([
-        'Server returned HTTP code 404 - inner error message',
-        '----------',
-        'Content-length: 32',
-        'Content-type: application/json',
-        '',
-        '{"error": "inner error message"}',
-        '----------',
-    ]))
+      e.description(False),
+      "Server returned HTTP code 404 - inner error message",
+    )
+    self.assertEqual(
+      e.description(True),
+      "\n".join(
+        [
+          "Server returned HTTP code 404 - inner error message",
+          "----------",
+          "Content-length: 32",
+          "Content-type: application/json",
+          "",
+          '{"error": "inner error message"}',
+          "----------",
+        ]
+      ),
+    )
 
 
 class HttpServiceTest(RetryLoopMockedTest):
@@ -121,84 +131,89 @@
 
   @staticmethod
   def mocked_http_service(
-      url='http://example.com',
-      perform_request=None,
-      authorize=None,
-      login=None):
+    url="http://example.com", perform_request=None, authorize=None, login=None
+  ):
 
     class MockedAuthenticator(authenticators.Authenticator):
       supports_login = True
+
       def authorize(self, request):
         return authorize(request) if authorize else None
+
       def login(self, allow_user_interaction):
         return login(allow_user_interaction) if login else False
 
     class MockedRequestEngine:
-
       @net.maybe_inject_user_agent
       def perform_request(self, request):
         return perform_request(request) if perform_request else None
 
     return net.HttpService(
-        url,
-        authenticator=MockedAuthenticator(),
-        engine=MockedRequestEngine())
+      url, authenticator=MockedAuthenticator(), engine=MockedRequestEngine()
+    )
 
   def test_request_GET_success(self):
-    service_url = 'http://example.com'
-    request_url = '/some_request'
-    response = b'True'
+    service_url = "http://example.com"
+    request_url = "/some_request"
+    response = b"True"
 
     def mock_perform_request(request):
       self.assertTrue(
-          request.get_full_url().startswith(service_url + request_url))
+        request.get_full_url().startswith(service_url + request_url)
+      )
       return net_utils.make_fake_response(response, request.get_full_url())
 
-    service = self.mocked_http_service(url=service_url,
-        perform_request=mock_perform_request)
+    service = self.mocked_http_service(
+      url=service_url, perform_request=mock_perform_request
+    )
     self.assertEqual(service.request(request_url).read(), response)
     self.assertAttempts(1, net.URL_OPEN_TIMEOUT)
 
   def test_request_POST_success(self):
-    service_url = 'http://example.com'
-    request_url = '/some_request'
-    response = b'True'
+    service_url = "http://example.com"
+    request_url = "/some_request"
+    response = b"True"
 
     def mock_perform_request(request):
       self.assertTrue(
-          request.get_full_url().startswith(service_url + request_url))
-      self.assertEqual(b'', request.body)
+        request.get_full_url().startswith(service_url + request_url)
+      )
+      self.assertEqual(b"", request.body)
       return net_utils.make_fake_response(response, request.get_full_url())
 
-    service = self.mocked_http_service(url=service_url,
-        perform_request=mock_perform_request)
+    service = self.mocked_http_service(
+      url=service_url, perform_request=mock_perform_request
+    )
     self.assertEqual(service.request(request_url, data={}).read(), response)
     self.assertAttempts(1, net.URL_OPEN_TIMEOUT)
 
   def test_request_PUT_success(self):
-    service_url = 'http://example.com'
-    request_url = '/some_request'
-    request_body = b'data_body'
-    response_body = b'True'
-    content_type = 'application/octet-stream'
+    service_url = "http://example.com"
+    request_url = "/some_request"
+    request_body = b"data_body"
+    response_body = b"True"
+    content_type = "application/octet-stream"
 
     def mock_perform_request(request):
       self.assertTrue(
-          request.get_full_url().startswith(service_url + request_url))
+        request.get_full_url().startswith(service_url + request_url)
+      )
       self.assertEqual(request_body, request.body)
-      self.assertEqual(request.method, 'PUT')
-      self.assertEqual(request.headers['Content-Type'], content_type)
+      self.assertEqual(request.method, "PUT")
+      self.assertEqual(request.headers["Content-Type"], content_type)
       return net_utils.make_fake_response(response_body, request.get_full_url())
 
-    service = self.mocked_http_service(url=service_url,
-        perform_request=mock_perform_request)
-    response = service.request(request_url,
-        data=request_body, content_type=content_type, method='PUT')
+    service = self.mocked_http_service(
+      url=service_url, perform_request=mock_perform_request
+    )
+    response = service.request(
+      request_url, data=request_body, content_type=content_type, method="PUT"
+    )
     self.assertEqual(response.read(), response_body)
     self.assertAttempts(1, net.URL_OPEN_TIMEOUT)
 
   def test_request_success_after_failure(self):
-    response = b'True'
+    response = b"True"
     attempts = []
 
     def mock_perform_request(request):
@@ -208,84 +223,97 @@
       return net_utils.make_fake_response(response, request.get_full_url())
 
     service = self.mocked_http_service(perform_request=mock_perform_request)
-    self.assertEqual(service.request('/', data={}).read(), response)
+    self.assertEqual(service.request("/", data={}).read(), response)
     self.assertAttempts(2, net.URL_OPEN_TIMEOUT)
 
   def test_request_failure_max_attempts_default(self):
     def mock_perform_request(_request):
       raise net.ConnectionError()
+
     service = self.mocked_http_service(perform_request=mock_perform_request)
-    self.assertEqual(service.request('/'), None)
+    self.assertEqual(service.request("/"), None)
     self.assertAttempts(net.URL_OPEN_MAX_ATTEMPTS, net.URL_OPEN_TIMEOUT)
 
   def test_request_failure_max_attempts(self):
     def mock_perform_request(_request):
       raise net.ConnectionError()
+
     service = self.mocked_http_service(perform_request=mock_perform_request)
-    self.assertEqual(service.request('/', max_attempts=23), None)
+    self.assertEqual(service.request("/", max_attempts=23), None)
     self.assertAttempts(23, net.URL_OPEN_TIMEOUT)
 
   def test_request_failure_timeout(self):
     def mock_perform_request(_request):
       raise net.ConnectionError()
+
     service = self.mocked_http_service(perform_request=mock_perform_request)
-    self.assertEqual(service.request('/', max_attempts=10000), None)
+    self.assertEqual(service.request("/", max_attempts=10000), None)
     self.assertAttempts(int(net.URL_OPEN_TIMEOUT) + 1, net.URL_OPEN_TIMEOUT)
 
   def test_request_failure_timeout_default(self):
     def mock_perform_request(_request):
       raise net.ConnectionError()
+
     service = self.mocked_http_service(perform_request=mock_perform_request)
-    self.assertEqual(service.request('/', timeout=10.), None)
+    self.assertEqual(service.request("/", timeout=10.0), None)
     self.assertAttempts(11, 10.0)
 
   def test_request_HTTP_error_no_retry(self):
     count = []
+
     def mock_perform_request(request):
       count.append(request)
       raise net_utils.make_fake_error(400, request.get_full_url())
 
     service = self.mocked_http_service(perform_request=mock_perform_request)
-    self.assertEqual(service.request('/', data={}), None)
+    self.assertEqual(service.request("/", data={}), None)
     self.assertEqual(1, len(count))
     self.assertAttempts(1, net.URL_OPEN_TIMEOUT)
 
   def test_request_expected_HTTP_error_code(self):
-    content = b'data'
+    content = b"data"
 
     count = []
+
     def mock_perform_request(request):
       count.append(request)
       raise net_utils.make_fake_error(
-          400, request.get_full_url(), content=content)
+        400, request.get_full_url(), content=content
+      )
 
     service = self.mocked_http_service(perform_request=mock_perform_request)
-    response = service.request('/', data={}, expected_error_codes=(400,))
+    response = service.request("/", data={}, expected_error_codes=(400,))
     self.assertEqual(400, response.code)
     self.assertEqual(content, response.read())
     self.assertEqual(1, len(count))
     self.assertAttempts(1, net.URL_OPEN_TIMEOUT)
 
   def test_request_HTTP_error_retry_404_endpoints(self):
-    response = b'data'
+    response = b"data"
     attempts = []
 
     def mock_perform_request(request):
       attempts.append(request)
       if len(attempts) == 1:
-        raise net_utils.make_fake_error(404, request.get_full_url(), headers={
-          'Content-Type': 'application/text; charset=ASCII',
-        })
+        raise net_utils.make_fake_error(
+          404,
+          request.get_full_url(),
+          headers={
+            "Content-Type": "application/text; charset=ASCII",
+          },
+        )
       return net_utils.make_fake_response(response, request.get_full_url())
 
     service = self.mocked_http_service(perform_request=mock_perform_request)
-    result = service.request('/_ah/api/foo/v1/bar', )
+    result = service.request(
+      "/_ah/api/foo/v1/bar",
+    )
     self.assertEqual(result.read(), response)
     self.assertAttempts(2, net.URL_OPEN_TIMEOUT)
 
-  @parameterized.expand([(408, ), (429, ), (500, ), (503, ), (599, )])
+  @parameterized.expand([(408,), (429,), (500,), (503,), (599,)])
   def test_request_HTTP_error_with_retry(self, status_code):
-    response = b'response'
+    response = b"response"
     attempts = []
 
     def mock_perform_request(request):
@@ -295,35 +323,37 @@
       return net_utils.make_fake_response(response, request.get_full_url())
 
     service = self.mocked_http_service(perform_request=mock_perform_request)
-    self.assertTrue(service.request('/', data={}).read(), response)
+    self.assertTrue(service.request("/", data={}).read(), response)
     self.assertAttempts(2, net.URL_OPEN_TIMEOUT)
 
   def test_auth_success(self):
     calls = []
-    response = b'response'
+    response = b"response"
 
     def mock_perform_request(request):
-      calls.append('request')
-      if 'login' not in calls:
+      calls.append("request")
+      if "login" not in calls:
         raise net_utils.make_fake_error(403, request.get_full_url())
       return net_utils.make_fake_response(response, request.get_full_url())
 
     def mock_authorize(request):
       self.assertTrue(request)
-      calls.append('authorize')
+      calls.append("authorize")
 
     def mock_login(allow_user_interaction):
       self.assertFalse(allow_user_interaction)
-      calls.append('login')
+      calls.append("login")
       return True
 
     service = self.mocked_http_service(
-        perform_request=mock_perform_request,
-        authorize=mock_authorize,
-        login=mock_login)
-    self.assertEqual(service.request('/').read(), response)
+      perform_request=mock_perform_request,
+      authorize=mock_authorize,
+      login=mock_login,
+    )
+    self.assertEqual(service.request("/").read(), response)
     self.assertEqual(
-        ['authorize', 'request', 'login', 'authorize', 'request'], calls)
+      ["authorize", "request", "login", "authorize", "request"], calls
+    )
     self.assertAttempts(2, net.URL_OPEN_TIMEOUT)
     self.assertSleeps(0)
 
@@ -338,34 +368,39 @@
       count.append(1)
       return False
 
-    service = self.mocked_http_service(perform_request=mock_perform_request,
-        login=mock_login)
-    self.assertEqual(service.request('/'), None)
+    service = self.mocked_http_service(
+      perform_request=mock_perform_request, login=mock_login
+    )
+    self.assertEqual(service.request("/"), None)
     self.assertEqual(len(count), 1)
     self.assertAttempts(1, net.URL_OPEN_TIMEOUT)
 
   def test_url_read(self):
     # Successfully reads the data.
-    self.mock(net, 'url_open',
-              lambda url, **_kwargs: net_utils.make_fake_response(b'111', url))
-    self.assertEqual(net.url_read('https://fake_url.com/test'), b'111')
+    self.mock(
+      net,
+      "url_open",
+      lambda url, **_kwargs: net_utils.make_fake_response(b"111", url),
+    )
+    self.assertEqual(net.url_read("https://fake_url.com/test"), b"111")
 
     # Respects url_open connection errors.
-    self.mock(net, 'url_open', lambda _url, **_kwargs: None)
-    self.assertIsNone(net.url_read('https://fake_url.com/test'))
+    self.mock(net, "url_open", lambda _url, **_kwargs: None)
+    self.assertIsNone(net.url_read("https://fake_url.com/test"))
 
     # Respects read timeout errors.
     def timeouting_http_response(url):
       def read_mock(_size=None):
         raise net.TimeoutError()
 
-      response = net_utils.make_fake_response(b'', url)
-      self.mock(response, 'read', read_mock)
+      response = net_utils.make_fake_response(b"", url)
+      self.mock(response, "read", read_mock)
       return response
 
-    self.mock(net, 'url_open',
-        lambda url, **_kwargs: timeouting_http_response(url))
-    self.assertIsNone(net.url_read('https://fake_url.com/test'))
+    self.mock(
+      net, "url_open", lambda url, **_kwargs: timeouting_http_response(url)
+    )
+    self.assertIsNone(net.url_read("https://fake_url.com/test"))
 
   def test_url_retrieve(self):
     # Successfully reads the data.
@@ -373,33 +408,40 @@
     def fake_open(_filepath, _mode):
       yield io.BytesIO()
 
-    self.mock(io, 'open', fake_open)
-    self.mock(net, 'url_open',
-              lambda url, **_kwargs: net_utils.make_fake_response(b'111', url))
+    self.mock(io, "open", fake_open)
+    self.mock(
+      net,
+      "url_open",
+      lambda url, **_kwargs: net_utils.make_fake_response(b"111", url),
+    )
     self.assertEqual(
-        True, net.url_retrieve('filepath', 'https://localhost/test'))
+      True, net.url_retrieve("filepath", "https://localhost/test")
+    )
 
     # Respects url_open connection errors.
-    self.mock(net, 'url_open', lambda _url, **_kwargs: None)
+    self.mock(net, "url_open", lambda _url, **_kwargs: None)
     self.assertEqual(
-        False, net.url_retrieve('filepath', 'https://localhost/test'))
+      False, net.url_retrieve("filepath", "https://localhost/test")
+    )
 
     # Respects read timeout errors.
     def timeouting_http_response(url):
       def iter_content_mock(_size=None):
         raise net.TimeoutError()
 
-      response = net_utils.make_fake_response(b'', url)
-      self.mock(response, 'iter_content', iter_content_mock)
+      response = net_utils.make_fake_response(b"", url)
+      self.mock(response, "iter_content", iter_content_mock)
       return response
 
     removed = []
-    self.mock(os, 'remove', removed.append)
-    self.mock(net, 'url_open',
-        lambda url, **_kwargs: timeouting_http_response(url))
+    self.mock(os, "remove", removed.append)
+    self.mock(
+      net, "url_open", lambda url, **_kwargs: timeouting_http_response(url)
+    )
     self.assertEqual(
-        False, net.url_retrieve('filepath', 'https://localhost/test'))
-    self.assertEqual(['filepath'], removed)
+      False, net.url_retrieve("filepath", "https://localhost/test")
+    )
+    self.assertEqual(["filepath"], removed)
 
   def test_request_has_user_agent(self):
 
@@ -407,32 +449,32 @@
       return request
 
     service = self.mocked_http_service(perform_request=mock_perform_request)
-    user_agent = 'Py/Foo'
+    user_agent = "Py/Foo"
     net.set_user_agent(user_agent)
-    request_headers = service.request('/', data={}).headers
-    self.assertEqual(request_headers['User-Agent'], user_agent)
+    request_headers = service.request("/", data={}).headers
+    self.assertEqual(request_headers["User-Agent"], user_agent)
 
     net.set_user_agent(None)
-    request_headers = service.request('/', data={}).headers
-    self.assertNotIn('User-Agent', request_headers)
+    request_headers = service.request("/", data={}).headers
+    self.assertNotIn("User-Agent", request_headers)
 
 
 class TestNetFunctions(auto_stub.TestCase):
   def test_fix_url(self):
     data = [
-      ('http://foo.com/', 'http://foo.com'),
-      ('https://foo.com/', 'https://foo.com'),
-      ('https://foo.com', 'https://foo.com'),
-      ('https://foo.com/a', 'https://foo.com/a'),
-      ('https://foo.com/a/', 'https://foo.com/a'),
-      ('https://foo.com:8080/a/', 'https://foo.com:8080/a'),
-      ('foo.com', 'https://foo.com'),
-      ('foo.com/', 'https://foo.com'),
-      ('foo.com/a/', 'https://foo.com/a'),
+      ("http://foo.com/", "http://foo.com"),
+      ("https://foo.com/", "https://foo.com"),
+      ("https://foo.com", "https://foo.com"),
+      ("https://foo.com/a", "https://foo.com/a"),
+      ("https://foo.com/a/", "https://foo.com/a"),
+      ("https://foo.com:8080/a/", "https://foo.com:8080/a"),
+      ("foo.com", "https://foo.com"),
+      ("foo.com/", "https://foo.com"),
+      ("foo.com/a/", "https://foo.com/a"),
     ]
     for value, expected in data:
       self.assertEqual(expected, net.fix_url(value))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
   test_env.main()
diff --git a/tests/net_utils.py b/tests/net_utils.py
index 08ac8a6..63a37b6 100644
--- a/tests/net_utils.py
+++ b/tests/net_utils.py
@@ -15,37 +15,41 @@
   """Returns HttpResponse with predefined content, useful in tests."""
   assert isinstance(content, bytes), content
   headers = dict(headers or {})
-  headers['Content-Length'] = len(content)
+  headers["Content-Length"] = len(content)
 
   class _Fake:
     def __init__(self):
       self.content = content
+
     def iter_content(self, chunk_size):
       c = self.content
       while c:
         yield c[:chunk_size]
         c = c[chunk_size:]
+
     def read(self):
       return self.content
+
   return net.HttpResponse(_Fake(), url, code, headers)
 
 
 def make_fake_error(code, url, content=None, headers=None):
   """Returns HttpError that represents the given response, useful in tests."""
   if content is None:
-    content = b'Fake error body for code %d' % code
+    content = b"Fake error body for code %d" % code
   if headers is None:
-    headers = {'Content-Type': 'text/plain'}
+    headers = {"Content-Type": "text/plain"}
   return net.HttpError(make_fake_response(content, url, code, headers))
 
 
 class TestCase(auto_stub.TestCase):
   """Mocks out url_open() calls."""
+
   def setUp(self):
     super(TestCase, self).setUp()
-    self.mock(net, 'url_open', self._url_open)
-    self.mock(net, 'url_read_json', self._url_read_json)
-    self.mock(net, 'sleep_before_retry', lambda *_: None)
+    self.mock(net, "url_open", self._url_open)
+    self.mock(net, "url_read_json", self._url_read_json)
+    self.mock(net, "sleep_before_retry", lambda *_: None)
     self._lock = threading.Lock()
     self._requests = []
 
@@ -76,17 +80,17 @@
       self._requests = requests
 
   def _url_open(self, url, **kwargs):
-    logging.warning('url_open(%s, %s)', url[:500], str(kwargs)[:500])
+    logging.warning("url_open(%s, %s)", url[:500], str(kwargs)[:500])
     with self._lock:
       if not self._requests:
         return None
       # Ignore 'stream' argument, it's not important for these tests.
-      kwargs.pop('stream', None)
+      kwargs.pop("stream", None)
       for i, n in enumerate(self._requests):
         if n[0] == url:
           data = self._requests.pop(i)
           if len(data) != 4:
-            self.fail('Expected normal request, got json data; %s' % url)
+            self.fail("Expected normal request, got json data; %s" % url)
           _, expected_kwargs, result, headers = data
           if callable(expected_kwargs):
             expected_kwargs(kwargs)
@@ -95,23 +99,23 @@
           if result is not None or headers is not None:
             return make_fake_response(result, url, headers=headers)
           return None
-    self.fail('Unknown request %s' % url)
+    self.fail("Unknown request %s" % url)
     return None
 
   def _url_read_json(self, url, **kwargs):
-    logging.warning('url_read_json(%s, %s)', url[:500], str(kwargs)[:500])
+    logging.warning("url_read_json(%s, %s)", url[:500], str(kwargs)[:500])
     with self._lock:
       # Ignore 'stream' argument, it's not important for these tests.
-      kwargs.pop('stream', None)
+      kwargs.pop("stream", None)
       for i, n in enumerate(self._requests):
         if n[0] == url:
           data = self._requests.pop(i)
           if len(data) != 3:
-            self.fail('Expected json request, got normal data; %s' % url)
+            self.fail("Expected json request, got normal data; %s" % url)
           _, expected_kwargs, result = data
           if callable(expected_kwargs):
             expected_kwargs(kwargs)
           else:
             self.assertEqual(expected_kwargs, kwargs)
           return result
-    self.fail('Unknown request %s %s' % (url, kwargs))
+    self.fail("Unknown request %s %s" % (url, kwargs))
diff --git a/tests/run_isolated_smoke_test.py b/tests/run_isolated_smoke_test.py
index 12e5cc7..2681eae 100755
--- a/tests/run_isolated_smoke_test.py
+++ b/tests/run_isolated_smoke_test.py
@@ -30,15 +30,14 @@
 
 
 _LUCI_GO = os.path.join(
-    os.path.dirname(os.path.dirname(os.path.dirname(
-        os.path.abspath(__file__)))), 'luci-go')
+  os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))),
+  "luci-go",
+)
 
-OUTPUT_CONTENT = 'foooo'
+OUTPUT_CONTENT = "foooo"
 CONTENTS = {
-    'file1.txt':
-    b'File1\n',
-    'repeated_files.py':
-    textwrap.dedent("""
+  "file1.txt": b"File1\n",
+  "repeated_files.py": textwrap.dedent("""
       from __future__ import print_function
       import os, sys
       expected = ['file1.txt', 'file1_copy.txt', 'repeated_files.py']
@@ -51,8 +50,7 @@
             file=sys.stderr)
         sys.exit(1)
       print('Success')""").encode(),
-    'max_path.py':
-    textwrap.dedent("""
+  "max_path.py": textwrap.dedent("""
       from __future__ import print_function
       import os, sys
       prefix = '\\\\\\\\?\\\\' if sys.platform == 'win32' else ''
@@ -63,22 +61,23 @@
           print('Unexpected content: %s' % actual, file=sys.stderr)
           sys.exit(1)
       print('Success')""").encode(),
-    'output.py':
-    textwrap.dedent("""
+  "output.py": textwrap.dedent(
+    """
       import sys
       with open(sys.argv[1], 'w') as fh:
-        fh.writelines(['{}'])""".format(OUTPUT_CONTENT)).encode(),
+        fh.writelines(['{}'])""".format(OUTPUT_CONTENT)
+  ).encode(),
 }
 
 
-CMD_REPEATED_FILES = ['python3', 'repeated_files.py']
+CMD_REPEATED_FILES = ["python3", "repeated_files.py"]
 
-CMD_OUTPUT = ['python3', 'output.py', '${ISOLATED_OUTDIR}/foo.txt']
+CMD_OUTPUT = ["python3", "output.py", "${ISOLATED_OUTDIR}/foo.txt"]
 
 _repeated_files = {
-    'file1.txt': CONTENTS['file1.txt'],
-    'file1_copy.txt': CONTENTS['file1.txt'],
-    'repeated_files.py': CONTENTS['repeated_files.py'],
+  "file1.txt": CONTENTS["file1.txt"],
+  "file1_copy.txt": CONTENTS["file1.txt"],
+  "repeated_files.py": CONTENTS["repeated_files.py"],
 }
 
 
@@ -86,17 +85,17 @@
   """Returns the list of all the files in a tree."""
   actual = []
   for root, _dirs, files in os.walk(directory):
-    actual.extend(os.path.join(root, f)[len(directory)+1:] for f in files)
+    actual.extend(os.path.join(root, f)[len(directory) + 1 :] for f in files)
   return sorted(actual)
 
 
 def read_content(filepath):
-  with open(filepath, 'rb') as f:
+  with open(filepath, "rb") as f:
     return f.read()
 
 
 def write_content(filepath, content):
-  with open(filepath, 'wb') as f:
+  with open(filepath, "wb") as f:
     f.write(content)
 
 
@@ -106,8 +105,8 @@
   Includes |root| as '.'.
   """
   out = {}
-  offset = len(root.rstrip('/\\')) + 1
-  out['.'] = oct(os.stat(root).st_mode)
+  offset = len(root.rstrip("/\\")) + 1
+  out["."] = oct(os.stat(root).st_mode)
   for dirpath, dirnames, filenames in os.walk(root):
     for filename in filenames:
       p = os.path.join(dirpath, filename)
@@ -120,8 +119,8 @@
 
 def load_isolated_stats(stats_json_path, key):
   actual = json.loads(read_content(stats_json_path))
-  stats = actual['stats']['isolated'].get(key)
-  for k in ['items_cold', 'items_hot']:
+  stats = actual["stats"]["isolated"].get(key)
+  for k in ["items_cold", "items_hot"]:
     if not stats[k]:
       continue
     stats[k] = large.unpack(base64.b64decode(stats[k]))
@@ -131,17 +130,18 @@
 class RunIsolatedTest(unittest.TestCase):
   def setUp(self):
     super(RunIsolatedTest, self).setUp()
-    self.tempdir = run_isolated.make_temp_dir('run_isolated_smoke_test',
-                                              test_env.CLIENT_DIR)
+    self.tempdir = run_isolated.make_temp_dir(
+      "run_isolated_smoke_test", test_env.CLIENT_DIR
+    )
     logging.debug(self.tempdir)
-    self._root_dir = os.path.join(self.tempdir, 'w')
+    self._root_dir = os.path.join(self.tempdir, "w")
     # The run_isolated local cache.
-    self._named_cache_dir = os.path.join(self.tempdir, 'n')
-    self._cipd_cache_dir = os.path.join(self.tempdir, 'cipd')
-    self._cipd_packages_cache_dir = os.path.join(self._cipd_cache_dir, 'cache')
+    self._named_cache_dir = os.path.join(self.tempdir, "n")
+    self._cipd_cache_dir = os.path.join(self.tempdir, "cipd")
+    self._cipd_packages_cache_dir = os.path.join(self._cipd_cache_dir, "cache")
 
-    self._cas_cache_dir = os.path.join(self.tempdir, 'c')
-    self._cas_kvs = os.path.join(self.tempdir, 'cas_kvs')
+    self._cas_cache_dir = os.path.join(self.tempdir, "c")
+    self._cas_kvs = os.path.join(self.tempdir, "cas_kvs")
 
     self._fakecas = cas_util.LocalCAS(self.tempdir)
     self._fakecas.start()
@@ -156,43 +156,45 @@
 
   def _run_cmd(self, cmd):
     pipe = subprocess.PIPE
-    logging.debug(' '.join(cmd))
+    logging.debug(" ".join(cmd))
     env = os.environ.copy()
-    env['RUN_ISOLATED_CAS_ADDRESS'] = self._cas_addr
-    proc = subprocess.Popen(cmd,
-                            stdout=pipe,
-                            stderr=pipe,
-                            universal_newlines=True,
-                            cwd=self.tempdir,
-                            env=env)
+    env["RUN_ISOLATED_CAS_ADDRESS"] = self._cas_addr
+    proc = subprocess.Popen(
+      cmd,
+      stdout=pipe,
+      stderr=pipe,
+      universal_newlines=True,
+      cwd=self.tempdir,
+      env=env,
+    )
     out, err = proc.communicate()
     return out, err, proc.returncode
 
   def _run(self, args):
-    cmd = [sys.executable, os.path.join(test_env.CLIENT_DIR, 'run_isolated.py')]
+    cmd = [sys.executable, os.path.join(test_env.CLIENT_DIR, "run_isolated.py")]
     cmd.extend(args)
     return self._run_cmd(cmd)
 
   def _run_cas(self, args):
-    return self._run_cmd([os.path.join(_LUCI_GO, 'cas')] + args)
+    return self._run_cmd([os.path.join(_LUCI_GO, "cas")] + args)
 
   def _download_from_cas(self, root_digest, dest):
     """Downloads files from CAS."""
     cmd = [
-        'download',
-        '-cas-addr',
-        self._cas_addr,
-        '-digest',
-        root_digest,
-        '-cache-dir',
-        self._cas_cache_dir,
-        '-dir',
-        dest,
-        '-kvs-dir',
-        self._cas_kvs,
+      "download",
+      "-cas-addr",
+      self._cas_addr,
+      "-digest",
+      root_digest,
+      "-cache-dir",
+      self._cas_cache_dir,
+      "-dir",
+      dest,
+      "-kvs-dir",
+      self._cas_kvs,
     ]
     _, err, returncode = self._run_cas(cmd)
-    self.assertEqual('', err)
+    self.assertEqual("", err)
     self.assertEqual(0, returncode)
 
   def _cmd_args(self, digest):
@@ -201,10 +203,10 @@
     Returns a list of the required arguments.
     """
     return [
-        '--cas-digest',
-        digest,
-        '--cas-cache',
-        self._cas_cache_dir,
+      "--cas-digest",
+      digest,
+      "--cas-cache",
+      self._cas_cache_dir,
     ]
 
   def assertTreeModes(self, root, expected):
@@ -218,9 +220,9 @@
                 ints.
     """
     actual = tree_modes(root)
-    if sys.platform == 'win32':
+    if sys.platform == "win32":
       index = 2
-    elif sys.platform == 'darwin':
+    elif sys.platform == "darwin":
       index = 1
     else:
       index = 0
@@ -228,15 +230,17 @@
     self.assertEqual(expected_mangled, actual)
 
   def assertEndsWith(self, expected_ending, output):
-    """ Tests whether output ends with expected_ending"""
-    self.assertRegex(output,
-                     re.compile("(\\s|\\S)*%s$" % re.escape(expected_ending)))
+    """Tests whether output ends with expected_ending"""
+    self.assertRegex(
+      output, re.compile("(\\s|\\S)*%s$" % re.escape(expected_ending))
+    )
 
   def test_simple(self):
     out, err, returncode = self._run(
-        ['--', 'python3', '-c', 'print("no --root-dir")'])
-    self.assertEndsWith('no --root-dir\n', out)
-    self.assertEqual('', err)
+      ["--", "python3", "-c", 'print("no --root-dir")']
+    )
+    self.assertEndsWith("no --root-dir\n", out)
+    self.assertEqual("", err)
     self.assertEqual(0, returncode)
 
   def test_isolated_normal(self):
@@ -244,15 +248,16 @@
     # digest), listed under two different names and ensure both are created.
     cas_digest = self._fakecas.archive_files(_repeated_files)
     expected = [
-        'state.json',
-        cas_util.cache_hash(CONTENTS['file1.txt']),
-        cas_util.cache_hash(CONTENTS['repeated_files.py']),
+      "state.json",
+      cas_util.cache_hash(CONTENTS["file1.txt"]),
+      cas_util.cache_hash(CONTENTS["repeated_files.py"]),
     ]
 
     out, err, returncode = self._run(
-        self._cmd_args(cas_digest) + ['--'] + CMD_REPEATED_FILES)
-    self.assertEqual('', cas_util.filter_out_go_logs(err))
-    self.assertEndsWith('Success\n', out)
+      self._cmd_args(cas_digest) + ["--"] + CMD_REPEATED_FILES
+    )
+    self.assertEqual("", cas_util.filter_out_go_logs(err))
+    self.assertEndsWith("Success\n", out)
     self.assertEqual(0, returncode)
     actual = list_files_tree(self._cas_cache_dir)
     self.assertEqual(sorted(set(expected)), actual)
@@ -260,54 +265,60 @@
   def test_isolated_max_path(self):
     # Make sure we can map and delete a tree that has paths longer than
     # MAX_PATH.
-    cas_digest = self._fakecas.archive_files({
-        os.path.join('a' * 200, 'b' * 200):
-        CONTENTS['file1.txt'],
-        'max_path.py':
-        CONTENTS['max_path.py'],
-    })
+    cas_digest = self._fakecas.archive_files(
+      {
+        os.path.join("a" * 200, "b" * 200): CONTENTS["file1.txt"],
+        "max_path.py": CONTENTS["max_path.py"],
+      }
+    )
     expected = [
-        'state.json',
-        cas_util.cache_hash(CONTENTS['file1.txt']),
-        cas_util.cache_hash(CONTENTS['max_path.py']),
+      "state.json",
+      cas_util.cache_hash(CONTENTS["file1.txt"]),
+      cas_util.cache_hash(CONTENTS["max_path.py"]),
     ]
     out, err, returncode = self._run(
-        self._cmd_args(cas_digest) + ['--', 'python3', 'max_path.py'])
+      self._cmd_args(cas_digest) + ["--", "python3", "max_path.py"]
+    )
     err = cas_util.filter_out_go_logs(err)
-    self.assertEqual('', err)
-    self.assertEndsWith('Success\n', out)
+    self.assertEqual("", err)
+    self.assertEndsWith("Success\n", out)
     self.assertEqual(0, returncode)
     actual = list_files_tree(self._cas_cache_dir)
     self.assertEqual(sorted(set(expected)), actual)
 
   def test_isolated_fail_empty_args(self):
     out, err, returncode = self._run([])
-    self.assertEndsWith('Starting run_isolated script', out)
+    self.assertEndsWith("Starting run_isolated script", out)
     self.assertEqual(
-        'Usage: run_isolated.py <options> [command to run or extra args]\n\n'
-        'run_isolated.py: error: command to run is required.\n', err)
+      "Usage: run_isolated.py <options> [command to run or extra args]\n\n"
+      "run_isolated.py: error: command to run is required.\n",
+      err,
+    )
     self.assertEqual(2, returncode)
     actual = list_files_tree(self._cas_cache_dir)
     self.assertEqual([], actual)
 
   def _test_corruption_common(self, new_content):
-    cas_digest = self._fakecas.archive_files({
-        'file1.txt': CONTENTS['file1.txt'],
-    })
-    file1_hash = cas_util.cache_hash(CONTENTS['file1.txt'])
+    cas_digest = self._fakecas.archive_files(
+      {
+        "file1.txt": CONTENTS["file1.txt"],
+      }
+    )
+    file1_hash = cas_util.cache_hash(CONTENTS["file1.txt"])
 
     # Run the test once to generate the cache.
     # The weird file mode is because of test_env.py that sets umask(0070).
     out, err, returncode = self._run(
-        self._cmd_args(cas_digest) + ['--', 'python3', '-V'])
+      self._cmd_args(cas_digest) + ["--", "python3", "-V"]
+    )
     self.assertEqual(0, returncode, (out, err, returncode))
     expected = {
-        '.': (0o40707, 0o40707, 0o40777),
-        'state.json': (0o100606, 0o100606, 0o100666),
-        # The reason for 0100666 on Windows is that the file node had to be
-        # modified to delete the hardlinked node. The read only bit is reset on
-        # load.
-        file1_hash: (0o100604, 0o100604, 0o100604),
+      ".": (0o40707, 0o40707, 0o40777),
+      "state.json": (0o100606, 0o100606, 0o100666),
+      # The reason for 0100666 on Windows is that the file node had to be
+      # modified to delete the hardlinked node. The read only bit is reset on
+      # load.
+      file1_hash: (0o100604, 0o100604, 0o100604),
     }
     self.assertTreeModes(self._cas_cache_dir, expected)
 
@@ -317,58 +328,64 @@
     os.chmod(cached_file_path, 0o600)
     write_content(cached_file_path, new_content)
     os.chmod(cached_file_path, previous_mode)
-    logging.info('Modified %s', cached_file_path)
+    logging.info("Modified %s", cached_file_path)
     # Ensure that the cache has an invalid file.
-    self.assertNotEqual(CONTENTS['file1.txt'], read_content(cached_file_path))
+    self.assertNotEqual(CONTENTS["file1.txt"], read_content(cached_file_path))
 
     # Clean up the cache
-    out, err, returncode = self._run([
-        '--clean',
-        '--cas-cache',
+    out, err, returncode = self._run(
+      [
+        "--clean",
+        "--cas-cache",
         self._cas_cache_dir,
-    ])
+      ]
+    )
     self.assertEqual(0, returncode, (out, err, returncode))
 
     # Rerun the test and make sure the cache contains the right file afterwards.
     out, err, returncode = self._run(
-        self._cmd_args(cas_digest) + ['--', 'python3', '-V'])
+      self._cmd_args(cas_digest) + ["--", "python3", "-V"]
+    )
     self.assertEqual(0, returncode, (out, err, returncode))
     expected = {
-        '.': (0o40700, 0o40700, 0o40700),
-        'state.json': (0o100600, 0o100600, 0o100600),
-        file1_hash: (0o100604, 0o100604, 0o100604),
+      ".": (0o40700, 0o40700, 0o40700),
+      "state.json": (0o100600, 0o100600, 0o100600),
+      file1_hash: (0o100604, 0o100604, 0o100604),
     }
     self.assertTreeModes(self._cas_cache_dir, expected)
     return cached_file_path
 
-  @unittest.skipIf(sys.platform == 'win32', 'crbug.com/1148174')
+  @unittest.skipIf(sys.platform == "win32", "crbug.com/1148174")
   def test_isolated_corrupted_cache_entry_different_size(self):
     # Test that an entry with an invalid file size properly gets removed and
     # fetched again. This test case also check for file modes.
-    cached_file_path = self._test_corruption_common(CONTENTS['file1.txt'] +
-                                                    b' now invalid size')
-    self.assertEqual(CONTENTS['file1.txt'], read_content(cached_file_path))
+    cached_file_path = self._test_corruption_common(
+      CONTENTS["file1.txt"] + b" now invalid size"
+    )
+    self.assertEqual(CONTENTS["file1.txt"], read_content(cached_file_path))
 
-  @unittest.skipIf(sys.platform == 'win32', 'crbug.com/1148174')
+  @unittest.skipIf(sys.platform == "win32", "crbug.com/1148174")
   def test_isolated_corrupted_cache_entry_same_size(self):
     # Test that an entry with an invalid file content but same size is NOT
     # detected property.
-    cached_file_path = self._test_corruption_common(CONTENTS['file1.txt'][:-1] +
-                                                    b' ')
-    self.assertEqual(CONTENTS['file1.txt'], read_content(cached_file_path))
+    cached_file_path = self._test_corruption_common(
+      CONTENTS["file1.txt"][:-1] + b" "
+    )
+    self.assertEqual(CONTENTS["file1.txt"], read_content(cached_file_path))
 
-  @unittest.skipIf(sys.platform == 'win32', 'crbug.com/1148174')
+  @unittest.skipIf(sys.platform == "win32", "crbug.com/1148174")
   def test_minimal_lower_priority(self):
-    cmd = ['--lower-priority', '--', sys.executable, '-c']
-    if sys.platform == 'win32':
+    cmd = ["--lower-priority", "--", sys.executable, "-c"]
+    if sys.platform == "win32":
       cmd.append(
-          'import ctypes,sys; v=ctypes.windll.kernel32.GetPriorityClass(-1);'
-          'sys.stdout.write(hex(v))')
+        "import ctypes,sys; v=ctypes.windll.kernel32.GetPriorityClass(-1);"
+        "sys.stdout.write(hex(v))"
+      )
     else:
-      cmd.append('import os,sys; sys.stdout.write(str(os.nice(0)))')
+      cmd.append("import os,sys; sys.stdout.write(str(os.nice(0)))")
     out, err, returncode = self._run(cmd)
-    self.assertEqual('', err)
-    if sys.platform == 'win32':
+    self.assertEqual("", err)
+    if sys.platform == "win32":
       # See
       # https://docs.microsoft.com/en-us/windows/desktop/api/processthreadsapi/nf-processthreadsapi-getpriorityclass
       BELOW_NORMAL_PRIORITY_CLASS = 0x4000
@@ -380,29 +397,31 @@
   def test_limit_processes(self):
     # Execution fails because it tries to run a second process.
     cmd = [
-        '--limit-processes',
-        '1',
+      "--limit-processes",
+      "1",
     ]
-    if sys.platform == 'win32':
-      cmd.extend(('--containment-type', 'JOB_OBJECT'))
-    cmd.extend(('--', sys.executable, '-c'))
-    if sys.platform == 'win32':
-      cmd.append('import subprocess,sys; '
-                 'subprocess.call([sys.executable, "-c", "print(0)"])')
+    if sys.platform == "win32":
+      cmd.extend(("--containment-type", "JOB_OBJECT"))
+    cmd.extend(("--", sys.executable, "-c"))
+    if sys.platform == "win32":
+      cmd.append(
+        "import subprocess,sys; "
+        'subprocess.call([sys.executable, "-c", "print(0)"])'
+      )
     else:
-      cmd.append('import os,sys; sys.stdout.write(str(os.nice(0)))')
+      cmd.append("import os,sys; sys.stdout.write(str(os.nice(0)))")
     out, err, returncode = self._run(cmd)
-    if sys.platform == 'win32':
-      self.assertIn('WinError', err)
+    if sys.platform == "win32":
+      self.assertIn("WinError", err)
       # Value for ERROR_NOT_ENOUGH_QUOTA. See
       # https://docs.microsoft.com/windows/desktop/debug/system-error-codes--1700-3999-
-      self.assertIn('1816', err)
-      self.assertEndsWith('', out)
+      self.assertIn("1816", err)
+      self.assertEndsWith("", out)
       self.assertEqual(1, returncode)
     else:
       # TODO(maruel): Add containment on other platforms.
-      self.assertEqual('', err)
-      self.assertEndsWith('0', out)
+      self.assertEqual("", err)
+      self.assertEndsWith("0", out)
       self.assertEqual(0, returncode)
 
   def test_named_cache(self):
@@ -412,152 +431,173 @@
     # means that it could get rounded *down* and match the value of now.
     now = time.time() - 2
     cmd = [
-        '--cas-cache', self._cas_cache_dir, '--named-cache-root',
-        self._named_cache_dir, '--named-cache', 'cache1', 'a', '100', '--',
-        sys.executable, '-c',
-        'open("a/hello","wb").write(b"world");print("Success")'
+      "--cas-cache",
+      self._cas_cache_dir,
+      "--named-cache-root",
+      self._named_cache_dir,
+      "--named-cache",
+      "cache1",
+      "a",
+      "100",
+      "--",
+      sys.executable,
+      "-c",
+      'open("a/hello","wb").write(b"world");print("Success")',
     ]
     out, err, returncode = self._run(cmd)
-    self.assertEqual('', err)
-    self.assertEndsWith('Success\n', out)
+    self.assertEqual("", err)
+    self.assertEndsWith("Success\n", out)
     self.assertEqual(0, returncode)
-    self.assertEqual(['state.json'], list_files_tree(self._cas_cache_dir))
+    self.assertEqual(["state.json"], list_files_tree(self._cas_cache_dir))
 
     # Load the state file manually. This assumes internal knowledge in
     # local_caching.py.
-    with open(os.path.join(self._named_cache_dir, 'state.json'), 'rb') as f:
+    with open(os.path.join(self._named_cache_dir, "state.json"), "rb") as f:
       data = json.load(f)
-    name, ((rel_path, size), timestamp) = data['items'][0]
-    self.assertEqual('cache1', name)
+    name, ((rel_path, size), timestamp) = data["items"][0]
+    self.assertEqual("cache1", name)
     self.assertGreaterEqual(timestamp, now)
-    self.assertEqual(len('world'), size)
-    self.assertEqual(['hello'],
-                     list_files_tree(
-                         os.path.join(self._named_cache_dir, rel_path)))
+    self.assertEqual(len("world"), size)
+    self.assertEqual(
+      ["hello"], list_files_tree(os.path.join(self._named_cache_dir, rel_path))
+    )
 
   def test_cas_input(self):
     # Prepare inputs on the remote CAS instance.
-    inputs_root_digest = self._fakecas.archive_files({
-        'repeated_files.py':
-        CONTENTS['repeated_files.py'],
-        'file1.txt':
-        CONTENTS['file1.txt'],
-        'file1_copy.txt':
-        CONTENTS['file1.txt'],
-    })
+    inputs_root_digest = self._fakecas.archive_files(
+      {
+        "repeated_files.py": CONTENTS["repeated_files.py"],
+        "file1.txt": CONTENTS["file1.txt"],
+        "file1_copy.txt": CONTENTS["file1.txt"],
+      }
+    )
 
     # Path to the result json file.
-    result_json = os.path.join(self.tempdir, 'run_isolated_result.json')
+    result_json = os.path.join(self.tempdir, "run_isolated_result.json")
 
     def assertRunIsolatedWithCAS(optional_args, expected_retcode=0):
-      args = optional_args + [
-          '--root-dir',
+      args = (
+        optional_args
+        + [
+          "--root-dir",
           self._root_dir,
-          '--cas-digest',
+          "--cas-digest",
           inputs_root_digest,
-          '--cas-cache',
+          "--cas-cache",
           self._cas_cache_dir,
-          '--cipd-cache',
+          "--cipd-cache",
           self._cipd_cache_dir,
-          '--json',
+          "--json",
           result_json,
-          '--',
-      ] + CMD_REPEATED_FILES
+          "--",
+        ]
+        + CMD_REPEATED_FILES
+      )
       out, _, ret = self._run(args)
 
       if expected_retcode == 0:
-        self.assertEndsWith('Success\n', out)
+        self.assertEndsWith("Success\n", out)
       self.assertEqual(expected_retcode, ret)
 
     # Runs run_isolated with cas options.
     assertRunIsolatedWithCAS([])
-    download_stats = load_isolated_stats(result_json, 'download')
-    download_stats.pop('duration')
+    download_stats = load_isolated_stats(result_json, "download")
+    download_stats.pop("duration")
     self.assertEqual(
-        {
-            'items_cold': [
-                len(CONTENTS['file1.txt']),
-                len(CONTENTS['repeated_files.py']),
-            ],
-            'items_hot': None,
-        }, download_stats)
-    self.assertEqual([
-        'ebea1137c5ece3f8a58f0e1a0da1411fe0a2648501419d190b3b154f3f191259',
-        'f0a8a1a7050bfae60a591d0cb7d74de2ef52963b9913253fc9ec7151aa5d421e',
-        'state.json',
-    ], list_files_tree(self._cas_cache_dir))
+      {
+        "items_cold": [
+          len(CONTENTS["file1.txt"]),
+          len(CONTENTS["repeated_files.py"]),
+        ],
+        "items_hot": None,
+      },
+      download_stats,
+    )
+    self.assertEqual(
+      [
+        "ebea1137c5ece3f8a58f0e1a0da1411fe0a2648501419d190b3b154f3f191259",
+        "f0a8a1a7050bfae60a591d0cb7d74de2ef52963b9913253fc9ec7151aa5d421e",
+        "state.json",
+      ],
+      list_files_tree(self._cas_cache_dir),
+    )
 
     # Cleanup all caches.
     # TODO(crbug.com/1129290):
     # '--max-cache-size=0' is ignored by local_caching.py unexpectedly.
     # change it to 0 after fixing the bug.
-    _, _, returncode = self._run([
-        '--clean',
-        '--cas-cache',
+    _, _, returncode = self._run(
+      [
+        "--clean",
+        "--cas-cache",
         self._cas_cache_dir,
-        '--max-cache-size=1',
-    ])
+        "--max-cache-size=1",
+      ]
+    )
     self.assertEqual(0, returncode)
-    self.assertEqual(['state.json'], list_files_tree(self._cas_cache_dir))
+    self.assertEqual(["state.json"], list_files_tree(self._cas_cache_dir))
 
     # Specify --max-cache-size option.
     optional_args = [
-        '--max-cache-size',
-        '1', # 0 means infinity
+      "--max-cache-size",
+      "1",  # 0 means infinity
     ]
     assertRunIsolatedWithCAS(optional_args)
-    download_stats = load_isolated_stats(result_json, 'download')
-    self.assertEqual(2, len(download_stats['items_cold']))
-    self.assertEqual(['state.json'], list_files_tree(self._cas_cache_dir))
+    download_stats = load_isolated_stats(result_json, "download")
+    self.assertEqual(2, len(download_stats["items_cold"]))
+    self.assertEqual(["state.json"], list_files_tree(self._cas_cache_dir))
 
     # Specify --min-free-space option. This shouldn't fail even if there are no
     # required space.
     optional_args = [
-        '--min-free-space',
-        str(2**63 - 1),
+      "--min-free-space",
+      str(2**63 - 1),
     ]
     assertRunIsolatedWithCAS(optional_args)
 
   def test_cas_output(self):
     # Prepare inputs on CAS instance for `output.py` task.
     inputs_root_digest = self._fakecas.archive_files(
-        {'output.py': CONTENTS['output.py']})
+      {"output.py": CONTENTS["output.py"]}
+    )
 
     # Path to the result json file.
-    result_json = os.path.join(self.tempdir, 'run_isolated_result.json')
+    result_json = os.path.join(self.tempdir, "run_isolated_result.json")
 
     args = [
-        '--root-dir',
-        self._root_dir,
-        '--cas-instance',
-        'projects/test/instances/default_instance',
-        '--cas-digest',
-        inputs_root_digest,
-        '--cas-cache',
-        self._cas_cache_dir,
-        '--cipd-cache',
-        self._cipd_cache_dir,
-        '--json',
-        result_json,
-        '--',
+      "--root-dir",
+      self._root_dir,
+      "--cas-instance",
+      "projects/test/instances/default_instance",
+      "--cas-digest",
+      inputs_root_digest,
+      "--cas-cache",
+      self._cas_cache_dir,
+      "--cipd-cache",
+      self._cipd_cache_dir,
+      "--json",
+      result_json,
+      "--",
     ] + CMD_OUTPUT
     out, err, ret = self._run(args)
 
-    self.assertEqual(0, ret,
-                     "stdout\n%s\nstderr\n%s\nret: %d" % (out, err, ret))
-    upload_stats = load_isolated_stats(result_json, 'upload')
-    upload_size = upload_stats['items_cold'][0]
+    self.assertEqual(
+      0, ret, "stdout\n%s\nstderr\n%s\nret: %d" % (out, err, ret)
+    )
+    upload_stats = load_isolated_stats(result_json, "upload")
+    upload_size = upload_stats["items_cold"][0]
     self.assertEqual(len(OUTPUT_CONTENT), upload_size)
     result = json.loads(read_content(result_json))
 
-    output_dir = os.path.join(self.tempdir, 'out')
-    d = result['cas_output_root']['digest']
-    output_root_digest = "%s/%s" % (d['hash'], d['size_bytes'])
+    output_dir = os.path.join(self.tempdir, "out")
+    d = result["cas_output_root"]["digest"]
+    output_root_digest = "%s/%s" % (d["hash"], d["size_bytes"])
     self._download_from_cas(output_root_digest, output_dir)
-    self.assertEqual(['foo.txt'], list_files_tree(output_dir))
-    self.assertEqual(OUTPUT_CONTENT.encode(),
-                     read_content(os.path.join(output_dir, 'foo.txt')))
+    self.assertEqual(["foo.txt"], list_files_tree(output_dir))
+    self.assertEqual(
+      OUTPUT_CONTENT.encode(), read_content(os.path.join(output_dir, "foo.txt"))
+    )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
   test_env.main()
diff --git a/tests/run_isolated_test.py b/tests/run_isolated_test.py
index ebc60a5..e462f27 100755
--- a/tests/run_isolated_test.py
+++ b/tests/run_isolated_test.py
@@ -41,12 +41,13 @@
 
 
 ROOT_DIR = os.path.dirname(
-    os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-LUCI_GO_CLIENT_DIR = os.path.join(ROOT_DIR, 'luci-go')
+  os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+)
+LUCI_GO_CLIENT_DIR = os.path.join(ROOT_DIR, "luci-go")
 
 
 def json_dumps(data):
-  return json.dumps(data, sort_keys=True, separators=(',', ':'))
+  return json.dumps(data, sort_keys=True, separators=(",", ":"))
 
 
 @contextlib.contextmanager
@@ -87,30 +88,33 @@
   # 'AssertionError: Items in the first set but not the second'
   # Need to run in sequential_test_runner.py as an executable
   no_run = 1
-  DISABLE_CIPD_FOR_TESTS = ['--cipd-enabled', False]
+  DISABLE_CIPD_FOR_TESTS = ["--cipd-enabled", False]
 
   @classmethod
   def setUpClass(cls):
     if not file_path.enable_symlink():
       raise Exception(
-          'Failed to enable symlink; this test requires it. On Windows, maybe '
-          'try running as Administrator')
+        "Failed to enable symlink; this test requires it. On Windows, maybe "
+        "try running as Administrator"
+      )
 
   def setUp(self):
     super(RunIsolatedTestBase, self).setUp()
-    os.environ.pop('LUCI_CONTEXT', None)
-    os.environ['LUCI_GO_CLIENT_DIR'] = LUCI_GO_CLIENT_DIR
+    os.environ.pop("LUCI_CONTEXT", None)
+    os.environ["LUCI_GO_CLIENT_DIR"] = LUCI_GO_CLIENT_DIR
     self._previous_dir = os.getcwd()
-    self.tempdir = tempfile.mkdtemp(prefix='run_isolated_test')
-    logging.debug('Temp dir: %s', self.tempdir)
-    cwd = os.path.join(self.tempdir, 'cwd')
+    self.tempdir = tempfile.mkdtemp(prefix="run_isolated_test")
+    logging.debug("Temp dir: %s", self.tempdir)
+    cwd = os.path.join(self.tempdir, "cwd")
     fs.mkdir(cwd)
     os.chdir(cwd)
-    self.mock(run_isolated, 'make_temp_dir', self.fake_make_temp_dir)
-    self.mock(run_isolated.auth, 'ensure_logged_in', lambda _: None)
+    self.mock(run_isolated, "make_temp_dir", self.fake_make_temp_dir)
+    self.mock(run_isolated.auth, "ensure_logged_in", lambda _: None)
     self.mock(
-        logging_utils.OptionParserWithLogging, 'logger_root',
-        logging.Logger('unittest'))
+      logging_utils.OptionParserWithLogging,
+      "logger_root",
+      logging.Logger("unittest"),
+    )
 
     self._cipd_server = None  # initialized lazily
 
@@ -130,10 +134,16 @@
 
   def fake_make_temp_dir(self, prefix, _root_dir):
     """Predictably returns directory for run_tha_test (one per test case)."""
-    self.assertIn(prefix,
-                  (run_isolated.ISOLATED_OUT_DIR, run_isolated.ISOLATED_RUN_DIR,
-                   run_isolated.ISOLATED_TMP_DIR, run_isolated._CAS_CLIENT_DIR,
-                   'cipd_site_root'))
+    self.assertIn(
+      prefix,
+      (
+        run_isolated.ISOLATED_OUT_DIR,
+        run_isolated.ISOLATED_RUN_DIR,
+        run_isolated.ISOLATED_TMP_DIR,
+        run_isolated._CAS_CLIENT_DIR,
+        "cipd_site_root",
+      ),
+    )
     temp_dir = os.path.join(self.tempdir, prefix)
     self.assertFalse(fs.isdir(temp_dir))
     fs.makedirs(temp_dir)
@@ -148,7 +158,7 @@
 
   def assertExpectedTree(self, expected, root_dir=None):
     # Assume expected path are relative to root if not specified.
-    root_dir = root_dir or os.path.join(self.tempdir, 'io')
+    root_dir = root_dir or os.path.join(self.tempdir, "io")
 
     # Return True is the entries in out_dir are exactly the same as entries in
     # expected. Return False otherwise.
@@ -162,7 +172,7 @@
       # If we expect a non-empty directory, check the entries in dir.
       # If we expect an empty dir, its existence (checked above) is sufficient.
       if not fs.isdir(full_path):
-        with open(full_path, 'r') as f:
+        with open(full_path, "r") as f:
           self.assertEqual(f.read(), content)
       count += 1
     self.assertEqual(count, len(expected))
@@ -185,10 +195,10 @@
     class Popen:
       def __init__(self2, args, **kwargs):
         if not self.capture_popen_env:
-          kwargs.pop('env', None)
+          kwargs.pop("env", None)
         if self.capture_luci_ctx:
-          with open(os.environ['LUCI_CONTEXT']) as f:
-            kwargs['luci_ctx'] = json.load(f)
+          with open(os.environ["LUCI_CONTEXT"]) as f:
+            kwargs["luci_ctx"] = json.load(f)
         self2.returncode = None
         self2.args = args
         self2.kwargs = kwargs
@@ -212,293 +222,316 @@
       def kill(self):
         pass
 
-    self.mock(subprocess42, 'Popen', Popen)
+    self.mock(subprocess42, "Popen", Popen)
 
   def test_copy_recusrsively(self):
-    src = os.path.join(self.tempdir, 'src')
-    dst = os.path.join(self.tempdir, 'dst')
-    with open(src, 'w'):
+    src = os.path.join(self.tempdir, "src")
+    dst = os.path.join(self.tempdir, "dst")
+    with open(src, "w"):
       pass
 
     run_isolated.copy_recursively(src, dst)
     self.assertTrue(os.path.isfile(dst))
 
   def test_copy_recusrsively_not_exist(self):
-    src = os.path.join(self.tempdir, 'src')
-    dst = os.path.join(self.tempdir, 'dst')
+    src = os.path.join(self.tempdir, "src")
+    dst = os.path.join(self.tempdir, "dst")
     run_isolated.copy_recursively(src, dst)
     self.assertFalse(os.path.exists(dst))
 
   def test_get_command_env(self):
     old_env = os.environ.copy()
     try:
-      os.environ.pop('B', None)
-      self.assertNotIn('B', os.environ)
-      os.environ['C'] = 'foo'
-      os.environ['D'] = 'bar'
-      os.environ['E'] = 'baz'
+      os.environ.pop("B", None)
+      self.assertNotIn("B", os.environ)
+      os.environ["C"] = "foo"
+      os.environ["D"] = "bar"
+      os.environ["E"] = "baz"
       env = run_isolated.get_command_env(
-          '/a',
-          None,
-          '/b',
-          {
-              'A': 'a',
-              'B': None,
-              'C': None,
-              'E': '${ISOLATED_OUTDIR}/eggs'
-          },
-          {'D': ['foo']},
-          '/spam',
-          None)
-      self.assertNotIn('B', env)
-      self.assertNotIn('C', env)
-      if sys.platform == 'win32':
-        self.assertEqual('\\b\\foo;bar', env['D'])
+        "/a",
+        None,
+        "/b",
+        {"A": "a", "B": None, "C": None, "E": "${ISOLATED_OUTDIR}/eggs"},
+        {"D": ["foo"]},
+        "/spam",
+        None,
+      )
+      self.assertNotIn("B", env)
+      self.assertNotIn("C", env)
+      if sys.platform == "win32":
+        self.assertEqual("\\b\\foo;bar", env["D"])
       else:
-        self.assertEqual('/b/foo:bar', env['D'])
-      self.assertEqual(os.sep + os.path.join('spam', 'eggs'), env['E'])
+        self.assertEqual("/b/foo:bar", env["D"])
+      self.assertEqual(os.sep + os.path.join("spam", "eggs"), env["E"])
     finally:
       os.environ.clear()
       os.environ.update(old_env)
 
-  @mock.patch.dict(os.environ, {'SWARMING_TASK_ID': '4242'})
+  @mock.patch.dict(os.environ, {"SWARMING_TASK_ID": "4242"})
   def test_main(self):
-    self.mock(tools, 'disable_buffering', lambda: None)
+    self.mock(tools, "disable_buffering", lambda: None)
 
     cmd = self.DISABLE_CIPD_FOR_TESTS + [
-        '--no-log', '--named-cache-root',
-        os.path.join(self.tempdir, 'named_cache'), '--root-dir', self.tempdir,
-        '--', 'foo.exe', 'cmd with space', '-task-id', '${SWARMING_TASK_ID}'
+      "--no-log",
+      "--named-cache-root",
+      os.path.join(self.tempdir, "named_cache"),
+      "--root-dir",
+      self.tempdir,
+      "--",
+      "foo.exe",
+      "cmd with space",
+      "-task-id",
+      "${SWARMING_TASK_ID}",
     ]
     ret = run_isolated.main(cmd)
     self.assertEqual(0, ret)
-    self.assertEqual([
+    self.assertEqual(
+      [
         (
-            [self.ir_dir('foo.exe'), 'cmd with space', '-task-id', '4242'],
-            {
-                'cwd': self.ir_dir(),
-                'detached': True,
-                'close_fds': True,
-                'lower_priority': False,
-                'containment': subprocess42.Containment(),
-            },
+          [self.ir_dir("foo.exe"), "cmd with space", "-task-id", "4242"],
+          {
+            "cwd": self.ir_dir(),
+            "detached": True,
+            "close_fds": True,
+            "lower_priority": False,
+            "containment": subprocess42.Containment(),
+          },
         ),
-    ], self.popen_calls)
+      ],
+      self.popen_calls,
+    )
 
   def test_main_args(self):
-    self.mock(tools, 'disable_buffering', lambda: None)
+    self.mock(tools, "disable_buffering", lambda: None)
 
     cmd = self.DISABLE_CIPD_FOR_TESTS + [
-        '--no-log',
-        '--named-cache-root',
-        os.path.join(self.tempdir, 'named_cache'),
-        '--root-dir',
-        self.tempdir,
-        '--',
-        'foo.exe',
-        'cmd w/ space',
+      "--no-log",
+      "--named-cache-root",
+      os.path.join(self.tempdir, "named_cache"),
+      "--root-dir",
+      self.tempdir,
+      "--",
+      "foo.exe",
+      "cmd w/ space",
     ]
     ret = run_isolated.main(cmd)
     self.assertEqual(0, ret)
-    self.assertEqual([
+    self.assertEqual(
+      [
         (
-            [self.ir_dir('foo.exe'), 'cmd w/ space'],
-            {
-                'cwd': self.ir_dir(),
-                'detached': True,
-                'close_fds': True,
-                'lower_priority': False,
-                'containment': subprocess42.Containment(),
-            },
+          [self.ir_dir("foo.exe"), "cmd w/ space"],
+          {
+            "cwd": self.ir_dir(),
+            "detached": True,
+            "close_fds": True,
+            "lower_priority": False,
+            "containment": subprocess42.Containment(),
+          },
         ),
-    ], self.popen_calls)
+      ],
+      self.popen_calls,
+    )
 
-  def _run_tha_test(self,
-                    command=None,
-                    lower_priority=False,
-                    relative_cwd=None):
+  def _run_tha_test(
+    self, command=None, lower_priority=False, relative_cwd=None
+  ):
     make_tree_call = []
+
     def add(i, _):
       make_tree_call.append(i)
 
-    for i in ('make_tree_files_read_only', 'make_tree_deleteable'):
+    for i in ("make_tree_files_read_only", "make_tree_deleteable"):
       self.mock(file_path, i, functools.partial(add, i))
 
     data = run_isolated.TaskData(
-        command=command or [],
-        relative_cwd=relative_cwd,
-        cas_instance=None,
-        cas_digest=None,
-        outputs=None,
-        install_named_caches=init_named_caches_stub,
-        leak_temp_dir=False,
-        root_dir=self.tempdir,
-        hard_timeout=60,
-        grace_period=30,
-        bot_file=None,
-        switch_to_account=False,
-        install_packages_fn=run_isolated.copy_local_packages,
-        cas_cache_dir=None,
-        cas_cache_policies=None,
-        cas_kvs='',
-        env={},
-        env_prefix={},
-        lower_priority=lower_priority,
-        containment=None,
-        trim_caches_fn=trim_caches_stub)
+      command=command or [],
+      relative_cwd=relative_cwd,
+      cas_instance=None,
+      cas_digest=None,
+      outputs=None,
+      install_named_caches=init_named_caches_stub,
+      leak_temp_dir=False,
+      root_dir=self.tempdir,
+      hard_timeout=60,
+      grace_period=30,
+      bot_file=None,
+      switch_to_account=False,
+      install_packages_fn=run_isolated.copy_local_packages,
+      cas_cache_dir=None,
+      cas_cache_policies=None,
+      cas_kvs="",
+      env={},
+      env_prefix={},
+      lower_priority=lower_priority,
+      containment=None,
+      trim_caches_fn=trim_caches_stub,
+    )
     ret = run_isolated.run_tha_test(data, None)
     self.assertEqual(0, ret)
     return make_tree_call
 
   def test_run_tha_test_naked(self):
-    self._run_tha_test(command=['invalid', 'command'])
-    self.assertEqual([
+    self._run_tha_test(command=["invalid", "command"])
+    self.assertEqual(
+      [
         (
-            [self.ir_dir('invalid'), 'command'],
-            {
-                'cwd': self.ir_dir(),
-                'detached': True,
-                'close_fds': True,
-                'lower_priority': False,
-                'containment': None,
-            },
+          [self.ir_dir("invalid"), "command"],
+          {
+            "cwd": self.ir_dir(),
+            "detached": True,
+            "close_fds": True,
+            "lower_priority": False,
+            "containment": None,
+          },
         ),
-    ], self.popen_calls)
+      ],
+      self.popen_calls,
+    )
 
   def mock_popen_with_oserr(self):
     def r(self, args, **kwargs):
       old_init(self, args, **kwargs)
-      raise OSError('Unknown')
-    old_init = self.mock(subprocess42.Popen, '__init__', r)
+      raise OSError("Unknown")
+
+    old_init = self.mock(subprocess42.Popen, "__init__", r)
 
   def test_main_naked(self):
     self.mock_popen_with_oserr()
     # The most naked .isolated file that can exist.
-    self.mock(tools, 'disable_buffering', lambda: None)
+    self.mock(tools, "disable_buffering", lambda: None)
 
     cmd = self.DISABLE_CIPD_FOR_TESTS + [
-        '--no-log', '--named-cache-root',
-        os.path.join(self.tempdir, 'named_cache'), '--root-dir', self.tempdir,
-        '--', 'invalid', 'command'
+      "--no-log",
+      "--named-cache-root",
+      os.path.join(self.tempdir, "named_cache"),
+      "--root-dir",
+      self.tempdir,
+      "--",
+      "invalid",
+      "command",
     ]
     ret = run_isolated.main(cmd)
     self.assertEqual(1, ret)
     self.assertEqual(1, len(self.popen_calls))
-    self.assertEqual([
+    self.assertEqual(
+      [
         (
-            [self.ir_dir('invalid'), 'command'],
-            {
-                'cwd': self.ir_dir(),
-                'detached': True,
-                'close_fds': True,
-                'lower_priority': False,
-                'containment': subprocess42.Containment(),
-            },
+          [self.ir_dir("invalid"), "command"],
+          {
+            "cwd": self.ir_dir(),
+            "detached": True,
+            "close_fds": True,
+            "lower_priority": False,
+            "containment": subprocess42.Containment(),
+          },
         ),
-    ], self.popen_calls)
+      ],
+      self.popen_calls,
+    )
 
-  @unittest.skipIf(sys.platform == 'win32', 'crbug.com/1148174')
+  @unittest.skipIf(sys.platform == "win32", "crbug.com/1148174")
   def test_main_naked_without_isolated(self):
     self.mock_popen_with_oserr()
     cmd = self.DISABLE_CIPD_FOR_TESTS + [
-        '--no-log',
-        '--named-cache-root',
-        os.path.join(self.tempdir, 'named_cache'),
-        '--root-dir',
-        self.tempdir,
-        '--',
-        '/bin/echo',
-        'hello',
-        'world',
+      "--no-log",
+      "--named-cache-root",
+      os.path.join(self.tempdir, "named_cache"),
+      "--root-dir",
+      self.tempdir,
+      "--",
+      "/bin/echo",
+      "hello",
+      "world",
     ]
     ret = run_isolated.main(cmd)
     self.assertEqual(1, ret)
     self.assertEqual(
-        [
-          (
-            ['/bin/echo', 'hello', 'world'],
-            {
-              'cwd': self.ir_dir(),
-              'detached': True,
-              'close_fds': True,
-              'lower_priority': False,
-              'containment': subprocess42.Containment(),
-            },
-          ),
-        ],
-        self.popen_calls)
+      [
+        (
+          ["/bin/echo", "hello", "world"],
+          {
+            "cwd": self.ir_dir(),
+            "detached": True,
+            "close_fds": True,
+            "lower_priority": False,
+            "containment": subprocess42.Containment(),
+          },
+        ),
+      ],
+      self.popen_calls,
+    )
 
-  @unittest.skipIf(sys.platform == 'win32', 'crbug.com/1148174')
+  @unittest.skipIf(sys.platform == "win32", "crbug.com/1148174")
   def test_main_naked_with_account_switch(self):
     self.capture_luci_ctx = True
     self.mock_popen_with_oserr()
     cmd = self.DISABLE_CIPD_FOR_TESTS + [
-        '--no-log',
-        '--named-cache-root',
-        os.path.join(self.tempdir, 'named_cache'),
-        '--switch-to-account',
-        'task',
-        '--',
-        '/bin/echo',
-        'hello',
-        'world',
+      "--no-log",
+      "--named-cache-root",
+      os.path.join(self.tempdir, "named_cache"),
+      "--switch-to-account",
+      "task",
+      "--",
+      "/bin/echo",
+      "hello",
+      "world",
     ]
     root_ctx = {
-      'accounts': [{'id': 'bot'}, {'id': 'task'}],
-      'default_account_id' : 'bot',
-      'secret': 'sekret',
-      'rpc_port': 12345,
+      "accounts": [{"id": "bot"}, {"id": "task"}],
+      "default_account_id": "bot",
+      "secret": "sekret",
+      "rpc_port": 12345,
     }
     with luci_context.write(local_auth=root_ctx):
       run_isolated.main(cmd)
     # Switched default account to task.
     task_ctx = root_ctx.copy()
-    task_ctx['default_account_id'] = 'task'
-    self.assertEqual(task_ctx, self.popen_calls[0][1]['luci_ctx']['local_auth'])
+    task_ctx["default_account_id"] = "task"
+    self.assertEqual(task_ctx, self.popen_calls[0][1]["luci_ctx"]["local_auth"])
 
-  @unittest.skipIf(sys.platform == 'win32', 'crbug.com/1148174')
+  @unittest.skipIf(sys.platform == "win32", "crbug.com/1148174")
   def test_main_naked_with_account_pop(self):
     self.capture_luci_ctx = True
     self.mock_popen_with_oserr()
     cmd = self.DISABLE_CIPD_FOR_TESTS + [
-        '--no-log',
-        '--named-cache-root',
-        os.path.join(self.tempdir, 'named_cache'),
-        '--switch-to-account',
-        'task',
-        '--',
-        '/bin/echo',
-        'hello',
-        'world',
+      "--no-log",
+      "--named-cache-root",
+      os.path.join(self.tempdir, "named_cache"),
+      "--switch-to-account",
+      "task",
+      "--",
+      "/bin/echo",
+      "hello",
+      "world",
     ]
     root_ctx = {
-      'accounts': [{'id': 'bot'}],  # only 'bot', there's no 'task'
-      'default_account_id' : 'bot',
-      'secret': 'sekret',
-      'rpc_port': 12345,
+      "accounts": [{"id": "bot"}],  # only 'bot', there's no 'task'
+      "default_account_id": "bot",
+      "secret": "sekret",
+      "rpc_port": 12345,
     }
     with luci_context.write(local_auth=root_ctx):
       run_isolated.main(cmd)
     # Unset default account, since 'task' account is not defined.
     task_ctx = root_ctx.copy()
-    task_ctx.pop('default_account_id')
-    self.assertEqual(task_ctx, self.popen_calls[0][1]['luci_ctx']['local_auth'])
+    task_ctx.pop("default_account_id")
+    self.assertEqual(task_ctx, self.popen_calls[0][1]["luci_ctx"]["local_auth"])
 
-  @unittest.skipIf(sys.platform == 'win32', 'crbug.com/1148174')
+  @unittest.skipIf(sys.platform == "win32", "crbug.com/1148174")
   def test_main_naked_leaking(self):
     workdir = tempfile.mkdtemp()
     try:
       cmd = self.DISABLE_CIPD_FOR_TESTS + [
-          '--no-log',
-          '--root-dir',
-          workdir,
-          '--leak-temp-dir',
-          '--named-cache-root',
-          os.path.join(self.tempdir, 'named_cache'),
-          '--',
-          '/bin/echo',
-          'hello',
-          'world',
+        "--no-log",
+        "--root-dir",
+        workdir,
+        "--leak-temp-dir",
+        "--named-cache-root",
+        os.path.join(self.tempdir, "named_cache"),
+        "--",
+        "/bin/echo",
+        "hello",
+        "world",
       ]
       ret = run_isolated.main(cmd)
       self.assertEqual(0, ret)
@@ -506,68 +539,75 @@
       fs.rmtree(workdir)
 
   def test_main_naked_with_packages(self):
-    self.mock(cipd, 'get_platform', lambda: 'linux-amd64')
+    self.mock(cipd, "get_platform", lambda: "linux-amd64")
 
     def pins_generator():
       yield {
-          '': [
-              ('infra/data/x', 'badc0fee' * 5),
-              ('infra/data/y', 'cafebabe' * 5),
-          ],
-          'bin': [('infra/tools/echo/linux-amd64', 'deadbeef' * 5),],
+        "": [
+          ("infra/data/x", "badc0fee" * 5),
+          ("infra/data/y", "cafebabe" * 5),
+        ],
+        "bin": [
+          ("infra/tools/echo/linux-amd64", "deadbeef" * 5),
+        ],
       }
       yield {
-          '': [('infra/tools/luci/cas/linux-amd64',
-                run_isolated._LUCI_GO_REVISION)],
+        "": [
+          ("infra/tools/luci/cas/linux-amd64", run_isolated._LUCI_GO_REVISION)
+        ],
       }
 
     pins_gen = pins_generator()
 
-    suffix = '.exe' if sys.platform == 'win32' else ''
+    suffix = ".exe" if sys.platform == "win32" else ""
+
     def fake_ensure(args, **kwargs):
-      if (args[0].endswith(os.path.join('bin', 'cipd' + suffix)) and
-          args[1] == 'ensure'
-          and '-json-output' in args):
-        idx = args.index('-json-output')
-        with open(args[idx+1], 'w') as json_out:
+      if (
+        args[0].endswith(os.path.join("bin", "cipd" + suffix))
+        and args[1] == "ensure"
+        and "-json-output" in args
+      ):
+        idx = args.index("-json-output")
+        with open(args[idx + 1], "w") as json_out:
           json.dump(
-              {
-                  'result': {
-                      subdir: [{
-                          'package': pkg,
-                          'instance_id': ver
-                      } for pkg, ver in packages]
-                      for subdir, packages in next(pins_gen).items()
-                  }
-              }, json_out)
+            {
+              "result": {
+                subdir: [
+                  {"package": pkg, "instance_id": ver} for pkg, ver in packages
+                ]
+                for subdir, packages in next(pins_gen).items()
+              }
+            },
+            json_out,
+          )
         return 0
-      if args[0].endswith(os.sep + 'echo' + suffix):
+      if args[0].endswith(os.sep + "echo" + suffix):
         return 0
-      self.fail('unexpected: %s, %s' % (args, kwargs))
+      self.fail("unexpected: %s, %s" % (args, kwargs))
       return 1
 
     self.popen_fakes.append(fake_ensure)
-    cipd_cache = os.path.join(self.tempdir, 'cipd_cache')
+    cipd_cache = os.path.join(self.tempdir, "cipd_cache")
     cmd = [
-        '--no-log',
-        '--cipd-client-version',
-        'git:wowza',
-        '--cipd-package',
-        'bin:infra/tools/echo/${platform}:latest',
-        '--cipd-package',
-        '.:infra/data/x:latest',
-        '--cipd-package',
-        '.:infra/data/y:canary',
-        '--cipd-server',
-        self.cipd_server.url,
-        '--cipd-cache',
-        cipd_cache,
-        '--named-cache-root',
-        os.path.join(self.tempdir, 'named_cache'),
-        '--',
-        'bin/echo${EXECUTABLE_SUFFIX}',
-        'hello',
-        'world',
+      "--no-log",
+      "--cipd-client-version",
+      "git:wowza",
+      "--cipd-package",
+      "bin:infra/tools/echo/${platform}:latest",
+      "--cipd-package",
+      ".:infra/data/x:latest",
+      "--cipd-package",
+      ".:infra/data/y:canary",
+      "--cipd-server",
+      self.cipd_server.url,
+      "--cipd-cache",
+      cipd_cache,
+      "--named-cache-root",
+      os.path.join(self.tempdir, "named_cache"),
+      "--",
+      "bin/echo${EXECUTABLE_SUFFIX}",
+      "hello",
+      "world",
     ]
     ret = run_isolated.main(cmd)
     self.assertEqual(0, ret)
@@ -576,185 +616,208 @@
 
     # Test cipd-ensure command for installing packages.
     cipd_ensure_cmd, _ = self.popen_calls[0]
-    self.assertEqual(cipd_ensure_cmd[:2], [
-      os.path.join(cipd_cache, 'bin', 'cipd' + cipd.EXECUTABLE_SUFFIX),
-      'ensure',
-    ])
-    cache_dir_index = cipd_ensure_cmd.index('-cache-dir')
     self.assertEqual(
-        cipd_ensure_cmd[cache_dir_index+1],
-        os.path.join(cipd_cache, 'cache'))
+      cipd_ensure_cmd[:2],
+      [
+        os.path.join(cipd_cache, "bin", "cipd" + cipd.EXECUTABLE_SUFFIX),
+        "ensure",
+      ],
+    )
+    cache_dir_index = cipd_ensure_cmd.index("-cache-dir")
+    self.assertEqual(
+      cipd_ensure_cmd[cache_dir_index + 1], os.path.join(cipd_cache, "cache")
+    )
 
     # Test cipd client cache. `git:wowza` was a tag and so is cacheable.
-    self.assertEqual(len(fs.listdir(os.path.join(cipd_cache, 'versions'))), 2)
+    self.assertEqual(len(fs.listdir(os.path.join(cipd_cache, "versions"))), 2)
     version_file = os.path.join(
-        cipd_cache, 'versions',
-        '5c2ee864d65c435dfa1eb06bf4c52f58854db39392340a91fc91e88d6000d737')
+      cipd_cache,
+      "versions",
+      "5c2ee864d65c435dfa1eb06bf4c52f58854db39392340a91fc91e88d6000d737",
+    )
     self.assertTrue(fs.isfile(version_file))
     with open(version_file) as f:
-      self.assertEqual(f.read(), 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')
+      self.assertEqual(f.read(), "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
 
     client_binary_file = os.path.join(
-        cipd_cache, 'clients', 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')
+      cipd_cache, "clients", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+    )
     self.assertTrue(fs.isfile(client_binary_file))
 
     # Test echo call.
     echo_cmd, _ = self.popen_calls[2]
-    self.assertTrue(echo_cmd[0].endswith(
-        os.path.sep + 'bin' + os.path.sep + 'echo' + cipd.EXECUTABLE_SUFFIX),
-        echo_cmd[0])
-    self.assertEqual(echo_cmd[1:], ['hello', 'world'])
+    self.assertTrue(
+      echo_cmd[0].endswith(
+        os.path.sep + "bin" + os.path.sep + "echo" + cipd.EXECUTABLE_SUFFIX
+      ),
+      echo_cmd[0],
+    )
+    self.assertEqual(echo_cmd[1:], ["hello", "world"])
 
   def test_main_naked_with_invalid_cas_input(self):
     def dump_bad_digest_json(cmd, _):
-      json_path = cmd[cmd.index('-dump-json') + 1]
-      with open(json_path, 'w') as fp:
+      json_path = cmd[cmd.index("-dump-json") + 1]
+      with open(json_path, "w") as fp:
         json.dump(
-            {
-                'result': 'digest_invalid',
-                'error_details': {
-                    'digest': 'abcd1234/21'
-                }
-            }, fp)
+          {
+            "result": "digest_invalid",
+            "error_details": {"digest": "abcd1234/21"},
+          },
+          fp,
+        )
 
     self.mock(run_isolated, "_run_go_cmd_and_wait", dump_bad_digest_json)
-    result_json_path = os.path.join(self.tempdir, 'result.json')
+    result_json_path = os.path.join(self.tempdir, "result.json")
 
     cmd = [
-        '--json',
-        result_json_path,
-        '--no-log',
-        '--named-cache-root',
-        os.path.join(self.tempdir, 'named_cache'),
-        '--cipd-enabled',
-        'False',
-        '--cas-digest',
-        'not_valid',
-        '--cas-instance',
-        'some_cas_instance',
-        '--',
-        'bin/echo${EXECUTABLE_SUFFIX}',
-        'hello',
-        'world',
+      "--json",
+      result_json_path,
+      "--no-log",
+      "--named-cache-root",
+      os.path.join(self.tempdir, "named_cache"),
+      "--cipd-enabled",
+      "False",
+      "--cas-digest",
+      "not_valid",
+      "--cas-instance",
+      "some_cas_instance",
+      "--",
+      "bin/echo${EXECUTABLE_SUFFIX}",
+      "hello",
+      "world",
     ]
 
     ret = run_isolated.main(cmd)
     self.assertEqual(1, ret)
-    with open(result_json_path, 'r') as fp:
+    with open(result_json_path, "r") as fp:
       result_json = json.load(fp)
 
-    missing_cas = result_json['missing_cas'][0]
-    self.assertEqual('digest_invalid', missing_cas['status'])
-    self.assertEqual('abcd1234/21', missing_cas['digest'])
-    self.assertEqual('some_cas_instance', missing_cas['instance'])
+    missing_cas = result_json["missing_cas"][0]
+    self.assertEqual("digest_invalid", missing_cas["status"])
+    self.assertEqual("abcd1234/21", missing_cas["digest"])
+    self.assertEqual("some_cas_instance", missing_cas["instance"])
 
   def test_main_naked_with_invalid_cipd_package(self):
-    self.mock(cipd, 'get_platform', lambda: 'linux-amd64')
-    suffix = '.exe' if sys.platform == 'win32' else ''
+    self.mock(cipd, "get_platform", lambda: "linux-amd64")
+    suffix = ".exe" if sys.platform == "win32" else ""
 
     def fake_ensure(args, **kwargs):
-      if (args[0].endswith(os.path.join('bin', 'cipd' + suffix))
-          and args[1] == 'ensure' and '-json-output' in args):
-        idx = args.index('-json-output')
-        with open(args[idx + 1], 'w') as json_out:
+      if (
+        args[0].endswith(os.path.join("bin", "cipd" + suffix))
+        and args[1] == "ensure"
+        and "-json-output" in args
+      ):
+        idx = args.index("-json-output")
+        with open(args[idx + 1], "w") as json_out:
           json.dump(
-              {
-                  "error":
-                  "failed to resolve does/not/exists/linux-amd64@latest",
-                  "error_code": "invalid_version_error",
-                  "error_details": {
-                      "package": "does/not/exists/linux-amd64",
-                      "version": "latest"
-                  },
-                  "result": None
-              }, json_out)
+            {
+              "error": "failed to resolve does/not/exists/linux-amd64@latest",
+              "error_code": "invalid_version_error",
+              "error_details": {
+                "package": "does/not/exists/linux-amd64",
+                "version": "latest",
+              },
+              "result": None,
+            },
+            json_out,
+          )
         return 0
-      if args[0].endswith(os.sep + 'echo' + suffix):
+      if args[0].endswith(os.sep + "echo" + suffix):
         return 0
-      self.fail('unexpected: %s, %s' % (args, kwargs))
+      self.fail("unexpected: %s, %s" % (args, kwargs))
       return 1
 
     self.popen_fakes.append(fake_ensure)
-    result_json_path = os.path.join(self.tempdir, 'result.json')
-    cipd_cache = os.path.join(self.tempdir, 'cipd_cache')
+    result_json_path = os.path.join(self.tempdir, "result.json")
+    cipd_cache = os.path.join(self.tempdir, "cipd_cache")
     cmd = [
-        '--json',
-        result_json_path,
-        '--no-log',
-        '--cipd-package',
-        'bin:does/not/exists/${platform}:latest',
-        '--cipd-server',
-        self.cipd_server.url,
-        '--cipd-cache',
-        cipd_cache,
-        '--named-cache-root',
-        os.path.join(self.tempdir, 'named_cache'),
-        '--',
-        'bin/echo${EXECUTABLE_SUFFIX}',
-        'hello',
-        'world',
+      "--json",
+      result_json_path,
+      "--no-log",
+      "--cipd-package",
+      "bin:does/not/exists/${platform}:latest",
+      "--cipd-server",
+      self.cipd_server.url,
+      "--cipd-cache",
+      cipd_cache,
+      "--named-cache-root",
+      os.path.join(self.tempdir, "named_cache"),
+      "--",
+      "bin/echo${EXECUTABLE_SUFFIX}",
+      "hello",
+      "world",
     ]
     ret = run_isolated.main(cmd)
     self.assertEqual(1, ret)
-    with open(result_json_path, 'r') as fp:
+    with open(result_json_path, "r") as fp:
       result_json = json.load(fp)
-    self.assertEqual(1, len(result_json['missing_cipd']))
-    missing_cipd = result_json['missing_cipd'][0]
-    self.assertEqual('does/not/exists/linux-amd64',
-                     missing_cipd['package_name'])
-    self.assertEqual('invalid_version_error', missing_cipd['status'])
-    self.assertEqual('latest', missing_cipd['version'])
-    self.assertIsNone(missing_cipd['path'])
+    self.assertEqual(1, len(result_json["missing_cipd"]))
+    missing_cipd = result_json["missing_cipd"][0]
+    self.assertEqual(
+      "does/not/exists/linux-amd64", missing_cipd["package_name"]
+    )
+    self.assertEqual("invalid_version_error", missing_cipd["status"])
+    self.assertEqual("latest", missing_cipd["version"])
+    self.assertIsNone(missing_cipd["path"])
 
   def test_main_naked_with_cipd_client_no_packages(self):
-    self.mock(cipd, 'get_platform', lambda: 'linux-amd64')
+    self.mock(cipd, "get_platform", lambda: "linux-amd64")
 
-    cipd_cache = os.path.join(self.tempdir, 'cipd_cache')
+    cipd_cache = os.path.join(self.tempdir, "cipd_cache")
     cmd = [
-        '--no-log',
-        '--cipd-client-version',
-        'git:wowza',
-        '--cipd-server',
-        self.cipd_server.url,
-        '--cipd-cache',
-        cipd_cache,
-        '--named-cache-root',
-        os.path.join(self.tempdir, 'named_cache'),
-        '--relative-cwd',
-        'a',
-        '--root-dir',
-        self.tempdir,
-        '--',
-        'bin/echo${EXECUTABLE_SUFFIX}',
-        'hello',
-        'world',
+      "--no-log",
+      "--cipd-client-version",
+      "git:wowza",
+      "--cipd-server",
+      self.cipd_server.url,
+      "--cipd-cache",
+      cipd_cache,
+      "--named-cache-root",
+      os.path.join(self.tempdir, "named_cache"),
+      "--relative-cwd",
+      "a",
+      "--root-dir",
+      self.tempdir,
+      "--",
+      "bin/echo${EXECUTABLE_SUFFIX}",
+      "hello",
+      "world",
     ]
 
     pins = {
-        '': [('infra/tools/luci/isolated/linux-amd64',
-              run_isolated._LUCI_GO_REVISION)],
+      "": [
+        (
+          "infra/tools/luci/isolated/linux-amd64",
+          run_isolated._LUCI_GO_REVISION,
+        )
+      ],
     }
 
-    suffix = '.exe' if sys.platform == 'win32' else ''
+    suffix = ".exe" if sys.platform == "win32" else ""
 
     def fake_ensure(args, **kwargs):
-      if (args[0].endswith(os.path.join('bin', 'cipd' + suffix)) and
-          args[1] == 'ensure' and '-json-output' in args):
-        idx = args.index('-json-output')
-        with open(args[idx + 1], 'w') as json_out:
-          json.dump({
-              'result': {
-                  subdir: [{
-                      'package': pkg,
-                      'instance_id': ver
-                  } for pkg, ver in packages
-                          ] for subdir, packages in pins.items()
+      if (
+        args[0].endswith(os.path.join("bin", "cipd" + suffix))
+        and args[1] == "ensure"
+        and "-json-output" in args
+      ):
+        idx = args.index("-json-output")
+        with open(args[idx + 1], "w") as json_out:
+          json.dump(
+            {
+              "result": {
+                subdir: [
+                  {"package": pkg, "instance_id": ver} for pkg, ver in packages
+                ]
+                for subdir, packages in pins.items()
               }
-          }, json_out)
+            },
+            json_out,
+          )
         return 0
-      if args[0].endswith(os.sep + 'echo' + suffix):
+      if args[0].endswith(os.sep + "echo" + suffix):
         return 0
-      self.fail('unexpected: %s, %s' % (args, kwargs))
+      self.fail("unexpected: %s, %s" % (args, kwargs))
       return 1
 
     self.popen_fakes.append(fake_ensure)
@@ -765,55 +828,58 @@
 
     # The CIPD client was bootstrapped and hardlinked (or copied on Win).
     client_binary_file = os.path.join(
-        cipd_cache, 'clients', 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')
+      cipd_cache, "clients", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+    )
     self.assertTrue(fs.isfile(client_binary_file))
-    client_binary_link = os.path.join(cipd_cache, 'bin',
-                                      'cipd' + cipd.EXECUTABLE_SUFFIX)
+    client_binary_link = os.path.join(
+      cipd_cache, "bin", "cipd" + cipd.EXECUTABLE_SUFFIX
+    )
     self.assertTrue(fs.isfile(client_binary_link))
 
-    env = self.popen_calls[1][1].pop('env')
-    exec_path = self.ir_dir('a', 'bin', 'echo')
-    if sys.platform == 'win32':
-      exec_path += '.exe'
+    env = self.popen_calls[1][1].pop("env")
+    exec_path = self.ir_dir("a", "bin", "echo")
+    if sys.platform == "win32":
+      exec_path += ".exe"
     self.assertEqual(
-        [
-            (
-                [exec_path, 'hello', 'world'],
-                {
-                    'cwd': self.ir_dir('a'),
-                    'detached': True,
-                    'close_fds': True,
-                    'lower_priority': False,
-                    'containment': subprocess42.Containment(),
-                },
-            ),
-        ],
-        # Ignore `cipd ensure` for isolated client here.
-        self.popen_calls[1:])
+      [
+        (
+          [exec_path, "hello", "world"],
+          {
+            "cwd": self.ir_dir("a"),
+            "detached": True,
+            "close_fds": True,
+            "lower_priority": False,
+            "containment": subprocess42.Containment(),
+          },
+        ),
+      ],
+      # Ignore `cipd ensure` for isolated client here.
+      self.popen_calls[1:],
+    )
 
     # Directory with cipd client is in front of PATH.
-    path = env['PATH'].split(os.pathsep)
-    self.assertEqual(os.path.join(cipd_cache, 'bin'), path[0])
+    path = env["PATH"].split(os.pathsep)
+    self.assertEqual(os.path.join(cipd_cache, "bin"), path[0])
 
     # CIPD_CACHE_DIR is set.
-    self.assertEqual(os.path.join(cipd_cache, 'cache'), env['CIPD_CACHE_DIR'])
+    self.assertEqual(os.path.join(cipd_cache, "cache"), env["CIPD_CACHE_DIR"])
 
   def test_main_relative_cwd_no_cmd(self):
     cmd = self.DISABLE_CIPD_FOR_TESTS + [
-        '--relative-cwd',
-        'a',
+      "--relative-cwd",
+      "a",
     ]
     with self.assertRaises(SystemExit):
       run_isolated.main(cmd)
 
   def test_main_bad_relative_cwd(self):
     cmd = self.DISABLE_CIPD_FOR_TESTS + [
-        '--relative-cwd',
-        'a/../../b',
-        '--',
-        'bin/echo${EXECUTABLE_SUFFIX}',
-        'hello',
-        'world',
+      "--relative-cwd",
+      "a/../../b",
+      "--",
+      "bin/echo${EXECUTABLE_SUFFIX}",
+      "hello",
+      "world",
     ]
     with self.assertRaises(SystemExit):
       run_isolated.main(cmd)
@@ -824,74 +890,79 @@
     # for it to be kept, we need the tool to write to it. This is tested in the
     # smoke test.
     trimmed = []
+
     def trim_caches(caches, root, min_free_space, max_age_secs):
       trimmed.append(True)
       self.assertEqual(2, len(caches))
       self.assertTrue(root)
       # The name cache root is increased by the sum of the two hints and buffer.
       self.assertEqual(
-          run_isolated._FREE_SPACE_BUFFER_FOR_CIPD_PACKAGES +
-          2 * 1024 * 1024 * 1024 + 1100, min_free_space)
+        run_isolated._FREE_SPACE_BUFFER_FOR_CIPD_PACKAGES
+        + 2 * 1024 * 1024 * 1024
+        + 1100,
+        min_free_space,
+      )
       self.assertEqual(1814400, max_age_secs)
-    self.mock(local_caching, 'trim_caches', trim_caches)
-    nc = os.path.join(self.tempdir, 'named_cache')
+
+    self.mock(local_caching, "trim_caches", trim_caches)
+    nc = os.path.join(self.tempdir, "named_cache")
     cmd = self.DISABLE_CIPD_FOR_TESTS + [
-        '--no-log',
-        '--leak-temp-dir',
-        '100',
-        '--named-cache-root',
-        nc,
-        '--named-cache',
-        'cache_foo',
-        'foo',
-        '100',
-        '--named-cache',
-        'cache_bar',
-        'bar',
-        '1000',
-        '--',
-        'bin/echo${EXECUTABLE_SUFFIX}',
-        'hello',
-        'world',
+      "--no-log",
+      "--leak-temp-dir",
+      "100",
+      "--named-cache-root",
+      nc,
+      "--named-cache",
+      "cache_foo",
+      "foo",
+      "100",
+      "--named-cache",
+      "cache_bar",
+      "bar",
+      "1000",
+      "--",
+      "bin/echo${EXECUTABLE_SUFFIX}",
+      "hello",
+      "world",
     ]
     ret = run_isolated.main(cmd)
     self.assertEqual(0, ret)
 
-    for cache_name in ('cache_foo', 'cache_bar'):
-      named_path = os.path.join(nc, 'named', cache_name)
+    for cache_name in ("cache_foo", "cache_bar"):
+      named_path = os.path.join(nc, "named", cache_name)
       self.assertFalse(fs.exists(named_path))
     self.assertTrue(trimmed)
 
   def test_main_clean(self):
-    cas_cache_dir = os.path.join(self.tempdir, 'cas_cache')
-    named_cache_dir = os.path.join(self.tempdir, 'named_cache')
-    kvs_dir = os.path.join(self.tempdir, 'kvs_dir')
+    cas_cache_dir = os.path.join(self.tempdir, "cas_cache")
+    named_cache_dir = os.path.join(self.tempdir, "named_cache")
+    kvs_dir = os.path.join(self.tempdir, "kvs_dir")
     os.mkdir(kvs_dir)
-    with open(os.path.join(kvs_dir, 'dummy'), 'w') as f:
-      f.write('0' * 100)
+    with open(os.path.join(kvs_dir, "dummy"), "w") as f:
+      f.write("0" * 100)
 
     # override size threshold.
-    self.mock(run_isolated, '_CAS_KVS_CACHE_THRESHOLD', 99)
+    self.mock(run_isolated, "_CAS_KVS_CACHE_THRESHOLD", 99)
 
     min_free_space = 1
     max_cache_size = 2
 
     cmd = [
-        '--no-log',
-        '--clean',
-        # Shared options.
-        '--min-free-space',
-        str(min_free_space),
-        '--max-cache-size',
-        str(max_cache_size),
-        # CAS cache option.
-        '--cas-cache',
-        cas_cache_dir,
-        # Named cache option.
-        '--named-cache-root',
-        named_cache_dir,
-        '--kvs-dir',
-        kvs_dir,
+      "--no-log",
+      "--clean",
+      # Shared options.
+      "--min-free-space",
+      str(min_free_space),
+      "--max-cache-size",
+      str(max_cache_size),
+      # CAS cache option.
+      "--cas-cache",
+      cas_cache_dir,
+      # Named cache option.
+      "--named-cache-root",
+      named_cache_dir,
+      "--kvs-dir",
+      kvs_dir,
     ]
 
     def trim_caches_mock(caches, _root_dir, min_free_space, max_age_secs):
@@ -900,25 +971,29 @@
 
       # CAS cache.
       cas_cache = caches[0]
-      self.assertEqual(cas_cache.state_file,
-                       os.path.join(cas_cache_dir, cas_cache.STATE_FILE))
+      self.assertEqual(
+        cas_cache.state_file, os.path.join(cas_cache_dir, cas_cache.STATE_FILE)
+      )
       self.assertEqual(cas_cache.policies.max_cache_size, max_cache_size)
       self.assertEqual(cas_cache.policies.min_free_space, min_free_space)
       self.assertIsNone(cas_cache.policies.max_items)
 
       # Named cache.
       named_cache = caches[1]
-      self.assertEqual(named_cache.state_file,
-                       os.path.join(named_cache_dir, named_cache.STATE_FILE))
+      self.assertEqual(
+        named_cache.state_file,
+        os.path.join(named_cache_dir, named_cache.STATE_FILE),
+      )
       # max_cache_size, max_items, max_age_secs are hardcoded in
       # run_isolated.process_named_cache_options().
       self.assertEqual(named_cache._policies.max_cache_size, 1024**4)
       self.assertEqual(named_cache._policies.min_free_space, min_free_space)
       self.assertEqual(named_cache._policies.max_items, 50)
-      self.assertEqual(named_cache._policies.max_age_secs,
-                       run_isolated.MAX_AGE_SECS)
+      self.assertEqual(
+        named_cache._policies.max_age_secs, run_isolated.MAX_AGE_SECS
+      )
 
-    self.mock(local_caching, 'trim_caches', trim_caches_mock)
+    self.mock(local_caching, "trim_caches", trim_caches_mock)
 
     ret = run_isolated.main(cmd)
     self.assertEqual(0, ret)
@@ -928,85 +1003,89 @@
       fs.stat(kvs_dir)
 
   def test_modified_cwd(self):
-    self._run_tha_test(command=['../out/some.exe', 'arg'], relative_cwd='some')
-    self.assertEqual([
+    self._run_tha_test(command=["../out/some.exe", "arg"], relative_cwd="some")
+    self.assertEqual(
+      [
         (
-            [self.ir_dir('out', 'some.exe'), 'arg'],
-            {
-                'cwd': self.ir_dir('some'),
-                'detached': True,
-                'close_fds': True,
-                'lower_priority': False,
-                'containment': None,
-            },
+          [self.ir_dir("out", "some.exe"), "arg"],
+          {
+            "cwd": self.ir_dir("some"),
+            "detached": True,
+            "close_fds": True,
+            "lower_priority": False,
+            "containment": None,
+          },
         ),
-    ], self.popen_calls)
+      ],
+      self.popen_calls,
+    )
 
-  @unittest.skipIf(sys.platform == 'win32', 'crbug.com/1148174')
+  @unittest.skipIf(sys.platform == "win32", "crbug.com/1148174")
   def test_run_tha_test_non_isolated(self):
-    _ = self._run_tha_test(command=['/bin/echo', 'hello', 'world'])
-    self.assertEqual([
+    _ = self._run_tha_test(command=["/bin/echo", "hello", "world"])
+    self.assertEqual(
+      [
         (
-            ['/bin/echo', 'hello', 'world'],
-            {
-                'cwd': self.ir_dir(),
-                'detached': True,
-                'close_fds': True,
-                'lower_priority': False,
-                'containment': None,
-            },
+          ["/bin/echo", "hello", "world"],
+          {
+            "cwd": self.ir_dir(),
+            "detached": True,
+            "close_fds": True,
+            "lower_priority": False,
+            "containment": None,
+          },
         ),
-    ], self.popen_calls)
+      ],
+      self.popen_calls,
+    )
 
-  @unittest.skipIf(sys.platform == 'win32', 'crbug.com/1148174')
+  @unittest.skipIf(sys.platform == "win32", "crbug.com/1148174")
   def test_main_containment(self):
     def fake_wait(args, **kwargs):  # pylint: disable=unused-argument
       # Success.
       return 0
+
     self.popen_fakes.append(fake_wait)
     cmd = self.DISABLE_CIPD_FOR_TESTS + [
-        '--no-log',
-        '--lower-priority',
-        '--containment-type',
-        'JOB_OBJECT',
-        '--limit-processes',
-        '42',
-        '--limit-total-committed-memory',
-        '1024',
-        '--root-dir',
-        self.tempdir,
-        '--',
-        '/bin/echo',
-        'hello',
-        'world',
+      "--no-log",
+      "--lower-priority",
+      "--containment-type",
+      "JOB_OBJECT",
+      "--limit-processes",
+      "42",
+      "--limit-total-committed-memory",
+      "1024",
+      "--root-dir",
+      self.tempdir,
+      "--",
+      "/bin/echo",
+      "hello",
+      "world",
     ]
     ret = run_isolated.main(cmd)
     self.assertEqual(0, ret)
-    self.assertEqual([
+    self.assertEqual(
+      [
         (
-            ['/bin/echo', 'hello', 'world'],
-            {
-                'cwd':
-                    self.ir_dir(),
-                'detached':
-                    True,
-                'close_fds':
-                    True,
-                'lower_priority':
-                    True,
-                'containment':
-                    subprocess42.Containment(
-                        containment_type=subprocess42.Containment.JOB_OBJECT,
-                        limit_processes=42,
-                        limit_total_committed_memory=1024,
-                    ),
-            },
+          ["/bin/echo", "hello", "world"],
+          {
+            "cwd": self.ir_dir(),
+            "detached": True,
+            "close_fds": True,
+            "lower_priority": True,
+            "containment": subprocess42.Containment(
+              containment_type=subprocess42.Containment.JOB_OBJECT,
+              limit_processes=42,
+              limit_total_committed_memory=1024,
+            ),
+          },
         ),
-    ], self.popen_calls)
+      ],
+      self.popen_calls,
+    )
 
 
 class RunIsolatedTestRun(RunIsolatedTestBase):
-
   def setUp(self):
     super(RunIsolatedTestRun, self).setUp()
     # Starts a full CAS server mock and have run_tha_test() uploads results
@@ -1021,82 +1100,84 @@
   # Runs the actual command requested.
   def test_output(self):
     digest = self._server.archive_files(
-        {'cmd.py': b'import sys\n'
-         b'open(sys.argv[1], "w").write("bar")\n'})
+      {"cmd.py": b'import sys\nopen(sys.argv[1], "w").write("bar")\n'}
+    )
 
-    os.environ['RUN_ISOLATED_CAS_ADDRESS'] = self._server.address
+    os.environ["RUN_ISOLATED_CAS_ADDRESS"] = self._server.address
     data = run_isolated.TaskData(
-        command=['python3', 'cmd.py', '${ISOLATED_OUTDIR}/foo'],
-        relative_cwd=None,
-        cas_instance=None,
-        cas_digest=digest,
-        outputs=None,
-        install_named_caches=init_named_caches_stub,
-        leak_temp_dir=False,
-        root_dir=self.tempdir,
-        hard_timeout=60,
-        grace_period=30,
-        bot_file=None,
-        switch_to_account=False,
-        install_packages_fn=run_isolated.copy_local_packages,
-        cas_cache_dir='',
-        cas_cache_policies=local_caching.CachePolicies(0, 0, 0, 0),
-        cas_kvs='',
-        env={},
-        env_prefix={},
-        lower_priority=False,
-        containment=None,
-        trim_caches_fn=trim_caches_stub)
+      command=["python3", "cmd.py", "${ISOLATED_OUTDIR}/foo"],
+      relative_cwd=None,
+      cas_instance=None,
+      cas_digest=digest,
+      outputs=None,
+      install_named_caches=init_named_caches_stub,
+      leak_temp_dir=False,
+      root_dir=self.tempdir,
+      hard_timeout=60,
+      grace_period=30,
+      bot_file=None,
+      switch_to_account=False,
+      install_packages_fn=run_isolated.copy_local_packages,
+      cas_cache_dir="",
+      cas_cache_policies=local_caching.CachePolicies(0, 0, 0, 0),
+      cas_kvs="",
+      env={},
+      env_prefix={},
+      lower_priority=False,
+      containment=None,
+      trim_caches_fn=trim_caches_stub,
+    )
 
-    result_json = os.path.join(self.tempdir, 'result.json')
+    result_json = os.path.join(self.tempdir, "result.json")
     ret = run_isolated.run_tha_test(data, result_json)
     self.assertEqual(0, ret)
     with open(result_json) as f:
       result = json.load(f)
 
-    output_digest = result['cas_output_root']['digest']
-    dest = os.path.join(self.tempdir, 'output')
+    output_digest = result["cas_output_root"]["digest"]
+    dest = os.path.join(self.tempdir, "output")
     self._server.download(
-        output_digest['hash'] + '/' + str(output_digest['size_bytes']), dest)
+      output_digest["hash"] + "/" + str(output_digest["size_bytes"]), dest
+    )
 
-    self.assertEqual(os.listdir(dest), ['foo'])
-    with open(os.path.join(dest, 'foo'), 'rb') as f:
-      self.assertEqual(f.read(), b'bar')
+    self.assertEqual(os.listdir(dest), ["foo"])
+    with open(os.path.join(dest, "foo"), "rb") as f:
+      self.assertEqual(f.read(), b"bar")
 
   def test_write_without_empty_cas_does_not_crash(self):
-    """Test is here to prevent regression of: https://crbug.com/1504567
-    """
+    """Test is here to prevent regression of: https://crbug.com/1504567"""
     cmd = """
 import os
 outpath = os.path.join("${ISOLATED_OUTDIR}", "foo")
 with open(outpath, "w") as f:
   f.write("dont crash")
     """
-    os.environ.pop('RUN_ISOLATED_CAS_ADDRESS', None)
+    os.environ.pop("RUN_ISOLATED_CAS_ADDRESS", None)
     data = run_isolated.TaskData(
-        command=['python3', '-c', cmd],
-        relative_cwd=None,
-        cas_instance=None,
-        cas_digest=None,
-        outputs=None,
-        install_named_caches=init_named_caches_stub,
-        leak_temp_dir=False,
-        root_dir=self.tempdir,
-        hard_timeout=60,
-        grace_period=30,
-        bot_file=None,
-        switch_to_account=False,
-        install_packages_fn=run_isolated.copy_local_packages,
-        cas_cache_dir='',
-        cas_cache_policies=local_caching.CachePolicies(0, 0, 0, 0),
-        cas_kvs='',
-        env={},
-        env_prefix={},
-        lower_priority=False,
-        containment=None,
-        trim_caches_fn=trim_caches_stub)
+      command=["python3", "-c", cmd],
+      relative_cwd=None,
+      cas_instance=None,
+      cas_digest=None,
+      outputs=None,
+      install_named_caches=init_named_caches_stub,
+      leak_temp_dir=False,
+      root_dir=self.tempdir,
+      hard_timeout=60,
+      grace_period=30,
+      bot_file=None,
+      switch_to_account=False,
+      install_packages_fn=run_isolated.copy_local_packages,
+      cas_cache_dir="",
+      cas_cache_policies=local_caching.CachePolicies(0, 0, 0, 0),
+      cas_kvs="",
+      env={},
+      env_prefix={},
+      lower_priority=False,
+      containment=None,
+      trim_caches_fn=trim_caches_stub,
+    )
 
-    result_json = os.path.join(self.tempdir, 'result.json')
+    result_json = os.path.join(self.tempdir, "result.json")
     ret = run_isolated.run_tha_test(data, result_json)
     self.assertEqual(0, ret)
 
@@ -1104,118 +1185,122 @@
 class RunIsolatedTestCase(RunIsolatedTestRun):
   def test_bad_cas_json_output(self):
     def dump_bad_json(cmd, _):
-      json_path = cmd[cmd.index('-dump-json') + 1]
-      with open(json_path, 'w') as fp:
+      json_path = cmd[cmd.index("-dump-json") + 1]
+      with open(json_path, "w") as fp:
         fp.write("{i[]nv[[]alid js{}on")
 
     digest = self._server.archive_files(
-        {'cmd.py': b'import sys\n'
-         b'open(sys.argv[1], "w").write("bar")\n'})
+      {"cmd.py": b'import sys\nopen(sys.argv[1], "w").write("bar")\n'}
+    )
 
     self.mock(run_isolated, "_run_go_cmd_and_wait", dump_bad_json)
 
     data = run_isolated.TaskData(
-        command=['python3', 'cmd.py', '${ISOLATED_OUTDIR}/foo'],
-        relative_cwd=None,
-        cas_instance="some_instance",
-        cas_digest=digest,
-        outputs=None,
-        install_named_caches=init_named_caches_stub,
-        leak_temp_dir=False,
-        root_dir=self.tempdir,
-        hard_timeout=60,
-        grace_period=30,
-        bot_file=None,
-        switch_to_account=False,
-        install_packages_fn=run_isolated.copy_local_packages,
-        cas_cache_dir='',
-        cas_cache_policies=local_caching.CachePolicies(0, 0, 0, 0),
-        cas_kvs=None,
-        env={},
-        env_prefix={},
-        lower_priority=False,
-        containment=None,
-        trim_caches_fn=trim_caches_stub)
+      command=["python3", "cmd.py", "${ISOLATED_OUTDIR}/foo"],
+      relative_cwd=None,
+      cas_instance="some_instance",
+      cas_digest=digest,
+      outputs=None,
+      install_named_caches=init_named_caches_stub,
+      leak_temp_dir=False,
+      root_dir=self.tempdir,
+      hard_timeout=60,
+      grace_period=30,
+      bot_file=None,
+      switch_to_account=False,
+      install_packages_fn=run_isolated.copy_local_packages,
+      cas_cache_dir="",
+      cas_cache_policies=local_caching.CachePolicies(0, 0, 0, 0),
+      cas_kvs=None,
+      env={},
+      env_prefix={},
+      lower_priority=False,
+      containment=None,
+      trim_caches_fn=trim_caches_stub,
+    )
 
-    result_json = os.path.join(self.tempdir, 'result.json')
+    result_json = os.path.join(self.tempdir, "result.json")
     run_isolated.run_tha_test(data, result_json)
     with open(result_json) as f:
       result = json.load(f)
     # Don't care the exact error, so long as its not reported as a missing_cas
-    self.assertTrue(result.get('internal_failure'))
-    self.assertIsNone(result.get('missing_cas'))
+    self.assertTrue(result.get("internal_failure"))
+    self.assertIsNone(result.get("missing_cas"))
 
   def test_bad_cas_digest(self):
     digest = "notvaliddigest"
-    os.environ['RUN_ISOLATED_CAS_ADDRESS'] = self._server.address
+    os.environ["RUN_ISOLATED_CAS_ADDRESS"] = self._server.address
     data = run_isolated.TaskData(
-        command=['python3', 'cmd.py', '${ISOLATED_OUTDIR}/foo'],
-        relative_cwd=None,
-        cas_instance="some_instance",
-        cas_digest=digest,
-        outputs=None,
-        install_named_caches=init_named_caches_stub,
-        leak_temp_dir=False,
-        root_dir=self.tempdir,
-        hard_timeout=60,
-        grace_period=30,
-        bot_file=None,
-        switch_to_account=False,
-        install_packages_fn=run_isolated.copy_local_packages,
-        cas_cache_dir='',
-        cas_cache_policies=local_caching.CachePolicies(0, 0, 0, 0),
-        cas_kvs='',
-        env={},
-        env_prefix={},
-        lower_priority=False,
-        containment=None,
-        trim_caches_fn=trim_caches_stub)
+      command=["python3", "cmd.py", "${ISOLATED_OUTDIR}/foo"],
+      relative_cwd=None,
+      cas_instance="some_instance",
+      cas_digest=digest,
+      outputs=None,
+      install_named_caches=init_named_caches_stub,
+      leak_temp_dir=False,
+      root_dir=self.tempdir,
+      hard_timeout=60,
+      grace_period=30,
+      bot_file=None,
+      switch_to_account=False,
+      install_packages_fn=run_isolated.copy_local_packages,
+      cas_cache_dir="",
+      cas_cache_policies=local_caching.CachePolicies(0, 0, 0, 0),
+      cas_kvs="",
+      env={},
+      env_prefix={},
+      lower_priority=False,
+      containment=None,
+      trim_caches_fn=trim_caches_stub,
+    )
 
-    result_json = os.path.join(self.tempdir, 'result.json')
+    result_json = os.path.join(self.tempdir, "result.json")
     ret = run_isolated.run_tha_test(data, result_json)
     with open(result_json) as f:
       result = json.load(f)
     self.assertEqual(1, ret)
-    self.assertEqual(digest, result['missing_cas'][0]['digest'])
-    self.assertEqual('some_instance', result['missing_cas'][0]['instance'])
+    self.assertEqual(digest, result["missing_cas"][0]["digest"])
+    self.assertEqual("some_instance", result["missing_cas"][0]["instance"])
 
   def test_bad_cipd_package(self):
     def emulate_bad_cipd(_run_dir, cas_dir):
-      raise errors.NonRecoverableCipdException("missing_cipd", "foo_package",
-                                               "not/found/foo", "deadbeef")
+      raise errors.NonRecoverableCipdException(
+        "missing_cipd", "foo_package", "not/found/foo", "deadbeef"
+      )
 
     data = run_isolated.TaskData(
-        command=['python3', 'cmd.py', '${ISOLATED_OUTDIR}/foo'],
-        relative_cwd=None,
-        cas_instance=None,
-        cas_digest=None,
-        outputs=None,
-        install_named_caches=init_named_caches_stub,
-        leak_temp_dir=False,
-        root_dir=self.tempdir,
-        hard_timeout=60,
-        grace_period=30,
-        bot_file=None,
-        switch_to_account=False,
-        install_packages_fn=emulate_bad_cipd,
-        cas_cache_dir='',
-        cas_cache_policies=local_caching.CachePolicies(0, 0, 0, 0),
-        cas_kvs='',
-        env={},
-        env_prefix={},
-        lower_priority=False,
-        containment=None,
-        trim_caches_fn=trim_caches_stub)
+      command=["python3", "cmd.py", "${ISOLATED_OUTDIR}/foo"],
+      relative_cwd=None,
+      cas_instance=None,
+      cas_digest=None,
+      outputs=None,
+      install_named_caches=init_named_caches_stub,
+      leak_temp_dir=False,
+      root_dir=self.tempdir,
+      hard_timeout=60,
+      grace_period=30,
+      bot_file=None,
+      switch_to_account=False,
+      install_packages_fn=emulate_bad_cipd,
+      cas_cache_dir="",
+      cas_cache_policies=local_caching.CachePolicies(0, 0, 0, 0),
+      cas_kvs="",
+      env={},
+      env_prefix={},
+      lower_priority=False,
+      containment=None,
+      trim_caches_fn=trim_caches_stub,
+    )
 
-    result_json = os.path.join(self.tempdir, 'result.json')
+    result_json = os.path.join(self.tempdir, "result.json")
     ret = run_isolated.run_tha_test(data, result_json)
     with open(result_json) as f:
       result = json.load(f)
 
     self.assertEqual(1, ret)
-    self.assertEqual('foo_package', result['missing_cipd'][0]['package_name'])
-    self.assertEqual('not/found/foo', result['missing_cipd'][0]['path'])
-    self.assertEqual('deadbeef', result['missing_cipd'][0]['version'])
+    self.assertEqual("foo_package", result["missing_cipd"][0]["package_name"])
+    self.assertEqual("not/found/foo", result["missing_cipd"][0]["path"])
+    self.assertEqual("deadbeef", result["missing_cipd"][0]["version"])
 
 
 FILE, LINK, RELATIVE_LINK, DIR = range(4)
@@ -1230,12 +1315,12 @@
       full_path = os.path.join(run_dir, path)
       (t, content) = src_dir[path]
       if t == FILE:
-        with open(full_path, 'w') as f:
+        with open(full_path, "w") as f:
           f.write(content)
       elif t == RELATIVE_LINK:
         fs.symlink(content, full_path)
       elif t == LINK:
-        root_dir = os.path.join(self.tempdir, 'ir')
+        root_dir = os.path.join(self.tempdir, "ir")
         real_path = os.path.join(root_dir, content)
         fs.symlink(real_path, full_path)
       else:
@@ -1243,8 +1328,8 @@
         self.create_src_tree(os.path.join(run_dir, path), content)
 
   def link_outputs_test(self, src_dir, outputs):
-    run_dir = os.path.join(self.tempdir, 'ir')
-    out_dir = os.path.join(self.tempdir, 'io')
+    run_dir = os.path.join(self.tempdir, "ir")
+    out_dir = os.path.join(self.tempdir, "io")
     fs.mkdir(run_dir)
     fs.mkdir(out_dir)
     self.create_src_tree(run_dir, src_dir)
@@ -1252,222 +1337,251 @@
 
   def test_file(self):
     src_dir = {
-        'foo_file': (FILE, 'contents of foo'),
+      "foo_file": (FILE, "contents of foo"),
     }
-    outputs = ['foo_file']
+    outputs = ["foo_file"]
     expected = {
-        'foo_file': 'contents of foo',
+      "foo_file": "contents of foo",
     }
     self.link_outputs_test(src_dir, outputs)
     self.assertExpectedTree(expected)
 
   def test_symlink_to_file(self):
     src_dir = {
-        'foo_file': (FILE, 'contents of foo'),
-        'foo_link': (LINK, 'foo_file'),
+      "foo_file": (FILE, "contents of foo"),
+      "foo_link": (LINK, "foo_file"),
     }
-    outputs = ['foo_link']
+    outputs = ["foo_link"]
     expected = {
-        'foo_link': 'contents of foo',
+      "foo_link": "contents of foo",
     }
     self.link_outputs_test(src_dir, outputs)
     self.assertExpectedTree(expected)
 
   def test_dir_containing_files(self):
     src_dir = {
-        'subdir': (DIR, {
-            'child_a': (FILE, 'contents of a'),
-            'child_b': (FILE, 'contents of b'),
-        })
+      "subdir": (
+        DIR,
+        {
+          "child_a": (FILE, "contents of a"),
+          "child_b": (FILE, "contents of b"),
+        },
+      )
     }
-    outputs = [os.path.join('subdir', '')]
+    outputs = [os.path.join("subdir", "")]
     expected = {
-        os.path.join('subdir', 'child_a'): 'contents of a',
-        os.path.join('subdir', 'child_b'): 'contents of b',
+      os.path.join("subdir", "child_a"): "contents of a",
+      os.path.join("subdir", "child_b"): "contents of b",
     }
     self.link_outputs_test(src_dir, outputs)
     self.assertExpectedTree(expected)
 
   def test_relative_symlink(self):
     src_dir = {
-        'foo_file': (FILE, 'contents of foo'),
-        'subdir': (DIR, {
-            'foo_link': (RELATIVE_LINK, '../foo_file'),
-            'subsubdir': (DIR, {
-                'bar_link': (RELATIVE_LINK, '../foo_link'),
-            }),
-        }),
+      "foo_file": (FILE, "contents of foo"),
+      "subdir": (
+        DIR,
+        {
+          "foo_link": (RELATIVE_LINK, "../foo_file"),
+          "subsubdir": (
+            DIR,
+            {
+              "bar_link": (RELATIVE_LINK, "../foo_link"),
+            },
+          ),
+        },
+      ),
     }
-    outputs = [os.path.join('subdir', 'subsubdir', 'bar_link')]
+    outputs = [os.path.join("subdir", "subsubdir", "bar_link")]
     expected = {
-        os.path.join('subdir', 'subsubdir', 'bar_link'): 'contents of foo',
+      os.path.join("subdir", "subsubdir", "bar_link"): "contents of foo",
     }
     self.link_outputs_test(src_dir, outputs)
     self.assertExpectedTree(expected)
 
   def test_symlink_to_dir_containing_files(self):
     src_dir = {
-        'subdir_link': (LINK, 'subdir'),
-        'subdir': (DIR, {
-            'child_a': (FILE, 'contents of a'),
-        }),
+      "subdir_link": (LINK, "subdir"),
+      "subdir": (
+        DIR,
+        {
+          "child_a": (FILE, "contents of a"),
+        },
+      ),
     }
-    outputs = ['subdir_link']
+    outputs = ["subdir_link"]
     expected = {
-        os.path.join('subdir_link', 'child_a'): 'contents of a',
+      os.path.join("subdir_link", "child_a"): "contents of a",
     }
     self.link_outputs_test(src_dir, outputs)
     self.assertExpectedTree(expected)
 
   def test_symlink_to_symlink_to_dir_containing_files(self):
     src_dir = {
-        'subdir_link': (LINK, 'subdir_link2'),
-        'subdir_link2': (LINK, 'subdir'),
-        'subdir': (DIR, {
-            'child_a': (FILE, 'contents of a'),
-            'child_b': (FILE, 'contents of b'),
-        }),
+      "subdir_link": (LINK, "subdir_link2"),
+      "subdir_link2": (LINK, "subdir"),
+      "subdir": (
+        DIR,
+        {
+          "child_a": (FILE, "contents of a"),
+          "child_b": (FILE, "contents of b"),
+        },
+      ),
     }
-    outputs = ['subdir_link']
+    outputs = ["subdir_link"]
     expected = {
-        os.path.join('subdir_link', 'child_a'): 'contents of a',
-        os.path.join('subdir_link', 'child_b'): 'contents of b',
+      os.path.join("subdir_link", "child_a"): "contents of a",
+      os.path.join("subdir_link", "child_b"): "contents of b",
     }
     self.link_outputs_test(src_dir, outputs)
     self.assertExpectedTree(expected)
 
   def test_empty_dir(self):
     src_dir = {
-        'subdir': (DIR, {}),
+      "subdir": (DIR, {}),
     }
-    outputs = [os.path.join('subdir', '')]
+    outputs = [os.path.join("subdir", "")]
     expected = {
-        os.path.join('subdir', ''): '',
+      os.path.join("subdir", ""): "",
     }
     self.link_outputs_test(src_dir, outputs)
     self.assertExpectedTree(expected)
 
   def test_dir_ignore_trailing_slash(self):
     src_dir = {
-        'subdir': (DIR, {}),
+      "subdir": (DIR, {}),
     }
-    outputs = [os.path.join('subdir', '')]
+    outputs = [os.path.join("subdir", "")]
     expected = {
-        'subdir': '',
+      "subdir": "",
     }
     self.link_outputs_test(src_dir, outputs)
     self.assertExpectedTree(expected)
 
   def test_dir_containing_empty_dir(self):
     src_dir = {
-        'subdir': (DIR, {
-            'subsubdir': (DIR, ''),
-        }),
+      "subdir": (
+        DIR,
+        {
+          "subsubdir": (DIR, ""),
+        },
+      ),
     }
-    outputs = [os.path.join('subdir', '')]
+    outputs = [os.path.join("subdir", "")]
     expected = {
-        os.path.join('subdir', 'subsubdir', ''): '',
-        os.path.join('subdir', 'subsubdir', ''): '',
+      os.path.join("subdir", "subsubdir", ""): "",
+      os.path.join("subdir", "subsubdir", ""): "",
     }
     self.link_outputs_test(src_dir, outputs)
     self.assertExpectedTree(expected)
 
   def test_symlink_to_empty_dir(self):
     src_dir = {
-        'subdir': (DIR, {}),
-        'subdir_link': (LINK, 'subdir'),
+      "subdir": (DIR, {}),
+      "subdir_link": (LINK, "subdir"),
     }
-    outputs = ['subdir_link']
+    outputs = ["subdir_link"]
     expected = {
-        os.path.join('subdir_link', ''): '',
+      os.path.join("subdir_link", ""): "",
     }
     self.link_outputs_test(src_dir, outputs)
     self.assertExpectedTree(expected)
 
   def test_symlink_to_nonexistent_file(self):
     src_dir = {
-        'bad_link': (LINK, 'nonexistent_file'),
+      "bad_link": (LINK, "nonexistent_file"),
     }
-    outputs = ['bad_link']
+    outputs = ["bad_link"]
     expected = {}
     self.link_outputs_test(src_dir, outputs)
     self.assertExpectedTree(expected)
 
   def test_symlink_to_symlink_to_file(self):
     src_dir = {
-        'first_link': (LINK, 'second_link'),
-        'second_link': (LINK, 'foo_file'),
-        'foo_file': (FILE, 'contents of foo'),
+      "first_link": (LINK, "second_link"),
+      "second_link": (LINK, "foo_file"),
+      "foo_file": (FILE, "contents of foo"),
     }
-    outputs = ['first_link']
+    outputs = ["first_link"]
     expected = {
-        'first_link': 'contents of foo',
+      "first_link": "contents of foo",
     }
     self.link_outputs_test(src_dir, outputs)
     self.assertExpectedTree(expected)
 
   def test_symlink_to_symlink_to_nonexistent_file(self):
     src_dir = {
-        'first_link': (LINK, 'second_link'),
-        'second_link': (LINK, 'nonexistent_file'),
+      "first_link": (LINK, "second_link"),
+      "second_link": (LINK, "nonexistent_file"),
     }
-    outputs = ['first_link']
+    outputs = ["first_link"]
     expected = {}
     self.link_outputs_test(src_dir, outputs)
     self.assertExpectedTree(expected)
 
   def test_symlink_to_file_in_parent(self):
     src_dir = {
-        'subdir': (DIR, {
-            'subsubdir': (DIR, {
-                'foo_link': (LINK, 'subdir/foo_file'),
-            }),
-            'foo_file': (FILE, 'contents of foo'),
-        }),
+      "subdir": (
+        DIR,
+        {
+          "subsubdir": (
+            DIR,
+            {
+              "foo_link": (LINK, "subdir/foo_file"),
+            },
+          ),
+          "foo_file": (FILE, "contents of foo"),
+        },
+      ),
     }
     outputs = [
-      os.path.join('subdir', 'subsubdir', 'foo_link'),
-      os.path.join('subdir', 'foo_file'),
+      os.path.join("subdir", "subsubdir", "foo_link"),
+      os.path.join("subdir", "foo_file"),
     ]
     expected = {
-        os.path.join('subdir', 'subsubdir', 'foo_link'): 'contents of foo',
-        os.path.join('subdir', 'foo_file'): 'contents of foo',
+      os.path.join("subdir", "subsubdir", "foo_link"): "contents of foo",
+      os.path.join("subdir", "foo_file"): "contents of foo",
     }
     self.link_outputs_test(src_dir, outputs)
     self.assertExpectedTree(expected)
 
   def test_symlink_to_file_in_dir(self):
     src_dir = {
-        'subdir_link': (LINK, 'subdir/child_a'),
-        'subdir': (DIR, {
-            'child_a': (FILE, 'contents of a'),
-        }),
+      "subdir_link": (LINK, "subdir/child_a"),
+      "subdir": (
+        DIR,
+        {
+          "child_a": (FILE, "contents of a"),
+        },
+      ),
     }
-    outputs = ['subdir_link']
+    outputs = ["subdir_link"]
     expected = {
-        'subdir_link': 'contents of a',
+      "subdir_link": "contents of a",
     }
     self.link_outputs_test(src_dir, outputs)
     self.assertExpectedTree(expected)
 
   def test_symlink_to_symlink_to_file_in_dir(self):
     src_dir = {
-        'first_link': (LINK, 'subdir_link'),
-        'subdir_link': (LINK, 'subdir/child_a'),
-        'subdir': (DIR, {
-            'child_a': (FILE, 'contents of a'),
-        }),
+      "first_link": (LINK, "subdir_link"),
+      "subdir_link": (LINK, "subdir/child_a"),
+      "subdir": (
+        DIR,
+        {
+          "child_a": (FILE, "contents of a"),
+        },
+      ),
     }
-    outputs = ['first_link']
+    outputs = ["first_link"]
     expected = {
-        'first_link': 'contents of a',
+      "first_link": "contents of a",
     }
     self.link_outputs_test(src_dir, outputs)
     self.assertExpectedTree(expected)
 
 
 class RunIsolatedTestOutputFiles(RunIsolatedTestBase):
-
   def setUp(self):
     super(RunIsolatedTestOutputFiles, self).setUp()
 
@@ -1475,7 +1589,7 @@
     # back after the task completed.
     self._server = cas_util.LocalCAS(self.tempdir)
     self._server.start()
-    os.environ['RUN_ISOLATED_CAS_ADDRESS'] = self._server.address
+    os.environ["RUN_ISOLATED_CAS_ADDRESS"] = self._server.address
 
   def tearDown(self):
     self._server.stop()
@@ -1491,49 +1605,51 @@
     # bardir --> bar1
     #
     # Create the symlinks only on Linux.
-    cas_digest = self._server.archive_files({
-        'cmd.py':
-        b'import os\n'
-        b'import sys\n'
+    cas_digest = self._server.archive_files(
+      {
+        "cmd.py": b"import os\n"
+        b"import sys\n"
         b'open(sys.argv[1], "w").write("foo1")\n'
         b'bar1_path = os.path.join(sys.argv[3], "bar1")\n'
         b'open(bar1_path, "w").write("bar1")\n'
         b'if sys.platform == "linux":\n'
         b'  foo_realpath = os.path.abspath("foo2_content")\n'
         b'  open(foo_realpath, "w").write("foo2")\n'
-        b'  os.symlink(foo_realpath, sys.argv[2])\n'
-        b'else:\n'
+        b"  os.symlink(foo_realpath, sys.argv[2])\n"
+        b"else:\n"
         b'  open(sys.argv[2], "w").write("foo2")\n'
-    })
+      }
+    )
 
     data = run_isolated.TaskData(
-        command=['python3', 'cmd.py', 'foo1', 'foodir/foo2_sl', 'bardir/'],
-        relative_cwd=None,
-        cas_instance=None,
-        cas_digest=cas_digest,
-        outputs=[
-            'foo1',
-            # They must be in OS native path.
-            os.path.join('foodir', 'foo2_sl'),
-            os.path.join('bardir', ''),
-        ],
-        install_named_caches=init_named_caches_stub,
-        leak_temp_dir=False,
-        root_dir=self.tempdir,
-        hard_timeout=60,
-        grace_period=30,
-        bot_file=None,
-        switch_to_account=False,
-        install_packages_fn=run_isolated.copy_local_packages,
-        cas_cache_dir='',
-        cas_cache_policies=local_caching.CachePolicies(0, 0, 0, 0),
-        cas_kvs='',
-        env={},
-        env_prefix={},
-        lower_priority=False,
-        containment=None,
-        trim_caches_fn=trim_caches_stub)
-    result_json = os.path.join(self.tempdir, 'result.json')
+      command=["python3", "cmd.py", "foo1", "foodir/foo2_sl", "bardir/"],
+      relative_cwd=None,
+      cas_instance=None,
+      cas_digest=cas_digest,
+      outputs=[
+        "foo1",
+        # They must be in OS native path.
+        os.path.join("foodir", "foo2_sl"),
+        os.path.join("bardir", ""),
+      ],
+      install_named_caches=init_named_caches_stub,
+      leak_temp_dir=False,
+      root_dir=self.tempdir,
+      hard_timeout=60,
+      grace_period=30,
+      bot_file=None,
+      switch_to_account=False,
+      install_packages_fn=run_isolated.copy_local_packages,
+      cas_cache_dir="",
+      cas_cache_policies=local_caching.CachePolicies(0, 0, 0, 0),
+      cas_kvs="",
+      env={},
+      env_prefix={},
+      lower_priority=False,
+      containment=None,
+      trim_caches_fn=trim_caches_stub,
+    )
+    result_json = os.path.join(self.tempdir, "result.json")
     ret = run_isolated.run_tha_test(data, result_json)
     self.assertEqual(0, ret)
 
@@ -1542,21 +1658,24 @@
     with open(result_json) as f:
       result = json.load(f)
 
-    output_digest = result['cas_output_root']['digest']
-    dest = os.path.join(self.tempdir, 'outputs')
+    output_digest = result["cas_output_root"]["digest"]
+    dest = os.path.join(self.tempdir, "outputs")
     self._server.download(
-        output_digest['hash'] + '/' + str(output_digest['size_bytes']), dest)
+      output_digest["hash"] + "/" + str(output_digest["size_bytes"]), dest
+    )
 
     self.assertExpectedTree(
-        {
-            os.path.join('foodir', 'foo2_sl'): 'foo2',
-            'foo1': 'foo1',
-            os.path.join('bardir', 'bar1'): 'bar1',
-        }, dest)
+      {
+        os.path.join("foodir", "foo2_sl"): "foo2",
+        "foo1": "foo1",
+        os.path.join("bardir", "bar1"): "bar1",
+      },
+      dest,
+    )
 
-    self.assertCountEqual(os.listdir(dest), ['foodir', 'foo1', 'bardir'])
-    self.assertEqual(os.listdir(os.path.join(dest, 'foodir')), ['foo2_sl'])
-    self.assertEqual(os.listdir(os.path.join(dest, 'bardir')), ['bar1'])
+    self.assertCountEqual(os.listdir(dest), ["foodir", "foo1", "bardir"])
+    self.assertEqual(os.listdir(os.path.join(dest, "foodir")), ["foo2_sl"])
+    self.assertEqual(os.listdir(os.path.join(dest, "bardir")), ["bar1"])
 
 
 class RunIsolatedJsonTest(RunIsolatedTestBase):
@@ -1570,7 +1689,7 @@
     # back after the task completed.
     self._server = cas_util.LocalCAS(self.tempdir)
     self._server.start()
-    os.environ['RUN_ISOLATED_CAS_ADDRESS'] = self._server.address
+    os.environ["RUN_ISOLATED_CAS_ADDRESS"] = self._server.address
 
   def tearDown(self):
     self._server.stop()
@@ -1578,79 +1697,82 @@
 
   def test_main_json(self):
     sub_cmd = [
-        'python3',
-        '-c',
-        'import sys; open(sys.argv[1], "wb").write(b"generated data\\n")',
-        '${ISOLATED_OUTDIR}/out.txt',
+      "python3",
+      "-c",
+      'import sys; open(sys.argv[1], "wb").write(b"generated data\\n")',
+      "${ISOLATED_OUTDIR}/out.txt",
     ]
 
-    out = os.path.join(self.tempdir, 'res.json')
-    cmd = self.DISABLE_CIPD_FOR_TESTS + [
-        '--no-log',
-        '--named-cache-root',
-        os.path.join(self.tempdir, 'named_cache'),
-        '--json',
+    out = os.path.join(self.tempdir, "res.json")
+    cmd = (
+      self.DISABLE_CIPD_FOR_TESTS
+      + [
+        "--no-log",
+        "--named-cache-root",
+        os.path.join(self.tempdir, "named_cache"),
+        "--json",
         out,
-        '--root-dir',
+        "--root-dir",
         self.tempdir,
-        '--',
-    ] + sub_cmd
+        "--",
+      ]
+      + sub_cmd
+    )
     ret = run_isolated.main(cmd)
     self.assertEqual(0, ret)
 
     cas_hash = (
-        '5868195adddf130eeb09a939bc40a17033fb058288b7b0bec0144dcb07e9cf78')
+      "5868195adddf130eeb09a939bc40a17033fb058288b7b0bec0144dcb07e9cf78"
+    )
 
     expected = {
-        'exit_code': 0,
-        'had_hard_timeout': False,
-        'internal_failure': None,
-        'cas_output_root': {
-            # Local cas server uses its own default instance.
-            'cas_instance': None,
-            'digest': {
-                'hash': cas_hash,
-                'size_bytes': 81
-            },
+      "exit_code": 0,
+      "had_hard_timeout": False,
+      "internal_failure": None,
+      "cas_output_root": {
+        # Local cas server uses its own default instance.
+        "cas_instance": None,
+        "digest": {"hash": cas_hash, "size_bytes": 81},
+      },
+      "outputs_ref": None,
+      "stats": {
+        "trim_caches": {},
+        "isolated": {
+          "download": {},
+          "upload": {
+            "items_cold": [15, 81],
+            "items_hot": None,
+            "result": "success",
+            "size_cold": 96,
+            "size_hot": 0,
+          },
         },
-        'outputs_ref': None,
-        'stats': {
-            'trim_caches': {},
-            'isolated': {
-                'download': {},
-                'upload': {
-                    'items_cold': [15, 81],
-                    'items_hot': None,
-                    'result': 'success',
-                    'size_cold': 96,
-                    'size_hot': 0,
-                },
-            },
-            'named_caches': {
-                'install': {},
-                'uninstall': {},
-            },
-            'cleanup': {},
+        "named_caches": {
+          "install": {},
+          "uninstall": {},
         },
-        'version': 5,
+        "cleanup": {},
+      },
+      "version": 5,
     }
     actual = tools.read_json(out)
     # duration can be exactly 0 due to low timer resolution, especially but not
     # exclusively on Windows.
-    self.assertLessEqual(0, actual.pop('duration'))
-    self.assertLessEqual(0, actual['stats']['trim_caches'].pop('duration'))
-    actual_upload_stats = actual['stats']['isolated']['upload']
-    self.assertLessEqual(0, actual_upload_stats.pop('duration'))
-    named_caches_stats = actual['stats']['named_caches']
-    self.assertLessEqual(0, named_caches_stats['install'].pop('duration'))
-    self.assertLessEqual(0, named_caches_stats['uninstall'].pop('duration'))
-    self.assertLessEqual(0, actual['stats']['cleanup'].pop('duration'))
-    for i in ('items_cold', 'items_hot'):
+    self.assertLessEqual(0, actual.pop("duration"))
+    self.assertLessEqual(0, actual["stats"]["trim_caches"].pop("duration"))
+    actual_upload_stats = actual["stats"]["isolated"]["upload"]
+    self.assertLessEqual(0, actual_upload_stats.pop("duration"))
+    named_caches_stats = actual["stats"]["named_caches"]
+    self.assertLessEqual(0, named_caches_stats["install"].pop("duration"))
+    self.assertLessEqual(0, named_caches_stats["uninstall"].pop("duration"))
+    self.assertLessEqual(0, actual["stats"]["cleanup"].pop("duration"))
+    for i in ("items_cold", "items_hot"):
       if actual_upload_stats[i]:
         actual_upload_stats[i] = large.unpack(
-            base64.b64decode(actual_upload_stats[i]))
+          base64.b64decode(actual_upload_stats[i])
+        )
     self.assertEqual(expected, actual)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
   test_env.main()
diff --git a/tests/subprocess42_test.py b/tests/subprocess42_test.py
index afd7a6f..7a5d5e2 100755
--- a/tests/subprocess42_test.py
+++ b/tests/subprocess42_test.py
@@ -28,47 +28,49 @@
 # here. Otherwise everything would test with unbuffered; which is fine but
 # that's not what we specifically want to test here.
 ENV = os.environ.copy()
-ENV.pop('PYTHONUNBUFFERED', None)
+ENV.pop("PYTHONUNBUFFERED", None)
 
-SCRIPT_OUT = ('import signal, sys, time;\n'
-              'l = [];\n'
-              'def handler(signum, _):\n'
-              '  l.append(signum);\n'
-              '  sys.stdout.write(\'got signal %%d\\n\' %% signum);\n'
-              '  sys.stdout.flush();\n'
-              'signal.signal(%s, handler);\n'
-              'sys.stdout.write(\'hi\\n\');\n'
-              'sys.stdout.flush();\n'
-              'while not l:\n'
-              '  try:\n'
-              '    time.sleep(0.01);\n'
-              '  except IOError:\n'
-              '    sys.stdout.write(\'ioerror\\n\');\n'
-              '    sys.stdout.flush();\n'
-              'sys.stdout.write(\'bye\\n\');\n'
-              'sys.stdout.flush();\n') % ('signal.SIGBREAK' if sys.platform ==
-                                          'win32' else 'signal.SIGTERM')
+SCRIPT_OUT = (
+  "import signal, sys, time;\n"
+  "l = [];\n"
+  "def handler(signum, _):\n"
+  "  l.append(signum);\n"
+  "  sys.stdout.write('got signal %%d\\n' %% signum);\n"
+  "  sys.stdout.flush();\n"
+  "signal.signal(%s, handler);\n"
+  "sys.stdout.write('hi\\n');\n"
+  "sys.stdout.flush();\n"
+  "while not l:\n"
+  "  try:\n"
+  "    time.sleep(0.01);\n"
+  "  except IOError:\n"
+  "    sys.stdout.write('ioerror\\n');\n"
+  "    sys.stdout.flush();\n"
+  "sys.stdout.write('bye\\n');\n"
+  "sys.stdout.flush();\n"
+) % ("signal.SIGBREAK" if sys.platform == "win32" else "signal.SIGTERM")
 
-SCRIPT_ERR = ('import signal, sys, time;\n'
-              'l = [];\n'
-              'def handler(signum, _):\n'
-              '  l.append(signum);\n'
-              '  sys.stderr.write(\'got signal %%d\\n\' %% signum);\n'
-              '  sys.stderr.flush();\n'
-              'signal.signal(%s, handler);\n'
-              'sys.stderr.write(\'hi\\n\');\n'
-              'sys.stderr.flush();\n'
-              'while not l:\n'
-              '  try:\n'
-              '    time.sleep(0.01);\n'
-              '  except IOError:\n'
-              '    sys.stderr.write(\'ioerror\\n\');\n'
-              '    sys.stderr.flush();\n'
-              'sys.stderr.write(\'bye\\n\');\n'
-              'sys.stderr.flush();\n') % ('signal.SIGBREAK' if sys.platform ==
-                                          'win32' else 'signal.SIGTERM')
+SCRIPT_ERR = (
+  "import signal, sys, time;\n"
+  "l = [];\n"
+  "def handler(signum, _):\n"
+  "  l.append(signum);\n"
+  "  sys.stderr.write('got signal %%d\\n' %% signum);\n"
+  "  sys.stderr.flush();\n"
+  "signal.signal(%s, handler);\n"
+  "sys.stderr.write('hi\\n');\n"
+  "sys.stderr.flush();\n"
+  "while not l:\n"
+  "  try:\n"
+  "    time.sleep(0.01);\n"
+  "  except IOError:\n"
+  "    sys.stderr.write('ioerror\\n');\n"
+  "    sys.stderr.flush();\n"
+  "sys.stderr.write('bye\\n');\n"
+  "sys.stderr.flush();\n"
+) % ("signal.SIGBREAK" if sys.platform == "win32" else "signal.SIGTERM")
 
-OUTPUT_SCRIPT = br"""
+OUTPUT_SCRIPT = rb"""
 import os
 import re
 import sys
@@ -120,11 +122,12 @@
   sys.exit(main())
 """
 
+
 def to_native_eol(string):
   if string is None:
     return string
-  if sys.platform == 'win32':
-    return string.replace(b'\n', b'\r\n')
+  if sys.platform == "win32":
+    return string.replace(b"\n", b"\r\n")
   return string
 
 
@@ -136,21 +139,24 @@
   unbuffered output in python.
   """
   command = [
-      'import sys,time',
-      'print(\'A\')',
+    "import sys,time",
+    "print('A')",
   ]
   if flush:
     # Sadly, this doesn't work otherwise in some combination.
-    command.append('sys.stdout.flush()')
-  command.extend((
-      'time.sleep(%s)' % sleep_duration,
-      'print(\'B\')',
-  ))
-  cmd = [sys.executable, '-c', ';'.join(command)]
+    command.append("sys.stdout.flush()")
+  command.extend(
+    (
+      "time.sleep(%s)" % sleep_duration,
+      "print('B')",
+    )
+  )
+  cmd = [sys.executable, "-c", ";".join(command)]
   if unbuffered:
-    cmd.append('-u')
+    cmd.append("-u")
   return subprocess42.Popen(
-      cmd, env=ENV, stdout=subprocess42.PIPE, universal_newlines=True)
+    cmd, env=ENV, stdout=subprocess42.PIPE, universal_newlines=True
+  )
 
 
 def get_output_sleep_proc_err(sleep_duration):
@@ -158,20 +164,22 @@
   and after a sleep.
   """
   command = [
-      'import sys,time',
-      'sys.stderr.write(\'A\\n\')',
+    "import sys,time",
+    "sys.stderr.write('A\\n')",
   ]
-  command.extend((
-      'time.sleep(%s)' % sleep_duration,
-      'sys.stderr.write(\'B\\n\')',
-  ))
-  cmd = [sys.executable, '-c', ';'.join(command)]
+  command.extend(
+    (
+      "time.sleep(%s)" % sleep_duration,
+      "sys.stderr.write('B\\n')",
+    )
+  )
+  cmd = [sys.executable, "-c", ";".join(command)]
   return subprocess42.Popen(
-      cmd, env=ENV, stderr=subprocess42.PIPE, universal_newlines=True)
+    cmd, env=ENV, stderr=subprocess42.PIPE, universal_newlines=True
+  )
 
 
 class Subprocess42Test(unittest.TestCase):
-
   def setUp(self):
     self._output_script = None
     super(Subprocess42Test, self).setUp()
@@ -187,73 +195,75 @@
   def output_script(self):
     if not self._output_script:
       handle, self._output_script = tempfile.mkstemp(
-          prefix='subprocess42', suffix='.py')
+        prefix="subprocess42", suffix=".py"
+      )
       os.write(handle, OUTPUT_SCRIPT)
       os.close(handle)
     return self._output_script
 
   def test_communicate_timeout(self):
-    timedout = 1 if sys.platform == 'win32' else -9
+    timedout = 1 if sys.platform == "win32" else -9
     # Format is:
     # ( (cmd, stderr_pipe, timeout), (stdout, stderr, returncode) ), ...
     # See OUTPUT script for the meaning of the commands.
     test_data = [
-        # 0 means no timeout, like None.
+      # 0 means no timeout, like None.
+      (
+        (["out_sleeping", "0.001", "out_slept", "err_print"], None, 0),
+        (b"Sleeping.\nSlept.\n", None, 0),
+      ),
+      (
+        (["err_print"], subprocess42.STDOUT, 0),
+        (b"printing", None, 0),
+      ),
+      (
+        (["err_print"], subprocess42.PIPE, 0),
+        (b"", b"printing", 0),
+      ),
+      # On a loaded system, this can be tight.
+      (
+        (["out_sleeping", "out_flush", "60", "out_slept"], None, 1),
+        (b"Sleeping.\n", None, timedout),
+      ),
+      (
         (
-            (['out_sleeping', '0.001', 'out_slept', 'err_print'], None, 0),
-            (b'Sleeping.\nSlept.\n', None, 0),
+          # Note that err_flush is necessary on Windows but not on the
+          # other OSes. This means the likelihood of missing stderr output
+          # from a killed child process on Windows is much higher than on
+          # other OSes.
+          [
+            "out_sleeping",
+            "out_flush",
+            "err_print",
+            "err_flush",
+            "60",
+            "out_slept",
+          ],
+          subprocess42.PIPE,
+          1,
         ),
-        (
-            (['err_print'], subprocess42.STDOUT, 0),
-            (b'printing', None, 0),
-        ),
-        (
-            (['err_print'], subprocess42.PIPE, 0),
-            (b'', b'printing', 0),
-        ),
-
-        # On a loaded system, this can be tight.
-        (
-            (['out_sleeping', 'out_flush', '60', 'out_slept'], None, 1),
-            (b'Sleeping.\n', None, timedout),
-        ),
-        (
-            (
-                # Note that err_flush is necessary on Windows but not on the
-                # other OSes. This means the likelihood of missing stderr output
-                # from a killed child process on Windows is much higher than on
-                # other OSes.
-                [
-                    'out_sleeping',
-                    'out_flush',
-                    'err_print',
-                    'err_flush',
-                    '60',
-                    'out_slept',
-                ],
-                subprocess42.PIPE,
-                1),
-            (b'Sleeping.\n', b'printing', timedout),
-        ),
-        (
-            (['out_sleeping', '0.001', 'out_slept'], None, 60),
-            (b'Sleeping.\nSlept.\n', None, 0),
-        ),
-        (
-            ([], None, 60),
-            (b'', None, 0),
-        ),
-        (
-            ([], subprocess42.PIPE, 60),
-            (b'', b'', 0),
-        ),
+        (b"Sleeping.\n", b"printing", timedout),
+      ),
+      (
+        (["out_sleeping", "0.001", "out_slept"], None, 60),
+        (b"Sleeping.\nSlept.\n", None, 0),
+      ),
+      (
+        ([], None, 60),
+        (b"", None, 0),
+      ),
+      (
+        ([], subprocess42.PIPE, 60),
+        (b"", b"", 0),
+      ),
     ]
     for i, ((args, errpipe, timeout), expected) in enumerate(test_data):
       proc = subprocess42.Popen(
-          [sys.executable, self.output_script] + args,
-          env=ENV,
-          stdout=subprocess42.PIPE,
-          stderr=errpipe)
+        [sys.executable, self.output_script] + args,
+        env=ENV,
+        stdout=subprocess42.PIPE,
+        stderr=errpipe,
+      )
       try:
         stdout, stderr = proc.communicate(timeout=timeout)
         code = proc.returncode
@@ -266,16 +276,24 @@
         duration = proc.duration()
       expected_duration = 0.0001 if not timeout or timeout == 60 else timeout
       self.assertTrue(duration >= expected_duration, (i, expected_duration))
-      self.assertEqual((i, stdout, stderr, code), (i, to_native_eol(
-          expected[0]), to_native_eol(expected[1]), expected[2]))
+      self.assertEqual(
+        (i, stdout, stderr, code),
+        (
+          i,
+          to_native_eol(expected[0]),
+          to_native_eol(expected[1]),
+          expected[2],
+        ),
+      )
 
       # Try again with universal_newlines=True.
       proc = subprocess42.Popen(
-          [sys.executable, self.output_script] + args,
-          env=ENV,
-          stdout=subprocess42.PIPE,
-          stderr=errpipe,
-          universal_newlines=True)
+        [sys.executable, self.output_script] + args,
+        env=ENV,
+        stdout=subprocess42.PIPE,
+        stderr=errpipe,
+        universal_newlines=True,
+      )
       try:
         stdout, stderr = proc.communicate(timeout=timeout)
         code = proc.returncode
@@ -286,7 +304,7 @@
         # is used.
         stdout = e.output
         stderr = e.stderr
-        if sys.platform != 'win32':
+        if sys.platform != "win32":
           stdout = stdout.decode() if stdout else None
           stderr = stderr.decode() if stderr else None
         self.assertTrue(proc.kill())
@@ -294,28 +312,35 @@
       finally:
         duration = proc.duration()
       self.assertTrue(duration >= expected_duration, (i, expected_duration))
-      self.assertEqual((i, None if stdout is None else stdout.encode(),
-                        None if stderr is None else stderr.encode(), code),
-                       (i,) + expected)
+      self.assertEqual(
+        (
+          i,
+          None if stdout is None else stdout.encode(),
+          None if stderr is None else stderr.encode(),
+          code,
+        ),
+        (i,) + expected,
+      )
 
   def test_communicate_input(self):
     cmd = [
-        sys.executable,
-        '-u',
-        '-c',
-        'import sys; sys.stdout.write(sys.stdin.read(5))',
+      sys.executable,
+      "-u",
+      "-c",
+      "import sys; sys.stdout.write(sys.stdin.read(5))",
     ]
     proc = subprocess42.Popen(
-        cmd, stdin=subprocess42.PIPE, stdout=subprocess42.PIPE)
-    out, err = proc.communicate(input=b'12345')
-    self.assertEqual(b'12345', out)
+      cmd, stdin=subprocess42.PIPE, stdout=subprocess42.PIPE
+    )
+    out, err = proc.communicate(input=b"12345")
+    self.assertEqual(b"12345", out)
     self.assertEqual(None, err)
 
   def test_communicate_input_timeout(self):
-    cmd = [sys.executable, '-u', '-c', 'import time; time.sleep(60)']
+    cmd = [sys.executable, "-u", "-c", "import time; time.sleep(60)"]
     proc = subprocess42.Popen(cmd, stdin=subprocess42.PIPE)
     try:
-      proc.communicate(input=b'12345', timeout=0.5)
+      proc.communicate(input=b"12345", timeout=0.5)
       self.fail()
     except subprocess42.TimeoutExpired as e:
       self.assertEqual(None, e.output)
@@ -326,10 +351,10 @@
 
   def test_communicate_input_stdout_timeout(self):
     cmd = [
-        sys.executable,
-        '-u',
-        '-c',
-        """
+      sys.executable,
+      "-u",
+      "-c",
+      """
 import sys, time
 sys.stdout.write(sys.stdin.read(5))
 sys.stdout.flush()
@@ -337,12 +362,13 @@
         """,
     ]
     proc = subprocess42.Popen(
-        cmd, stdin=subprocess42.PIPE, stdout=subprocess42.PIPE)
+      cmd, stdin=subprocess42.PIPE, stdout=subprocess42.PIPE
+    )
     try:
-      proc.communicate(input=b'12345', timeout=2)
+      proc.communicate(input=b"12345", timeout=2)
       self.fail()
     except subprocess42.TimeoutExpired as e:
-      self.assertEqual(b'12345', e.output)
+      self.assertEqual(b"12345", e.output)
       self.assertEqual(None, e.stderr)
       self.assertTrue(proc.kill())
       proc.wait()
@@ -350,7 +376,7 @@
 
   def test_communicate_timeout_no_pipe(self):
     # In this case, it's effectively a wait() call.
-    cmd = [sys.executable, '-u', '-c', 'import time; time.sleep(60)']
+    cmd = [sys.executable, "-u", "-c", "import time; time.sleep(60)"]
     proc = subprocess42.Popen(cmd)
     try:
       proc.communicate(timeout=0.5)
@@ -363,29 +389,32 @@
       self.assertLessEqual(0.5, proc.duration())
 
   def _test_lower_priority(self, lower_priority):
-    if sys.platform == 'win32':
+    if sys.platform == "win32":
       cmd = [
-          sys.executable, '-u', '-c',
-          'import ctypes,sys; v=ctypes.windll.kernel32.GetPriorityClass(-1);'
-          'sys.stdout.write(hex(v))'
+        sys.executable,
+        "-u",
+        "-c",
+        "import ctypes,sys; v=ctypes.windll.kernel32.GetPriorityClass(-1);"
+        "sys.stdout.write(hex(v))",
       ]
     else:
       cmd = [
-          sys.executable,
-          '-u',
-          '-c',
-          'import os,sys;sys.stdout.write(str(os.nice(0)))',
+        sys.executable,
+        "-u",
+        "-c",
+        "import os,sys;sys.stdout.write(str(os.nice(0)))",
       ]
     proc = subprocess42.Popen(
-        cmd, stdout=subprocess42.PIPE, lower_priority=lower_priority)
+      cmd, stdout=subprocess42.PIPE, lower_priority=lower_priority
+    )
     out, err = proc.communicate()
     self.assertEqual(None, err)
     return out
 
-  @unittest.skipIf(sys.platform == 'win32', 'crbug.com/1148174')
+  @unittest.skipIf(sys.platform == "win32", "crbug.com/1148174")
   def test_lower_priority(self):
     out = self._test_lower_priority(True)
-    if sys.platform == 'win32':
+    if sys.platform == "win32":
       # See
       # https://docs.microsoft.com/en-us/windows/desktop/api/processthreadsapi/nf-processthreadsapi-getpriorityclass
       BELOW_NORMAL_PRIORITY_CLASS = 0x4000
@@ -395,7 +424,7 @@
 
   def test_lower_priority_False(self):
     out = self._test_lower_priority(False)
-    if sys.platform == 'win32':
+    if sys.platform == "win32":
       # Should be NORMAL_PRIORITY_CLASS.
       p = ctypes.windll.kernel32.GetPriorityClass(-1)
       self.assertEqual(hex(p).encode(), out)
@@ -406,27 +435,29 @@
   def _cmd_print_good():
     # Used in test_containment_auto and test_containment_auto_limit_process.
     return [
-        sys.executable,
-        '-u',
-        '-c',
-        'import subprocess,sys; '
-        'subprocess.call([sys.executable, "-c", "print(\\"good\\")"])',
+      sys.executable,
+      "-u",
+      "-c",
+      "import subprocess,sys; "
+      'subprocess.call([sys.executable, "-c", "print(\\"good\\")"])',
     ]
 
   def test_containment_none(self):
     # Minimal test case. Starts two processes.
     cmd = self._cmd_print_good()
     containment = subprocess42.Containment(
-        containment_type=subprocess42.Containment.NONE)
+      containment_type=subprocess42.Containment.NONE
+    )
     self.assertEqual(0, subprocess42.check_call(cmd, containment=containment))
 
   def test_containment_auto(self):
     # Minimal test case. Starts two processes.
     cmd = self._cmd_print_good()
     containment = subprocess42.Containment(
-        containment_type=subprocess42.Containment.AUTO,
-        limit_processes=2,
-        limit_total_committed_memory=1024 * 1024 * 1024)
+      containment_type=subprocess42.Containment.AUTO,
+      limit_processes=2,
+      limit_total_committed_memory=1024 * 1024 * 1024,
+    )
     self.assertEqual(0, subprocess42.check_call(cmd, containment=containment))
 
   def test_containment_auto_limit_process(self):
@@ -434,22 +465,24 @@
     # quota.
     cmd = self._cmd_print_good()
     containment = subprocess42.Containment(
-        containment_type=subprocess42.Containment.JOB_OBJECT, limit_processes=1)
+      containment_type=subprocess42.Containment.JOB_OBJECT, limit_processes=1
+    )
     start = lambda: subprocess42.Popen(
-        cmd,
-        stdout=subprocess42.PIPE,
-        stderr=subprocess42.PIPE,
-        containment=containment)
+      cmd,
+      stdout=subprocess42.PIPE,
+      stderr=subprocess42.PIPE,
+      containment=containment,
+    )
 
-    if sys.platform == 'win32':
+    if sys.platform == "win32":
       p = start()
       out, err = p.communicate()
       self.assertEqual(1, p.returncode)
-      self.assertEqual(b'', out)
-      self.assertIn(b'WinError', err)
+      self.assertEqual(b"", out)
+      self.assertIn(b"WinError", err)
       # Value for ERROR_NOT_ENOUGH_QUOTA. See
       # https://docs.microsoft.com/windows/desktop/debug/system-error-codes--1700-3999-
-      self.assertIn(b'1816', err)
+      self.assertIn(b"1816", err)
     else:
       # JOB_OBJECT is not usable on non-Windows.
       with self.assertRaises(NotImplementedError):
@@ -458,31 +491,33 @@
   def test_containment_auto_kill(self):
     # Test process killing.
     cmd = [
-        sys.executable,
-        '-u',
-        '-c',
-        'import sys,time; print("hi");time.sleep(60)',
+      sys.executable,
+      "-u",
+      "-c",
+      'import sys,time; print("hi");time.sleep(60)',
     ]
     containment = subprocess42.Containment(
-        containment_type=subprocess42.Containment.AUTO,
-        limit_processes=1,
-        limit_total_committed_memory=1024 * 1024 * 1024)
+      containment_type=subprocess42.Containment.AUTO,
+      limit_processes=1,
+      limit_total_committed_memory=1024 * 1024 * 1024,
+    )
     p = subprocess42.Popen(
-        cmd, stdout=subprocess42.PIPE, containment=containment)
+      cmd, stdout=subprocess42.PIPE, containment=containment
+    )
     itr = p.yield_any_line()
-    self.assertEqual(('stdout', b'hi'), next(itr))
+    self.assertEqual(("stdout", b"hi"), next(itr))
     p.kill()
     p.wait()
-    if sys.platform != 'win32':
+    if sys.platform != "win32":
       # signal.SIGKILL is not defined on Windows. Validate our assumption here.
       self.assertEqual(9, signal.SIGKILL)
-    if sys.platform == 'win32':
+    if sys.platform == "win32":
       # p.returncode is unsigned in python3 on windows
       self.assertEqual(4294967287, p.returncode)
     else:
       self.assertEqual(-9, p.returncode)
 
-  @unittest.skipIf(sys.platform == 'win32', 'pgid test')
+  @unittest.skipIf(sys.platform == "win32", "pgid test")
   def test_kill_background(self):
     # Test process group killing.
 
@@ -494,11 +529,12 @@
 
     # Use fcntl instead of os.set_blocking because of python2
     import fcntl
+
     fcntl.fcntl(r, fcntl.F_SETFL, fcntl.fcntl(r, fcntl.F_GETFL) | os.O_NONBLOCK)
 
     p = subprocess42.Popen(
-        [sys.executable, self.output_script, 'out_leak'],
-        stdout=w, detached=True)
+      [sys.executable, self.output_script, "out_leak"], stdout=w, detached=True
+    )
     os.close(w)  # close so we don't think that a child is hanging onto it.
 
     self.assertEqual(p.wait(), 0)  # our immediate child has exited!
@@ -517,66 +553,68 @@
     now = time.time()
     while True:
       try:
-        self.assertEqual(os.read(r, 1), b'')  # i.e. EOF
+        self.assertEqual(os.read(r, 1), b"")  # i.e. EOF
         return
       except OSError as ex:
         if ex.errno != errno.EWOULDBLOCK:
           raise
         time.sleep(0.1)
         if time.time() - now > 5:
-          raise Exception('pipe not unblocked after 5s, bailing')
+          raise Exception("pipe not unblocked after 5s, bailing")
 
   @staticmethod
   def _cmd_large_memory():
     # Used in test_large_memory and test_containment_auto_limit_memory.
     return [
-        sys.executable,
-        '-u',
-        '-c',
-        'list(range(50*1024*1024)); print("hi")',
+      sys.executable,
+      "-u",
+      "-c",
+      'list(range(50*1024*1024)); print("hi")',
     ]
 
   def test_large_memory(self):
     # Just assert the process works normally.
     cmd = self._cmd_large_memory()
-    self.assertEqual(b'hi', subprocess42.check_output(cmd).strip())
+    self.assertEqual(b"hi", subprocess42.check_output(cmd).strip())
 
   def test_containment_auto_limit_memory(self):
     # Process allocates a lot of memory. It should fail due to quota.
     cmd = self._cmd_large_memory()
     containment = subprocess42.Containment(
-        containment_type=subprocess42.Containment.JOB_OBJECT,
-        # 20 MiB.
-        limit_total_committed_memory=20 * 1024 * 1024)
+      containment_type=subprocess42.Containment.JOB_OBJECT,
+      # 20 MiB.
+      limit_total_committed_memory=20 * 1024 * 1024,
+    )
     start = lambda: subprocess42.Popen(
-        cmd,
-        stdout=subprocess42.PIPE,
-        stderr=subprocess42.PIPE,
-        containment=containment)
+      cmd,
+      stdout=subprocess42.PIPE,
+      stderr=subprocess42.PIPE,
+      containment=containment,
+    )
 
-    if sys.platform == 'win32':
+    if sys.platform == "win32":
       p = start()
       out, err = p.communicate()
       self.assertEqual(1, p.returncode)
-      self.assertEqual(b'', out)
-      self.assertIn(b'MemoryError', err)
+      self.assertEqual(b"", out)
+      self.assertIn(b"MemoryError", err)
     else:
       # JOB_OBJECT is not usable on non-Windows.
       with self.assertRaises(NotImplementedError):
         start()
 
   def test_call(self):
-    cmd = [sys.executable, '-u', '-c', 'import sys; sys.exit(0)']
+    cmd = [sys.executable, "-u", "-c", "import sys; sys.exit(0)"]
     self.assertEqual(0, subprocess42.call(cmd))
 
-    cmd = [sys.executable, '-u', '-c', 'import sys; sys.exit(1)']
+    cmd = [sys.executable, "-u", "-c", "import sys; sys.exit(1)"]
     self.assertEqual(1, subprocess42.call(cmd))
 
   def test_check_call(self):
-    cmd = [sys.executable, '-u', '-c', 'import sys; sys.exit(0)']
+    cmd = [sys.executable, "-u", "-c", "import sys; sys.exit(0)"]
     self.assertEqual(0, subprocess42.check_call(cmd))
 
-    cmd = [sys.executable, '-u', '-c', 'import sys; sys.exit(1)']
+    cmd = [sys.executable, "-u", "-c", "import sys; sys.exit(1)"]
     try:
       self.assertEqual(1, subprocess42.check_call(cmd))
       self.fail()
@@ -584,127 +622,109 @@
       self.assertEqual(None, e.output)
 
   def test_check_output(self):
-    cmd = [sys.executable, '-u', '-c', 'print(\'.\')']
-    self.assertEqual('.\n',
-                     subprocess42.check_output(cmd, universal_newlines=True))
+    cmd = [sys.executable, "-u", "-c", "print('.')"]
+    self.assertEqual(
+      ".\n", subprocess42.check_output(cmd, universal_newlines=True)
+    )
 
-    cmd = [sys.executable, '-u', '-c', 'import sys; print(\'.\'); sys.exit(1)']
+    cmd = [sys.executable, "-u", "-c", "import sys; print('.'); sys.exit(1)"]
     try:
       subprocess42.check_output(cmd, universal_newlines=True)
       self.fail()
     except subprocess42.CalledProcessError as e:
-      self.assertEqual('.\n', e.output)
+      self.assertEqual(".\n", e.output)
 
   def test_recv_any(self):
     # Test all pipe direction and output scenarios.
     combinations = [
-        {
-            'cmd': ['out_print', 'err_print'],
-            'stdout': None,
-            'stderr': None,
-            'expected': {},
-            'universal_newlines': False,
-        },
-        {
-            'cmd': ['out_print', 'err_print'],
-            'stdout': None,
-            'stderr': subprocess42.STDOUT,
-            'universal_newlines': False,
-            'expected': {},
-        },
-        {
-            'cmd': ['out_print'],
-            'stdout': subprocess42.PIPE,
-            'stderr': subprocess42.PIPE,
-            'universal_newlines': False,
-            'expected': {
-                'stdout': b'printing'
-            },
-        },
-        {
-            'cmd': ['out_print'],
-            'stdout': subprocess42.PIPE,
-            'stderr': None,
-            'universal_newlines': False,
-            'expected': {
-                'stdout': b'printing'
-            },
-        },
-        {
-            'cmd': ['out_print'],
-            'stdout': subprocess42.PIPE,
-            'stderr': subprocess42.STDOUT,
-            'universal_newlines': False,
-            'expected': {
-                'stdout': b'printing'
-            },
-        },
-        {
-            'cmd': ['err_print'],
-            'stdout': subprocess42.PIPE,
-            'stderr': subprocess42.PIPE,
-            'universal_newlines': False,
-            'expected': {
-                'stderr': b'printing'
-            },
-        },
-        {
-            'cmd': ['err_print'],
-            'stdout': None,
-            'stderr': subprocess42.PIPE,
-            'universal_newlines': False,
-            'expected': {
-                'stderr': b'printing'
-            },
-        },
-        {
-            'cmd': ['err_print'],
-            'stdout': subprocess42.PIPE,
-            'stderr': subprocess42.STDOUT,
-            'universal_newlines': False,
-            'expected': {
-                'stdout': b'printing'
-            },
-        },
-        {
-            'cmd': ['out_print', 'err_print'],
-            'stdout': subprocess42.PIPE,
-            'stderr': subprocess42.PIPE,
-            'universal_newlines': False,
-            'expected': {
-                'stderr': b'printing',
-                'stdout': b'printing'
-            },
-        },
-        {
-            'cmd': ['out_print', 'err_print'],
-            'stdout': subprocess42.PIPE,
-            'stderr': subprocess42.STDOUT,
-            'universal_newlines': False,
-            'expected': {
-                'stdout': b'printingprinting'
-            },
-        },
-        {
-            'cmd': ['out_print', 'err_print'],
-            'stdout': subprocess42.PIPE,
-            'stderr': subprocess42.PIPE,
-            'universal_newlines': True,
-            'expected': {
-                'stderr': 'printing',
-                'stdout': 'printing'
-            },
-        },
+      {
+        "cmd": ["out_print", "err_print"],
+        "stdout": None,
+        "stderr": None,
+        "expected": {},
+        "universal_newlines": False,
+      },
+      {
+        "cmd": ["out_print", "err_print"],
+        "stdout": None,
+        "stderr": subprocess42.STDOUT,
+        "universal_newlines": False,
+        "expected": {},
+      },
+      {
+        "cmd": ["out_print"],
+        "stdout": subprocess42.PIPE,
+        "stderr": subprocess42.PIPE,
+        "universal_newlines": False,
+        "expected": {"stdout": b"printing"},
+      },
+      {
+        "cmd": ["out_print"],
+        "stdout": subprocess42.PIPE,
+        "stderr": None,
+        "universal_newlines": False,
+        "expected": {"stdout": b"printing"},
+      },
+      {
+        "cmd": ["out_print"],
+        "stdout": subprocess42.PIPE,
+        "stderr": subprocess42.STDOUT,
+        "universal_newlines": False,
+        "expected": {"stdout": b"printing"},
+      },
+      {
+        "cmd": ["err_print"],
+        "stdout": subprocess42.PIPE,
+        "stderr": subprocess42.PIPE,
+        "universal_newlines": False,
+        "expected": {"stderr": b"printing"},
+      },
+      {
+        "cmd": ["err_print"],
+        "stdout": None,
+        "stderr": subprocess42.PIPE,
+        "universal_newlines": False,
+        "expected": {"stderr": b"printing"},
+      },
+      {
+        "cmd": ["err_print"],
+        "stdout": subprocess42.PIPE,
+        "stderr": subprocess42.STDOUT,
+        "universal_newlines": False,
+        "expected": {"stdout": b"printing"},
+      },
+      {
+        "cmd": ["out_print", "err_print"],
+        "stdout": subprocess42.PIPE,
+        "stderr": subprocess42.PIPE,
+        "universal_newlines": False,
+        "expected": {"stderr": b"printing", "stdout": b"printing"},
+      },
+      {
+        "cmd": ["out_print", "err_print"],
+        "stdout": subprocess42.PIPE,
+        "stderr": subprocess42.STDOUT,
+        "universal_newlines": False,
+        "expected": {"stdout": b"printingprinting"},
+      },
+      {
+        "cmd": ["out_print", "err_print"],
+        "stdout": subprocess42.PIPE,
+        "stderr": subprocess42.PIPE,
+        "universal_newlines": True,
+        "expected": {"stderr": "printing", "stdout": "printing"},
+      },
     ]
     for i, testcase in enumerate(combinations):
-      default = '' if testcase['universal_newlines'] else b''
-      cmd = [sys.executable, self.output_script] + testcase['cmd']
+      default = "" if testcase["universal_newlines"] else b""
+      cmd = [sys.executable, self.output_script] + testcase["cmd"]
       p = subprocess42.Popen(
-          cmd,
-          env=ENV,
-          stdout=testcase['stdout'],
-          stderr=testcase['stderr'],
-          universal_newlines=testcase['universal_newlines'])
+        cmd,
+        env=ENV,
+        stdout=testcase["stdout"],
+        stderr=testcase["stderr"],
+        universal_newlines=testcase["universal_newlines"],
+      )
       actual = {}
       while p.poll() is None:
         pipe, data = p.recv_any()
@@ -719,25 +739,28 @@
           break
         actual.setdefault(pipe, default)
         actual[pipe] += data
-      self.assertEqual(testcase['expected'], actual,
-                       (i, testcase['cmd'], testcase['expected'], actual))
+      self.assertEqual(
+        testcase["expected"],
+        actual,
+        (i, testcase["cmd"], testcase["expected"], actual),
+      )
       self.assertEqual((None, None), p.recv_any())
       self.assertEqual(0, p.returncode)
 
   def test_recv_any_different_buffering(self):
     # Specifically test all buffering scenarios.
     for flush, unbuffered in itertools.product([True, False], [True, False]):
-      actual = ''
+      actual = ""
       proc = get_output_sleep_proc(flush, unbuffered, 0.5)
       while True:
         p, data = proc.recv_any()
         if not p:
           break
-        self.assertEqual('stdout', p)
+        self.assertEqual("stdout", p)
         self.assertTrue(data, (p, data))
         actual += data
 
-      self.assertEqual('A\nB\n', actual)
+      self.assertEqual("A\nB\n", actual)
       # Contrary to yield_any() or recv_any(0), wait() needs to be used here.
       proc.wait()
       self.assertEqual(0, proc.returncode)
@@ -753,14 +776,14 @@
     # least once, due to the sleep of 'duration' and the use of timeout=0.
     for duration in (0.05, 0.1, 0.5, 2):
       got_none = False
-      actual = ''
+      actual = ""
       try:
         proc = get_output_sleep_proc(flush, unbuffered, duration)
         try:
           while True:
             p, data = proc.recv_any(timeout=0)
             if p:
-              self.assertEqual('stdout', p)
+              self.assertEqual("stdout", p)
               self.assertTrue(data, (p, data))
               actual += data
               continue
@@ -769,7 +792,7 @@
               continue
             break
 
-          self.assertEqual('A\nB\n', actual)
+          self.assertEqual("A\nB\n", actual)
           self.assertEqual(0, proc.returncode)
           self.assertEqual(True, got_none)
           break
@@ -778,7 +801,7 @@
           proc.wait()
       except AssertionError:
         if duration != 2:
-          print('Sleeping rocks. Trying slower.')
+          print("Sleeping rocks. Trying slower.")
           continue
         raise
 
@@ -788,11 +811,11 @@
         proc = get_output_sleep_proc(True, True, duration)
         try:
           expected = [
-              'A\n',
-              'B\n',
+            "A\n",
+            "B\n",
           ]
           for p, data in proc.yield_any():
-            self.assertEqual('stdout', p)
+            self.assertEqual("stdout", p)
             self.assertEqual(expected.pop(0), data)
           self.assertEqual(0, proc.returncode)
           self.assertEqual([], expected)
@@ -802,7 +825,7 @@
           proc.wait()
       except AssertionError:
         if duration != 2:
-          print('Sleeping rocks. Trying slower.')
+          print("Sleeping rocks. Trying slower.")
           continue
         raise
 
@@ -814,15 +837,15 @@
         proc = get_output_sleep_proc(True, True, duration)
         try:
           expected = [
-              'A\n',
-              'B\n',
+            "A\n",
+            "B\n",
           ]
           got_none = False
           for p, data in proc.yield_any(timeout=0):
             if not p:
               got_none = True
               continue
-            self.assertEqual('stdout', p)
+            self.assertEqual("stdout", p)
             self.assertEqual(expected.pop(0), data)
           self.assertEqual(0, proc.returncode)
           self.assertEqual([], expected)
@@ -833,7 +856,7 @@
           proc.wait()
       except AssertionError:
         if duration != 2:
-          print('Sleeping rocks. Trying slower.')
+          print("Sleeping rocks. Trying slower.")
           continue
         raise
 
@@ -842,7 +865,7 @@
     # least once, due to the sleep of 'duration' and the use of timeout=0.
     for duration in (0.05, 0.1, 0.5, 2):
       got_none = False
-      expected = ['A\n', 'B\n']
+      expected = ["A\n", "B\n"]
       called = []
 
       def timeout():
@@ -857,7 +880,7 @@
             if not p:
               got_none = True
               continue
-            self.assertEqual('stdout', p)
+            self.assertEqual("stdout", p)
             self.assertEqual(expected.pop(0), data)
           self.assertEqual(0, proc.returncode)
           self.assertEqual([], expected)
@@ -869,17 +892,18 @@
           proc.wait()
       except AssertionError:
         if duration != 2:
-          print('Sleeping rocks. Trying slower.')
+          print("Sleeping rocks. Trying slower.")
           continue
         raise
 
   def test_yield_any_returncode(self):
     proc = subprocess42.Popen(
-        [sys.executable, '-c', 'import sys;sys.stdout.write("yo");sys.exit(1)'],
-        stdout=subprocess42.PIPE)
+      [sys.executable, "-c", 'import sys;sys.stdout.write("yo");sys.exit(1)'],
+      stdout=subprocess42.PIPE,
+    )
     for p, d in proc.yield_any():
-      self.assertEqual('stdout', p)
-      self.assertEqual(b'yo', d)
+      self.assertEqual("stdout", p)
+      self.assertEqual(b"yo", d)
     # There was a bug where the second call to wait() would overwrite
     # proc.returncode with 0 when timeout is not None.
     self.assertEqual(1, proc.wait())
@@ -891,17 +915,17 @@
     self.assertLessEqual(0, proc.duration())
 
   def _wait_for_hi(self, proc, err):
-    actual = b''
+    actual = b""
     while True:
       if err:
         data = proc.recv_err(timeout=5)
       else:
         data = proc.recv_out(timeout=5)
       if not data:
-        self.fail('%r' % actual)
+        self.fail("%r" % actual)
       self.assertTrue(data)
       actual += data
-      if actual in (b'hi\n', b'hi\r\n'):
+      if actual in (b"hi\n", b"hi\r\n"):
         break
 
   def _proc(self, err, **kwargs):
@@ -909,12 +933,12 @@
     # default. See reference above about PYTHONUNBUFFERED.
     # That's why the two scripts uses .flush(). Sadly, the flush() call is
     # needed on Windows even for sys.stderr (!)
-    cmd = [sys.executable, '-c', SCRIPT_ERR if err else SCRIPT_OUT]
+    cmd = [sys.executable, "-c", SCRIPT_ERR if err else SCRIPT_OUT]
     # TODO(maruel): Make universal_newlines=True work and not hang.
     if err:
-      kwargs['stderr'] = subprocess42.PIPE
+      kwargs["stderr"] = subprocess42.PIPE
     else:
-      kwargs['stdout'] = subprocess42.PIPE
+      kwargs["stdout"] = subprocess42.PIPE
     return subprocess42.Popen(cmd, **kwargs)
 
   def test_detached(self):
@@ -922,8 +946,8 @@
     self._test_detached(True)
 
   def _test_detached(self, err):
-    is_win = (sys.platform == 'win32')
-    key = 'stderr' if err else 'stdout'
+    is_win = sys.platform == "win32"
+    key = "stderr" if err else "stdout"
     proc = self._proc(err, detached=True)
     try:
       self._wait_for_hi(proc, err)
@@ -933,15 +957,18 @@
         # after handling SIGBREAK.
         self.assertEqual(0, proc.wait())
         # Windows...
-        self.assertIn(proc.recv_any(), (
-            (key, b'got signal 21\r\nioerror\r\nbye\r\n'),
-            (key, b'got signal 21\nioerror\nbye\n'),
-            (key, b'got signal 21\r\nbye\r\n'),
-            (key, b'got signal 21\nbye\n'),
-        ))
+        self.assertIn(
+          proc.recv_any(),
+          (
+            (key, b"got signal 21\r\nioerror\r\nbye\r\n"),
+            (key, b"got signal 21\nioerror\nbye\n"),
+            (key, b"got signal 21\r\nbye\r\n"),
+            (key, b"got signal 21\nbye\n"),
+          ),
+        )
       else:
         self.assertEqual(0, proc.wait())
-        self.assertEqual((key, b'got signal 15\nbye\n'), proc.recv_any())
+        self.assertEqual((key, b"got signal 15\nbye\n"), proc.recv_any())
     finally:
       # In case the test fails.
       proc.kill()
@@ -952,8 +979,8 @@
     self._test_attached(True)
 
   def _test_attached(self, err):
-    is_win = (sys.platform == 'win32')
-    key = 'stderr' if err else 'stdout'
+    is_win = sys.platform == "win32"
+    key = "stderr" if err else "stdout"
     proc = self._proc(err, detached=False)
     try:
       self._wait_for_hi(proc, err)
@@ -964,7 +991,7 @@
         self.assertEqual((None, None), proc.recv_any())
       else:
         self.assertEqual(0, proc.wait())
-        self.assertEqual((key, b'got signal 15\nbye\n'), proc.recv_any())
+        self.assertEqual((key, b"got signal 15\nbye\n"), proc.recv_any())
     finally:
       # In case the test fails.
       proc.kill()
@@ -972,36 +999,36 @@
 
   def test_split(self):
     data = [
-        ('stdout', b'o1\no2\no3\n'),
-        ('stderr', b'e1\ne2\ne3\n'),
-        ('stdout', b'\n\n'),
-        ('stdout', b'\n'),
-        ('stdout', b'o4\no5'),
-        ('stdout', b'_sameline\npart1 of one line '),
-        ('stderr', b'err inserted between two parts of stdout\n'),
-        ('stdout', b'part2 of one line\n'),
-        ('stdout', b'incomplete last stdout'),
-        ('stderr', b'incomplete last stderr'),
+      ("stdout", b"o1\no2\no3\n"),
+      ("stderr", b"e1\ne2\ne3\n"),
+      ("stdout", b"\n\n"),
+      ("stdout", b"\n"),
+      ("stdout", b"o4\no5"),
+      ("stdout", b"_sameline\npart1 of one line "),
+      ("stderr", b"err inserted between two parts of stdout\n"),
+      ("stdout", b"part2 of one line\n"),
+      ("stdout", b"incomplete last stdout"),
+      ("stderr", b"incomplete last stderr"),
     ]
     expected = [
-        ('stdout', b'o1'),
-        ('stdout', b'o2'),
-        ('stdout', b'o3'),
-        ('stderr', b'e1'),
-        ('stderr', b'e2'),
-        ('stderr', b'e3'),
-        ('stdout', b''),
-        ('stdout', b''),
-        ('stdout', b''),
-        ('stdout', b'o4'),
-        ('stdout', b'o5_sameline'),
-        ('stderr', b'err inserted between two parts of stdout'),
-        ('stdout', b'part1 of one line part2 of one line'),
-        ('stderr', b'incomplete last stderr'),
-        ('stdout', b'incomplete last stdout'),
+      ("stdout", b"o1"),
+      ("stdout", b"o2"),
+      ("stdout", b"o3"),
+      ("stderr", b"e1"),
+      ("stderr", b"e2"),
+      ("stderr", b"e3"),
+      ("stdout", b""),
+      ("stdout", b""),
+      ("stdout", b""),
+      ("stdout", b"o4"),
+      ("stdout", b"o5_sameline"),
+      ("stderr", b"err inserted between two parts of stdout"),
+      ("stdout", b"part1 of one line part2 of one line"),
+      ("stderr", b"incomplete last stderr"),
+      ("stdout", b"incomplete last stdout"),
     ]
-    if sys.platform == 'win32':
-      data = [(d[0], d[1].replace(b'\n', b'\r\n')) for d in data]
+    if sys.platform == "win32":
+      data = [(d[0], d[1].replace(b"\n", b"\r\n")) for d in data]
 
     # With universal_newlines=False
     self.assertEqual(list(subprocess42.split(data, False)), expected)
@@ -1014,9 +1041,10 @@
   @params((None,), (10,))
   def test_wait_can_be_interrupted(self, timeout):
     cmd = [
-        sys.executable,
-        '-c',
-        textwrap.dedent(r"""
+      sys.executable,
+      "-c",
+      textwrap.dedent(
+        r"""
             import signal
             import sys
             import textwrap
@@ -1046,11 +1074,14 @@
                 sys.stdout.write('wait is interrupted')
                 sys.stdout.flush()
                 proc.kill()
-        """ % timeout),
+        """
+        % timeout
+      ),
     ]
     # Set cwd to CLIENT_DIR so that the script can import subprocess42.
-    proc = subprocess42.Popen(cmd, stdout=subprocess42.PIPE,
-                              cwd=test_env.CLIENT_DIR, detached=True)
+    proc = subprocess42.Popen(
+      cmd, stdout=subprocess42.PIPE, cwd=test_env.CLIENT_DIR, detached=True
+    )
     self._wait_for_hi(proc, False)
     time.sleep(0.5)
     proc.terminate()
@@ -1060,11 +1091,11 @@
     # some buffer here.
     start = time.time()
     got = proc.recv_out(timeout=8)
-    want = b'wait is interrupted'
+    want = b"wait is interrupted"
     self.assertEqual(
-        got, want,
-        "%s != %s after %s seconds" % (got, want, time.time() - start))
+      got, want, "%s != %s after %s seconds" % (got, want, time.time() - start)
+    )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
   test_env.main()
diff --git a/tests/swarming_test.py b/tests/swarming_test.py
index c872381..b0c34ba 100755
--- a/tests/swarming_test.py
+++ b/tests/swarming_test.py
@@ -30,7 +30,7 @@
 
   It gets in the way when debugging test failures.
   """
-  dispatcher = swarming.subcommand.CommandDispatcher('swarming')
+  dispatcher = swarming.subcommand.CommandDispatcher("swarming")
   return dispatcher.execute(swarming.OptionParserSwarming(), args)
 
 
@@ -38,15 +38,15 @@
   # pylint: disable=no-member
 
   def setUp(self):
-    self.mock(auth, 'ensure_logged_in', lambda _: None)
-    self.mock(sys, 'stdout', StringIO.StringIO())
-    self.mock(sys, 'stderr', StringIO.StringIO())
-    self.mock(logging_utils, 'prepare_logging', lambda *args: None)
-    self.mock(logging_utils, 'set_console_level', lambda *args: None)
+    self.mock(auth, "ensure_logged_in", lambda _: None)
+    self.mock(sys, "stdout", StringIO.StringIO())
+    self.mock(sys, "stderr", StringIO.StringIO())
+    self.mock(logging_utils, "prepare_logging", lambda *args: None)
+    self.mock(logging_utils, "set_console_level", lambda *args: None)
 
   def tearDown(self):
     if not self.has_failed():
-      self._check_output('', '')
+      self._check_output("", "")
 
   maxDiff = None
 
@@ -55,8 +55,8 @@
     self.assertMultiLineEqual(err, sys.stderr.getvalue())
 
     # Flush their content by mocking them again.
-    self.mock(sys, 'stdout', StringIO.StringIO())
-    self.mock(sys, 'stderr', StringIO.StringIO())
+    self.mock(sys, "stdout", StringIO.StringIO())
+    self.mock(sys, "stderr", StringIO.StringIO())
 
   def main_safe(self, args):
     """Bypasses swarming.main()'s exception handling.
@@ -67,8 +67,11 @@
     try:
       return main(args)
     except:
-      data = '%s\nSTDOUT:\n%s\nSTDERR:\n%s' % (
-          traceback.format_exc(), sys.stdout.getvalue(), sys.stderr.getvalue())
+      data = "%s\nSTDOUT:\n%s\nSTDERR:\n%s" % (
+        traceback.format_exc(),
+        sys.stdout.getvalue(),
+        sys.stderr.getvalue(),
+      )
       self.fail(data)
 
 
@@ -86,67 +89,69 @@
 class TestMain(NetTestCase):
   # Tests calling main().
   def test_query_base(self):
-    self.expected_requests([
+    self.expected_requests(
+      [
         (
-            'https://localhost:1/_ah/api/swarming/v1/bot/botid/tasks?limit=200',
-            {},
-            {
-                'yo': 'dawg'
-            },
+          "https://localhost:1/_ah/api/swarming/v1/bot/botid/tasks?limit=200",
+          {},
+          {"yo": "dawg"},
         ),
-    ])
-    ret = self.main_safe([
-        'query',
-        '--swarming',
-        'https://localhost:1',
-        'bot/botid/tasks',
-    ])
-    self._check_output('{\n  "yo": "dawg"\n}\n', '')
+      ]
+    )
+    ret = self.main_safe(
+      [
+        "query",
+        "--swarming",
+        "https://localhost:1",
+        "bot/botid/tasks",
+      ]
+    )
+    self._check_output('{\n  "yo": "dawg"\n}\n', "")
     self.assertEqual(0, ret)
 
   def test_query_cursor(self):
-    self.expected_requests([
+    self.expected_requests(
+      [
         (
-            'https://localhost:1/_ah/api/swarming/v1/bot/botid/tasks?'
-            'foo=bar&limit=2',
-            {},
-            {
-                'cursor': '%',
-                'extra': False,
-                'items': ['A'],
-            },
+          "https://localhost:1/_ah/api/swarming/v1/bot/botid/tasks?"
+          "foo=bar&limit=2",
+          {},
+          {
+            "cursor": "%",
+            "extra": False,
+            "items": ["A"],
+          },
         ),
         (
-            'https://localhost:1/_ah/api/swarming/v1/bot/botid/tasks?'
-            'foo=bar&cursor=%25&limit=1',
-            {},
-            {
-                'cursor': None,
-                'items': ['B'],
-                'ignored': True,
-            },
+          "https://localhost:1/_ah/api/swarming/v1/bot/botid/tasks?"
+          "foo=bar&cursor=%25&limit=1",
+          {},
+          {
+            "cursor": None,
+            "items": ["B"],
+            "ignored": True,
+          },
         ),
-    ])
-    ret = self.main_safe([
-        'query',
-        '--swarming',
-        'https://localhost:1',
-        'bot/botid/tasks?foo=bar',
-        '--limit',
-        '2',
-    ])
-    expected = ('{\n'
-                '  "extra": false, \n'
-                '  "items": [\n'
-                '    "A", \n'
-                '    "B"\n'
-                '  ]\n'
-                '}\n')
-    self._check_output(expected, '')
+      ]
+    )
+    ret = self.main_safe(
+      [
+        "query",
+        "--swarming",
+        "https://localhost:1",
+        "bot/botid/tasks?foo=bar",
+        "--limit",
+        "2",
+      ]
+    )
+    expected = (
+      '{\n  "extra": false, \n  "items": [\n    "A", \n    "B"\n  ]\n}\n'
+    )
+    self._check_output(expected, "")
     self.assertEqual(0, ret)
 
 
-if __name__ == '__main__':
-  for env_var_to_remove in ('SWARMING_TASK_ID', 'SWARMING_SERVER'):
+if __name__ == "__main__":
+  for env_var_to_remove in ("SWARMING_TASK_ID", "SWARMING_SERVER"):
     os.environ.pop(env_var_to_remove, None)
   test_env.main()
diff --git a/tests/test_env.py b/tests/test_env.py
index f0c723a..d1d95ff 100644
--- a/tests/test_env.py
+++ b/tests/test_env.py
@@ -15,9 +15,9 @@
 sys.path.insert(0, CLIENT_DIR)
 
 # Fix import path.
-sys.path.insert(0, os.path.join(CLIENT_DIR, 'third_party', 'pyasn1'))
-sys.path.insert(0, os.path.join(CLIENT_DIR, 'third_party', 'rsa'))
-sys.path.insert(0, os.path.join(CLIENT_DIR, 'third_party'))
+sys.path.insert(0, os.path.join(CLIENT_DIR, "third_party", "pyasn1"))
+sys.path.insert(0, os.path.join(CLIENT_DIR, "third_party", "rsa"))
+sys.path.insert(0, os.path.join(CLIENT_DIR, "third_party"))
 
 # third_party/
 from depot_tools import fix_encoding
@@ -43,19 +43,19 @@
 
 def make_tree(out, contents):
   for relpath, content in sorted(contents.items()):
-    filepath = os.path.join(out, relpath.replace('/', os.path.sep))
+    filepath = os.path.join(out, relpath.replace("/", os.path.sep))
     dirpath = os.path.dirname(filepath)
     if not fs.isdir(dirpath):
       fs.makedirs(dirpath, 0o700)
     if isinstance(content, SymLink):
       fs.symlink(content, filepath)
     else:
-      mode = 0o700 if relpath.endswith('.py') else 0o600
+      mode = 0o700 if relpath.endswith(".py") else 0o600
       flags = os.O_WRONLY | os.O_CREAT
-      if sys.platform == 'win32':
+      if sys.platform == "win32":
         # pylint: disable=no-member
         flags |= os.O_BINARY
-      with os.fdopen(os.open(filepath, flags, mode), 'wb') as f:
+      with os.fdopen(os.open(filepath, flags, mode), "wb") as f:
         f.write(content)
 
 
@@ -69,9 +69,10 @@
 def main():
   """Improvement over unittest.main()."""
   logging.basicConfig(
-      level=logging.DEBUG if '-v' in sys.argv else logging.ERROR,
-      format='%(levelname)5s %(filename)15s(%(lineno)3d): %(message)s')
-  if '-v' in sys.argv:
+    level=logging.DEBUG if "-v" in sys.argv else logging.ERROR,
+    format="%(levelname)5s %(filename)15s(%(lineno)3d): %(message)s",
+  )
+  if "-v" in sys.argv:
     unittest.TestCase.maxDiff = None
   setup()
   unittest.main()
diff --git a/tests/threading_utils_test.py b/tests/threading_utils_test.py
index c223284..ed563bd 100755
--- a/tests/threading_utils_test.py
+++ b/tests/threading_utils_test.py
@@ -34,19 +34,20 @@
 
   Noop on windows (since win32 doesn't support signal.setitimer).
   """
-  if sys.platform == 'win32':
+  if sys.platform == "win32":
     return lambda method: method
 
   def decorator(method):
     @functools.wraps(method)
     def wrapper(self, *args, **kwargs):
-      signal.signal(signal.SIGALRM, lambda *_args: self.fail('Timeout'))
+      signal.signal(signal.SIGALRM, lambda *_args: self.fail("Timeout"))
       signal.setitimer(signal.ITIMER_REAL, max_running_time)
       try:
         return method(self, *args, **kwargs)
       finally:
         signal.signal(signal.SIGALRM, signal.SIG_DFL)
         signal.setitimer(signal.ITIMER_REAL, 0)
+
     return wrapper
 
   return decorator
@@ -62,15 +63,19 @@
   @staticmethod
   def sleep_task(duration=0.01):
     """Returns function that sleeps |duration| sec and returns its argument."""
+
     def task(arg):
       time.sleep(duration)
       return arg
+
     return task
 
   def retrying_sleep_task(self, duration=0.01):
     """Returns function that adds sleep_task to the thread pool."""
+
     def task(arg):
       self.thread_pool.add_task(0, self.sleep_task(duration), arg)
+
     return task
 
   @staticmethod
@@ -81,7 +86,8 @@
   def setUp(self):
     super(ThreadPoolTest, self).setUp()
     self.thread_pool = threading_utils.ThreadPool(
-        self.MIN_THREADS, self.MAX_THREADS, 0)
+      self.MIN_THREADS, self.MAX_THREADS, 0
+    )
 
   @timeout(10)
   def tearDown(self):
@@ -105,7 +111,7 @@
     """
     args = range(0, 100) if args is None else args
     expected = args if expected is None else expected
-    msg = 'Using \'%s\' to get results.' % (results_getter.__name__,)
+    msg = "Using '%s' to get results." % (results_getter.__name__,)
 
     for i in args:
       self.thread_pool.add_task(0, task, i)
@@ -121,8 +127,8 @@
 
   @timeout(10)
   def test_get_one_result_ok(self):
-    self.thread_pool.add_task(0, lambda: 'OK')
-    self.assertEqual(self.thread_pool.get_one_result(), 'OK')
+    self.thread_pool.add_task(0, lambda: "OK")
+    self.assertEqual(self.thread_pool.get_one_result(), "OK")
 
   @timeout(10)
   def test_get_one_result_fail(self):
@@ -132,39 +138,39 @@
 
   @timeout(30)
   def test_join(self):
-    self.run_results_test(self.sleep_task(),
-                          self.get_results_via_join)
+    self.run_results_test(self.sleep_task(), self.get_results_via_join)
 
   @timeout(30)
   def test_get_one_result(self):
-    self.run_results_test(self.sleep_task(),
-                          self.get_results_via_get_one_result)
+    self.run_results_test(
+      self.sleep_task(), self.get_results_via_get_one_result
+    )
 
   @timeout(30)
   def test_iter_results(self):
-    self.run_results_test(self.sleep_task(),
-                          self.get_results_via_iter_results)
+    self.run_results_test(self.sleep_task(), self.get_results_via_iter_results)
 
   @timeout(30)
   def test_retry_and_join(self):
-    self.run_results_test(self.retrying_sleep_task(),
-                          self.get_results_via_join)
+    self.run_results_test(self.retrying_sleep_task(), self.get_results_via_join)
 
   @timeout(30)
   def test_retry_and_get_one_result(self):
-    self.run_results_test(self.retrying_sleep_task(),
-                          self.get_results_via_get_one_result)
+    self.run_results_test(
+      self.retrying_sleep_task(), self.get_results_via_get_one_result
+    )
 
   @timeout(30)
   def test_retry_and_iter_results(self):
-    self.run_results_test(self.retrying_sleep_task(),
-                          self.get_results_via_iter_results)
+    self.run_results_test(
+      self.retrying_sleep_task(), self.get_results_via_iter_results
+    )
 
   @timeout(30)
   def test_none_task_and_join(self):
-    self.run_results_test(self.none_task(),
-                          self.get_results_via_join,
-                          expected=[])
+    self.run_results_test(
+      self.none_task(), self.get_results_via_join, expected=[]
+    )
 
   @timeout(30)
   def test_none_task_and_get_one_result(self):
@@ -174,9 +180,9 @@
 
   @timeout(30)
   def test_none_task_and_and_iter_results(self):
-    self.run_results_test(self.none_task(),
-                          self.get_results_via_iter_results,
-                          expected=[])
+    self.run_results_test(
+      self.none_task(), self.get_results_via_iter_results, expected=[]
+    )
 
   @timeout(30)
   def test_generator_task(self):
@@ -194,9 +200,11 @@
     expected = [i * MULTIPLIER + j for i in args for j in range(COUNT)]
 
     # Test all possible ways to pull results from the thread pool.
-    getters = (self.get_results_via_join,
-               self.get_results_via_iter_results,
-               self.get_results_via_get_one_result,)
+    getters = (
+      self.get_results_via_join,
+      self.get_results_via_iter_results,
+      self.get_results_via_get_one_result,
+    )
     for results_getter in getters:
       self.run_results_test(generator_task, results_getter, args, expected)
 
@@ -255,12 +263,12 @@
         return x
 
       with lock:
-        pool.add_task(0, wait_and_return, 'a')
-        pool.add_task(2, return_x, 'b')
-        pool.add_task(1, return_x, 'c')
+        pool.add_task(0, wait_and_return, "a")
+        pool.add_task(2, return_x, "b")
+        pool.add_task(1, return_x, "c")
 
       actual = pool.join()
-    self.assertEqual(['a', 'c', 'b'], actual)
+    self.assertEqual(["a", "c", "b"], actual)
 
   # Disabled due to https://crbug.com/778055
   @timeout(30)
@@ -340,51 +348,59 @@
         return x
 
       with lock:
-        pool.add_task(threading_utils.PRIORITY_HIGH, wait_and_return, 'a')
-        pool.add_task(threading_utils.PRIORITY_LOW, return_x, 'b')
-        pool.add_task(threading_utils.PRIORITY_MED, return_x, 'c')
+        pool.add_task(threading_utils.PRIORITY_HIGH, wait_and_return, "a")
+        pool.add_task(threading_utils.PRIORITY_LOW, return_x, "b")
+        pool.add_task(threading_utils.PRIORITY_MED, return_x, "c")
 
       actual = pool.join()
-    self.assertEqual(['a', 'c', 'b'], actual)
+    self.assertEqual(["a", "c", "b"], actual)
 
   def test_retry_inherited(self):
     # Exception class inheritance works.
     class CustomException(IOError):
       pass
+
     ran = []
+
     def throw(to_throw, x):
       ran.append(x)
       if to_throw:
         raise to_throw.pop(0)
       return x
+
     with threading_utils.AutoRetryThreadPool([IOError], 1, 1, 1, 0) as pool:
       pool.add_task(
-          threading_utils.PRIORITY_MED, throw, [CustomException('a')], 'yay')
+        threading_utils.PRIORITY_MED, throw, [CustomException("a")], "yay"
+      )
       actual = pool.join()
-    self.assertEqual(['yay'], actual)
-    self.assertEqual(['yay', 'yay'], ran)
+    self.assertEqual(["yay"], actual)
+    self.assertEqual(["yay", "yay"], ran)
 
   def test_retry_2_times(self):
     exceptions = [IOError, OSError]
-    to_throw = [OSError('a'), IOError('b')]
+    to_throw = [OSError("a"), IOError("b")]
+
     def throw(x):
       if to_throw:
         raise to_throw.pop(0)
       return x
+
     with threading_utils.AutoRetryThreadPool(exceptions, 2, 1, 1, 0) as pool:
-      pool.add_task(threading_utils.PRIORITY_MED, throw, 'yay')
+      pool.add_task(threading_utils.PRIORITY_MED, throw, "yay")
       actual = pool.join()
-    self.assertEqual(['yay'], actual)
+    self.assertEqual(["yay"], actual)
 
   def test_retry_too_many_times(self):
     exceptions = [IOError, OSError]
-    to_throw = [OSError('a'), IOError('b')]
+    to_throw = [OSError("a"), IOError("b")]
+
     def throw(x):
       if to_throw:
         raise to_throw.pop(0)
       return x
+
     with threading_utils.AutoRetryThreadPool(exceptions, 1, 1, 1, 0) as pool:
-      pool.add_task(threading_utils.PRIORITY_MED, throw, 'yay')
+      pool.add_task(threading_utils.PRIORITY_MED, throw, "yay")
       with self.assertRaises(IOError):
         pool.join()
 
@@ -394,13 +410,12 @@
       if to_throw:
         raise to_throw.pop(0)
       return x
+
     exceptions = [IOError, OSError]
     with threading_utils.AutoRetryThreadPool(exceptions, 1, 1, 1, 0) as pool:
       pool.add_task(
-          threading_utils.PRIORITY_MED,
-          throw,
-          [OSError('a'), IOError('b')],
-          'yay')
+        threading_utils.PRIORITY_MED, throw, [OSError("a"), IOError("b")], "yay"
+      )
       with self.assertRaises(IOError):
         pool.join()
 
@@ -410,15 +425,14 @@
       if to_throw:
         raise to_throw.pop(0)
       return x
+
     exceptions = [IOError, OSError]
     with threading_utils.AutoRetryThreadPool(exceptions, 2, 1, 1, 0) as pool:
       pool.add_task(
-          threading_utils.PRIORITY_MED,
-          throw,
-          [OSError('a'), IOError('b')],
-          'yay')
+        threading_utils.PRIORITY_MED, throw, [OSError("a"), IOError("b")], "yay"
+      )
       actual = pool.join()
-    self.assertEqual(['yay'], actual)
+    self.assertEqual(["yay"], actual)
 
   def test_retry_interleaved(self):
     # Verifies that retries are interleaved. This is important, we don't want a
@@ -427,28 +441,32 @@
     lock = threading.Lock()
     ran = []
     with threading_utils.AutoRetryThreadPool(exceptions, 2, 1, 1, 0) as pool:
+
       def lock_and_throw(to_throw, x):
         with lock:
           ran.append(x)
           if to_throw:
             raise to_throw.pop(0)
           return x
+
       with lock:
         pool.add_task(
-            threading_utils.PRIORITY_MED,
-            lock_and_throw,
-            [OSError('a'), IOError('b')],
-            'A')
+          threading_utils.PRIORITY_MED,
+          lock_and_throw,
+          [OSError("a"), IOError("b")],
+          "A",
+        )
         pool.add_task(
-            threading_utils.PRIORITY_MED,
-            lock_and_throw,
-            [OSError('a'), IOError('b')],
-            'B')
+          threading_utils.PRIORITY_MED,
+          lock_and_throw,
+          [OSError("a"), IOError("b")],
+          "B",
+        )
 
       actual = pool.join()
-    self.assertEqual(['A', 'B'], actual)
+    self.assertEqual(["A", "B"], actual)
     # Retries are properly interleaved:
-    self.assertEqual(['A', 'B', 'A', 'B', 'A', 'B'], ran)
+    self.assertEqual(["A", "B", "A", "B", "A", "B"], ran)
 
   def test_add_task_with_channel_success(self):
     with threading_utils.AutoRetryThreadPool([OSError], 2, 1, 1, 0) as pool:
@@ -459,8 +477,10 @@
   def test_add_task_with_channel_fatal_error(self):
     with threading_utils.AutoRetryThreadPool([OSError], 2, 1, 1, 0) as pool:
       channel = threading_utils.TaskChannel()
+
       def throw(exc):
         raise exc
+
       pool.add_task_with_channel(channel, 0, throw, ValueError())
       with self.assertRaises(ValueError):
         next(channel)
@@ -468,8 +488,10 @@
   def test_add_task_with_channel_retryable_error(self):
     with threading_utils.AutoRetryThreadPool([OSError], 2, 1, 1, 0) as pool:
       channel = threading_utils.TaskChannel()
+
       def throw(exc):
         raise exc
+
       pool.add_task_with_channel(channel, 0, throw, OSError())
       with self.assertRaises(OSError):
         next(channel)
@@ -477,17 +499,20 @@
   def test_add_task_with_channel_captures_stack_trace(self):
     with threading_utils.AutoRetryThreadPool([OSError], 2, 1, 1, 0) as pool:
       channel = threading_utils.TaskChannel()
+
       def throw(exc):
         def function_with_some_unusual_name():
           raise exc
+
         function_with_some_unusual_name()
+
       pool.add_task_with_channel(channel, 0, throw, OSError())
-      exc_traceback = ''
+      exc_traceback = ""
       try:
         next(channel)
       except OSError:
         exc_traceback = traceback.format_exc()
-      self.assertIn('function_with_some_unusual_name', exc_traceback)
+      self.assertIn("function_with_some_unusual_name", exc_traceback)
 
   def test_max_value(self):
     self.assertEqual(16, threading_utils.IOAutoRetryThreadPool.MAX_WORKERS)
@@ -512,8 +537,10 @@
   def test_exception(self):
     class FearsomeException(Exception):
       pass
+
     def mapper(value):
       raise FearsomeException(value)
+
     task_added = False
     try:
       progress = FakeProgress()
@@ -569,6 +596,7 @@
   def test_send_exception_raises_exception(self):
     class CustomError(Exception):
       pass
+
     with threading_utils.ThreadPool(1, 1, 0) as tp:
       channel = threading_utils.TaskChannel()
       exc_info = (CustomError, CustomError(), None)
@@ -579,10 +607,13 @@
   def test_wrap_task_raises_exception(self):
     class CustomError(Exception):
       pass
+
     with threading_utils.ThreadPool(1, 1, 0) as tp:
       channel = threading_utils.TaskChannel()
+
       def task_func():
         raise CustomError()
+
       tp.add_task(0, channel.wrap_task(task_func))
       with self.assertRaises(CustomError):
         next(channel)
@@ -590,29 +621,35 @@
   def test_wrap_task_exception_captures_stack_trace(self):
     class CustomError(Exception):
       pass
+
     with threading_utils.ThreadPool(1, 1, 0) as tp:
       channel = threading_utils.TaskChannel()
+
       def task_func():
         def function_with_some_unusual_name():
           raise CustomError()
+
         function_with_some_unusual_name()
+
       tp.add_task(0, channel.wrap_task(task_func))
-      exc_traceback = ''
+      exc_traceback = ""
       try:
         next(channel)
       except CustomError:
         exc_traceback = traceback.format_exc()
-      self.assertIn('function_with_some_unusual_name', exc_traceback)
+      self.assertIn("function_with_some_unusual_name", exc_traceback)
 
   def test_next_timeout(self):
     with threading_utils.ThreadPool(1, 1, 0) as tp:
       channel = threading_utils.TaskChannel()
+
       def task_func():
         # This test ultimately relies on the condition variable primitive
         # provided by pthreads. There's no easy way to mock time for it.
         # Increase this duration if the test is flaky.
         time.sleep(0.2)
         return 123
+
       tp.add_task(0, channel.wrap_task(task_func))
       with self.assertRaises(threading_utils.TaskChannel.Timeout):
         channel.next(timeout=0.001)
@@ -621,13 +658,15 @@
   def test_timeout_exception_from_task(self):
     with threading_utils.ThreadPool(1, 1, 0) as tp:
       channel = threading_utils.TaskChannel()
+
       def task_func():
         raise threading_utils.TaskChannel.Timeout()
+
       tp.add_task(0, channel.wrap_task(task_func))
       # 'Timeout' raised by task gets transformed into 'RuntimeError'.
       with self.assertRaises(RuntimeError):
         next(channel)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
   test_env.main()
diff --git a/tests/tools_test.py b/tests/tools_test.py
index 12d602a..1551545 100755
--- a/tests/tools_test.py
+++ b/tests/tools_test.py
@@ -36,20 +36,20 @@
   def setUp(self):
     super(FindExecutableTest, self).setUp()
     self.PATH = []
-    self.playground = os.path.realpath(tempfile.mkdtemp('tools_test-'))
+    self.playground = os.path.realpath(tempfile.mkdtemp("tools_test-"))
 
     self._orig_cwd = os.getcwd()
     os.chdir(self.playground)
 
-    if 'WIN' in self.id():
+    if "WIN" in self.id():
       self.mock(sys, "platform", "win32")
     else:
       self.mock(sys, "platform", "linux")
 
     # initial
-    self._touch_exe('SYSTEM', 'python')
-    self._touch_exe('SYSTEM', 'python.exe')
-    self._add_PATH_abs('SYSTEM')
+    self._touch_exe("SYSTEM", "python")
+    self._touch_exe("SYSTEM", "python.exe")
+    self._add_PATH_abs("SYSTEM")
 
   def tearDown(self):
     super(FindExecutableTest, self).tearDown()
@@ -71,8 +71,8 @@
     if not os.path.isdir(d):
       os.makedirs(d)
 
-    with open(full, 'w') as f:
-      f.write('hi')
+    with open(full, "w") as f:
+      f.write("hi")
 
     return full
 
@@ -83,53 +83,54 @@
     return full
 
   def _fe(self, cmd):
-    return tools.find_executable(cmd, env={'PATH': os.pathsep.join(self.PATH)})
+    return tools.find_executable(cmd, env={"PATH": os.pathsep.join(self.PATH)})
 
   def test_missing_passthrough(self):
-    cmd = ['not_a_real_path']
+    cmd = ["not_a_real_path"]
     self.assertEqual(cmd, self._fe(cmd))
 
   def test_missing_abs_passthrough(self):
-    cmd = [self._abs('not', 'real')]
+    cmd = [self._abs("not", "real")]
     self.assertEqual(cmd, self._fe(cmd))
 
-  @unittest.skipIf(sys.platform == 'win32', 'posix only')
+  @unittest.skipIf(sys.platform == "win32", "posix only")
   def test_bad_permissions(self):
-    cmd = ['config_file']
-    os.chmod(self._touch('something', 'dir', 'config_file'), 0)
-    os.chmod(self._abs('something', 'dir'), 0)
-    self._add_PATH_abs('something', 'dir')
+    cmd = ["config_file"]
+    os.chmod(self._touch("something", "dir", "config_file"), 0)
+    os.chmod(self._abs("something", "dir"), 0)
+    self._add_PATH_abs("something", "dir")
     self.assertEqual(cmd, self._fe(cmd))
 
   def test_WIN_implicit_extension(self):
-    self.assertEqual([self._touch_exe('SYSTEM', 'hello.bat')],
-                     self._fe(['hello']))
+    self.assertEqual(
+      [self._touch_exe("SYSTEM", "hello.bat")], self._fe(["hello"])
+    )
 
   def test_implicit_cwd(self):
-    self.assertEqual([self._touch_exe('python')], self._fe(['python']))
+    self.assertEqual([self._touch_exe("python")], self._fe(["python"]))
 
   def test_WIN_implicit_cwd(self):
-    self.assertEqual([self._touch_exe('python.bat')], self._fe(['python']))
+    self.assertEqual([self._touch_exe("python.bat")], self._fe(["python"]))
 
   def test_relative_PATH_entry(self):
-    self.PATH.insert(0, 'LOCAL')
-    self.assertEqual([self._touch_exe('LOCAL', 'thingy')], self._fe(['thingy']))
+    self.PATH.insert(0, "LOCAL")
+    self.assertEqual([self._touch_exe("LOCAL", "thingy")], self._fe(["thingy"]))
 
   def test_skip_empty(self):
-    self.PATH.insert(0, '')
-    self.assertEqual([self._abs('SYSTEM', 'python')], self._fe(['python']))
+    self.PATH.insert(0, "")
+    self.assertEqual([self._abs("SYSTEM", "python")], self._fe(["python"]))
 
   def test_explicit_relative(self):
-    self.assertEqual([self._touch_exe('python')], self._fe(['./python']))
+    self.assertEqual([self._touch_exe("python")], self._fe(["./python"]))
 
   def test_WIN_explicit_relative(self):
-    self.assertEqual([self._touch_exe('python.exe')], self._fe(['./python']))
+    self.assertEqual([self._touch_exe("python.exe")], self._fe(["./python"]))
 
   def test_explicit_relative_missing(self):
     # slash gets flipped on windows because this is not resolved to an absolute
     # path.
-    self.assertEqual([os.path.join('.', 'not_real')], self._fe(['./not_real']))
+    self.assertEqual([os.path.join(".", "not_real")], self._fe(["./not_real"]))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
   test_env.main()
diff --git a/tests/trace_inputs/child1.py b/tests/trace_inputs/child1.py
index 3bd7190..96ff355 100755
--- a/tests/trace_inputs/child1.py
+++ b/tests/trace_inputs/child1.py
@@ -12,15 +12,17 @@
   """When the gyp argument is not specified, the command is started from
   --root-dir directory.
   """
-  print('child from %s' % os.getcwd())
+  print("child from %s" % os.getcwd())
   # Force file opening with a non-normalized path.
-  open(os.path.join('tests', '..', 'trace_inputs.py'), 'rb').close()
-  open(os.path.join(
-      'tests', '..', 'tests', 'trace_inputs_smoke_test.py'), 'rb').close()
+  open(os.path.join("tests", "..", "trace_inputs.py"), "rb").close()
+  open(
+    os.path.join("tests", "..", "tests", "trace_inputs_smoke_test.py"), "rb"
+  ).close()
   # Do not wait for the child to exit.
   # Use relative directory.
   subprocess.Popen(
-      ['python', 'child2.py'], cwd=os.path.join('tests', 'trace_inputs'))
+    ["python", "child2.py"], cwd=os.path.join("tests", "trace_inputs")
+  )
   return 0
 
 
@@ -28,23 +30,23 @@
   """When the gyp argument is specified, the command is started from --cwd
   directory.
   """
-  print('child_gyp from %s' % os.getcwd())
+  print("child_gyp from %s" % os.getcwd())
   # Force file opening.
-  open(os.path.join('..', 'trace_inputs.py'), 'rb').close()
-  open(os.path.join('..', 'tests', 'trace_inputs_smoke_test.py'), 'rb').close()
+  open(os.path.join("..", "trace_inputs.py"), "rb").close()
+  open(os.path.join("..", "tests", "trace_inputs_smoke_test.py"), "rb").close()
   # Do not wait for the child to exit.
   # Use relative directory.
-  subprocess.Popen(['python', 'child2.py'], cwd='trace_inputs')
+  subprocess.Popen(["python", "child2.py"], cwd="trace_inputs")
   return 0
 
 
 def main():
-  if sys.argv[1] == '--child':
+  if sys.argv[1] == "--child":
     return child()
-  if sys.argv[1] == '--child-gyp':
+  if sys.argv[1] == "--child-gyp":
     return child_gyp()
   return 1
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
   sys.exit(main())
diff --git a/tests/trace_inputs/child2.py b/tests/trace_inputs/child2.py
index 5e360ca..a70b61c 100755
--- a/tests/trace_inputs/child2.py
+++ b/tests/trace_inputs/child2.py
@@ -9,37 +9,40 @@
 
 
 def main():
-  print('child2')
+  print("child2")
   # Introduce a race condition with the parent so the parent may have a chance
   # to exit before the child. Will be random.
-  time.sleep(.01)
+  time.sleep(0.01)
 
-  if sys.platform in ('darwin', 'win32'):
+  if sys.platform in ("darwin", "win32"):
     # Check for case-insensitive file system. This happens on Windows and OSX.
     # The log should still list test_file.txt.
-    open('Test_File.txt', 'rb').close()
+    open("Test_File.txt", "rb").close()
   else:
-    open('test_file.txt', 'rb').close()
+    open("test_file.txt", "rb").close()
 
   expected = {
-    'bar': 'Foo\n',
-    'foo': 'Bar\n',
+    "bar": "Foo\n",
+    "foo": "Bar\n",
   }
 
-  root = 'files1'
+  root = "files1"
   actual = dict(
-      (filename, open(os.path.join(root, filename), 'rb').read())
-      for filename in (os.listdir(root))
-      if (filename != 'do_not_care.txt' and
-          os.path.isfile(os.path.join(root, filename))))
+    (filename, open(os.path.join(root, filename), "rb").read())
+    for filename in (os.listdir(root))
+    if (
+      filename != "do_not_care.txt"
+      and os.path.isfile(os.path.join(root, filename))
+    )
+  )
 
   if actual != expected:
-    print('Failure')
+    print("Failure")
     print(actual)
     print(expected)
     return 1
   return 0
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
   sys.exit(main())
diff --git a/tests/trace_inputs/touch_only.py b/tests/trace_inputs/touch_only.py
index 1a3cde0..1323a4a 100755
--- a/tests/trace_inputs/touch_only.py
+++ b/tests/trace_inputs/touch_only.py
@@ -9,23 +9,24 @@
 import sys
 
 
-BASE_DIR = os.path.dirname(os.path.abspath(
-    __file__.decode(sys.getfilesystemencoding())))
+BASE_DIR = os.path.dirname(
+  os.path.abspath(__file__.decode(sys.getfilesystemencoding()))
+)
 
 
 def main():
-  print('Only look if a file exists but do not open it.')
+  print("Only look if a file exists but do not open it.")
   assert len(sys.argv) == 2
-  path = os.path.join(BASE_DIR, 'test_file.txt')
+  path = os.path.join(BASE_DIR, "test_file.txt")
   command = sys.argv[1]
-  if command == 'access':
+  if command == "access":
     return not os.access(path, os.R_OK)
-  if command == 'isfile':
+  if command == "isfile":
     return not os.path.isfile(path)
-  if command == 'stat':
+  if command == "stat":
     return not os.stat(path).st_size
   return 1
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
   sys.exit(main())
diff --git a/tests/url_open_timeout_test.py b/tests/url_open_timeout_test.py
index f48a13b..3add41d 100755
--- a/tests/url_open_timeout_test.py
+++ b/tests/url_open_timeout_test.py
@@ -31,7 +31,7 @@
   daemon_threads = True
 
   def __init__(self):
-    BaseHTTPServer.HTTPServer.__init__(self, ('127.0.0.1', 0), SleepingHandler)
+    BaseHTTPServer.HTTPServer.__init__(self, ("127.0.0.1", 0), SleepingHandler)
     self.dying = False
     self.dying_cv = threading.Condition()
     self.serving_thread = None
@@ -41,8 +41,9 @@
     pass
 
   def start(self):
-    self.serving_thread = threading.Thread(target=self.serve_forever,
-                                           kwargs={'poll_interval': 0.05})
+    self.serving_thread = threading.Thread(
+      target=self.serve_forever, kwargs={"poll_interval": 0.05}
+    )
     self.serving_thread.start()
 
   def stop(self):
@@ -53,7 +54,7 @@
 
   @property
   def url(self):
-    return 'http://%s:%d' % self.socket.getsockname()
+    return "http://%s:%d" % self.socket.getsockname()
 
   def sleep(self, timeout):
     deadline = time.time() + timeout
@@ -63,24 +64,24 @@
 
 
 class SleepingHandler(BaseHTTPServer.BaseHTTPRequestHandler):
-  protocol_version = 'HTTP/1.1'
+  protocol_version = "HTTP/1.1"
 
-  path_re = re.compile(r'/(.*)/([\.\d]*)(\?.*)?')
+  path_re = re.compile(r"/(.*)/([\.\d]*)(\?.*)?")
 
-  first_line = 'FIRST LINE\n'
-  second_line = 'SECOND LINE\n'
+  first_line = "FIRST LINE\n"
+  second_line = "SECOND LINE\n"
   full_response = first_line + second_line
 
   modes = {
-    'sleep_before_response': ['SLEEP', 'HEADERS', 'FIRST', 'SECOND'],
-    'sleep_after_headers': ['HEADERS', 'SLEEP', 'FIRST', 'SECOND'],
-    'sleep_during_response': ['HEADERS', 'FIRST', 'SLEEP', 'SECOND'],
-    'sleep_after_response': ['HEADERS', 'FIRST', 'SECOND', 'SLEEP'],
+    "sleep_before_response": ["SLEEP", "HEADERS", "FIRST", "SECOND"],
+    "sleep_after_headers": ["HEADERS", "SLEEP", "FIRST", "SECOND"],
+    "sleep_during_response": ["HEADERS", "FIRST", "SLEEP", "SECOND"],
+    "sleep_after_response": ["HEADERS", "FIRST", "SECOND", "SLEEP"],
   }
 
   def send_headers(self):
     self.send_response(200)
-    self.send_header('Content-Length', len(self.full_response))
+    self.send_header("Content-Length", len(self.full_response))
     self.end_headers()
 
   def log_message(self, _format, *_args):
@@ -106,10 +107,10 @@
       return
     # Mapping mode's action -> function to call.
     actions = {
-      'SLEEP': lambda: self.server.sleep(timeout),
-      'HEADERS': self.send_headers,
-      'FIRST': lambda: self.wfile.write(self.first_line),
-      'SECOND': lambda: self.wfile.write(self.second_line),
+      "SLEEP": lambda: self.server.sleep(timeout),
+      "HEADERS": self.send_headers,
+      "FIRST": lambda: self.wfile.write(self.first_line),
+      "SECOND": lambda: self.wfile.write(self.second_line),
     }
     # Execute all actions defined by the mode.
     for action in self.modes[mode]:
@@ -119,7 +120,7 @@
 class UrlOpenTimeoutTest(auto_stub.TestCase):
   def setUp(self):
     super(UrlOpenTimeoutTest, self).setUp()
-    self.mock(authenticators, 'OAuthAuthenticator', lambda *_: None)
+    self.mock(authenticators, "OAuthAuthenticator", lambda *_: None)
     self.server = SleepingServer()
     self.server.start()
 
@@ -130,45 +131,50 @@
     super(UrlOpenTimeoutTest, self).tearDown()
 
   def call(self, mode, sleep_duration, **kwargs):
-    url = self.server.url + '/%s/%f' % (mode, sleep_duration)
-    kwargs['max_attempts'] = 2
+    url = self.server.url + "/%s/%f" % (mode, sleep_duration)
+    kwargs["max_attempts"] = 2
     return net.url_open(url, **kwargs)
 
   def test_urlopen_success(self):
     # Server doesn't block.
     for mode in SleepingHandler.modes:
-      self.assertEqual(self.call(mode, 0, read_timeout=0.1).read(),
-                       SleepingHandler.full_response)
+      self.assertEqual(
+        self.call(mode, 0, read_timeout=0.1).read(),
+        SleepingHandler.full_response,
+      )
     # Server does block, but url_open called without read timeout.
     for mode in SleepingHandler.modes:
-      self.assertEqual(self.call(mode, 0.25, read_timeout=None).read(),
-                       SleepingHandler.full_response)
+      self.assertEqual(
+        self.call(mode, 0.25, read_timeout=None).read(),
+        SleepingHandler.full_response,
+      )
 
   def test_urlopen_retry(self):
     # This should trigger retry logic and eventually return None.
-    self.mock(net, 'sleep_before_retry', lambda *_: None)
-    stream = self.call('sleep_before_response', 0.25, read_timeout=0.1)
+    self.mock(net, "sleep_before_retry", lambda *_: None)
+    stream = self.call("sleep_before_response", 0.25, read_timeout=0.1)
     self.assertIsNone(stream)
 
   def test_urlopen_keeping_connection(self):
     # Sleeping after request is sent -> it's just connection keep alive.
-    stream = self.call('sleep_after_response', 0.25, read_timeout=0.1)
+    stream = self.call("sleep_after_response", 0.25, read_timeout=0.1)
     self.assertEqual(stream.read(), SleepingHandler.full_response)
 
   def test_urlopen_timeout_early_stream(self):
     # Timeouts while reading from the stream.
-    stream = self.call('sleep_after_headers', 0.25, read_timeout=0.1)
+    stream = self.call("sleep_after_headers", 0.25, read_timeout=0.1)
     self.assertTrue(stream)
     gen = stream.iter_content(len(SleepingHandler.first_line))
     with self.assertRaises(net.TimeoutError):
       next(gen)
 
-  @unittest.skipIf(platform.system() == 'Darwin',
-                   'TODO(crbug.com/1017545):'
-                   'AssertionError: TimeoutError not raised')
+  @unittest.skipIf(
+    platform.system() == "Darwin",
+    "TODO(crbug.com/1017545):AssertionError: TimeoutError not raised",
+  )
   def test_urlopen_timeout_mid_stream(self):
     # Timeouts while reading from the stream.
-    stream = self.call('sleep_during_response', 0.25, read_timeout=0.1)
+    stream = self.call("sleep_during_response", 0.25, read_timeout=0.1)
     self.assertTrue(stream)
     gen = stream.iter_content(len(SleepingHandler.first_line))
     next(gen)
@@ -176,5 +182,5 @@
       next(gen)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
   test_env.main()
diff --git a/tests/zip_package_test.py b/tests/zip_package_test.py
index 247c351..48db969 100755
--- a/tests/zip_package_test.py
+++ b/tests/zip_package_test.py
@@ -20,13 +20,14 @@
 
 def check_output(*args, **kwargs):
   return subprocess.check_output(
-      *args, stderr=subprocess.STDOUT, **kwargs).decode('utf-8')
+    *args, stderr=subprocess.STDOUT, **kwargs
+  ).decode("utf-8")
 
 
 class ZipPackageTest(unittest.TestCase):
   def setUp(self):
     super(ZipPackageTest, self).setUp()
-    self.temp_dir = tempfile.mkdtemp(prefix='zip_package_test')
+    self.temp_dir = tempfile.mkdtemp(prefix="zip_package_test")
 
   def tearDown(self):
     try:
@@ -37,19 +38,19 @@
   def stage_files(self, files):
     """Populates temp directory with given files specified as a list or dict."""
     if not isinstance(files, dict):
-      files = dict((p, b'') for p in files)
+      files = dict((p, b"") for p in files)
     for path, content in files.items():
-      abs_path = os.path.join(self.temp_dir, path.replace('/', os.sep))
+      abs_path = os.path.join(self.temp_dir, path.replace("/", os.sep))
       dir_path = os.path.dirname(abs_path)
       if not os.path.exists(dir_path):
         os.makedirs(dir_path)
-      with open(abs_path, 'wb') as f:
+      with open(abs_path, "wb") as f:
         f.write(content)
 
   @staticmethod
   def read_zip(stream):
     """Given some stream with zip data, reads and decompresses it into dict."""
-    zip_file = zipfile.ZipFile(stream, 'r')
+    zip_file = zipfile.ZipFile(stream, "r")
     try:
       return dict((i.filename, zip_file.read(i)) for i in zip_file.infolist())
     finally:
@@ -60,21 +61,23 @@
     zip_package.ZipPackage(self.temp_dir)
     # Relative path is not ok.
     with self.assertRaises(AssertionError):
-      zip_package.ZipPackage('.')
+      zip_package.ZipPackage(".")
 
   def test_require_absolute_file_paths(self):
     # Add some files to temp_dir.
-    self.stage_files([
-      'a.txt',
-      'b.py',
-      'c/c.txt',
-    ])
+    self.stage_files(
+      [
+        "a.txt",
+        "b.py",
+        "c/c.txt",
+      ]
+    )
 
     # Item to add -> method used to add it.
     cases = [
-      ('a.txt', zip_package.ZipPackage.add_file),
-      ('b.py', zip_package.ZipPackage.add_python_file),
-      ('c', zip_package.ZipPackage.add_directory),
+      ("a.txt", zip_package.ZipPackage.add_file),
+      ("b.py", zip_package.ZipPackage.add_python_file),
+      ("c", zip_package.ZipPackage.add_directory),
     ]
 
     for path, method in cases:
@@ -87,85 +90,89 @@
 
   def test_added_files_are_under_root(self):
     # Add some files to temp_dir.
-    self.stage_files([
-      'a.txt',
-      'p.py',
-      'pkg/1.txt',
-      'some_dir/2.txt',
-    ])
+    self.stage_files(
+      [
+        "a.txt",
+        "p.py",
+        "pkg/1.txt",
+        "some_dir/2.txt",
+      ]
+    )
 
     # Adding using |archive_path| should work.
-    pkg = zip_package.ZipPackage(os.path.join(self.temp_dir, 'pkg'))
-    pkg.add_file(os.path.join(self.temp_dir, 'a.txt'), '_a.txt')
-    pkg.add_python_file(os.path.join(self.temp_dir, 'p.py'), '_p.py')
-    pkg.add_directory(os.path.join(self.temp_dir, 'pkg'), '_pkg')
+    pkg = zip_package.ZipPackage(os.path.join(self.temp_dir, "pkg"))
+    pkg.add_file(os.path.join(self.temp_dir, "a.txt"), "_a.txt")
+    pkg.add_python_file(os.path.join(self.temp_dir, "p.py"), "_p.py")
+    pkg.add_directory(os.path.join(self.temp_dir, "pkg"), "_pkg")
 
     # Adding without |archive_path| should fail.
     with self.assertRaises(zip_package.ZipPackageError):
-      pkg.add_file(os.path.join(self.temp_dir, 'a.txt'))
+      pkg.add_file(os.path.join(self.temp_dir, "a.txt"))
     with self.assertRaises(zip_package.ZipPackageError):
-      pkg.add_python_file(os.path.join(self.temp_dir, 'p.py'))
+      pkg.add_python_file(os.path.join(self.temp_dir, "p.py"))
     with self.assertRaises(zip_package.ZipPackageError):
-      pkg.add_directory(os.path.join(self.temp_dir, 'a.txt'))
+      pkg.add_directory(os.path.join(self.temp_dir, "a.txt"))
 
   def test_adding_missing_files(self):
     pkg = zip_package.ZipPackage(self.temp_dir)
     with self.assertRaises(zip_package.ZipPackageError):
-      pkg.add_file(os.path.join(self.temp_dir, 'im_not_here'))
+      pkg.add_file(os.path.join(self.temp_dir, "im_not_here"))
     with self.assertRaises(zip_package.ZipPackageError):
-      pkg.add_python_file(os.path.join(self.temp_dir, 'im_not_here.py'))
+      pkg.add_python_file(os.path.join(self.temp_dir, "im_not_here.py"))
     with self.assertRaises(zip_package.ZipPackageError):
-      pkg.add_directory(os.path.join(self.temp_dir, 'im_not_here_dir'))
+      pkg.add_directory(os.path.join(self.temp_dir, "im_not_here_dir"))
 
   def test_adding_dir_as_file(self):
     # Create 'dir'.
-    self.stage_files(['dir/keep'])
+    self.stage_files(["dir/keep"])
     # Try to add it as file, not a directory.
     pkg = zip_package.ZipPackage(self.temp_dir)
     with self.assertRaises(zip_package.ZipPackageError):
-      pkg.add_file(os.path.join(self.temp_dir, 'dir'))
+      pkg.add_file(os.path.join(self.temp_dir, "dir"))
     # Adding as directory works.
-    pkg.add_directory(os.path.join(self.temp_dir, 'dir'))
+    pkg.add_directory(os.path.join(self.temp_dir, "dir"))
 
   def test_adding_non_python_as_python(self):
-    self.stage_files(['file.sh'])
+    self.stage_files(["file.sh"])
     pkg = zip_package.ZipPackage(self.temp_dir)
     with self.assertRaises(zip_package.ZipPackageError):
-      pkg.add_python_file(os.path.join(self.temp_dir, 'file.sh'))
+      pkg.add_python_file(os.path.join(self.temp_dir, "file.sh"))
 
   def test_adding_py_instead_of_pyc(self):
-    self.stage_files([
-      'file.py',
-      'file.pyo',
-      'file.pyc',
-    ])
-    for alternative in ('file.pyc', 'file.pyo'):
+    self.stage_files(
+      [
+        "file.py",
+        "file.pyo",
+        "file.pyc",
+      ]
+    )
+    for alternative in ("file.pyc", "file.pyo"):
       pkg = zip_package.ZipPackage(self.temp_dir)
       pkg.add_python_file(os.path.join(self.temp_dir, alternative))
-      self.assertIn('file.py', pkg.files)
+      self.assertIn("file.py", pkg.files)
 
   def test_adding_same_file_twice(self):
-    self.stage_files(['file'])
+    self.stage_files(["file"])
     pkg = zip_package.ZipPackage(self.temp_dir)
-    pkg.add_file(os.path.join(self.temp_dir, 'file'))
+    pkg.add_file(os.path.join(self.temp_dir, "file"))
     with self.assertRaises(zip_package.ZipPackageError):
-      pkg.add_file(os.path.join(self.temp_dir, 'file'))
+      pkg.add_file(os.path.join(self.temp_dir, "file"))
 
   def test_add_directory(self):
     should_add = [
-      'script.py',
-      'a/1.txt',
-      'a/2.txt',
-      'a/b/3.txt',
-      'a/script.py',
+      "script.py",
+      "a/1.txt",
+      "a/2.txt",
+      "a/b/3.txt",
+      "a/script.py",
     ]
     should_ignore = [
-      'script.pyc',
-      'a/script.pyo',
-      '.git/stuff',
-      '.svn/stuff',
-      'a/.svn/stuff',
-      'a/b/.svn/stuff',
+      "script.pyc",
+      "a/script.pyo",
+      ".git/stuff",
+      ".svn/stuff",
+      "a/.svn/stuff",
+      "a/b/.svn/stuff",
     ]
     # Add a whole set and verify only files from |should_add| were added.
     self.stage_files(should_add + should_ignore)
@@ -174,23 +181,23 @@
     self.assertEqual(set(pkg.files), set(should_add))
 
   def test_archive_path_is_respected(self):
-    self.stage_files(['a', 'b.py', 'dir/c'])
+    self.stage_files(["a", "b.py", "dir/c"])
     pkg = zip_package.ZipPackage(self.temp_dir)
-    pkg.add_file(os.path.join(self.temp_dir, 'a'), 'd1/a')
-    pkg.add_python_file(os.path.join(self.temp_dir, 'b.py'), 'd2/b.py')
-    pkg.add_directory(os.path.join(self.temp_dir, 'dir'), 'd3')
-    self.assertEqual(set(pkg.files), set(['d1/a', 'd2/b.py', 'd3/c']))
+    pkg.add_file(os.path.join(self.temp_dir, "a"), "d1/a")
+    pkg.add_python_file(os.path.join(self.temp_dir, "b.py"), "d2/b.py")
+    pkg.add_directory(os.path.join(self.temp_dir, "dir"), "d3")
+    self.assertEqual(set(pkg.files), set(["d1/a", "d2/b.py", "d3/c"]))
 
   def test_add_buffer(self):
     pkg = zip_package.ZipPackage(self.temp_dir)
-    pkg.add_buffer('buf1', b'')
-    self.assertEqual(list(pkg.files), ['buf1'])
+    pkg.add_buffer("buf1", b"")
+    self.assertEqual(list(pkg.files), ["buf1"])
     # No text types.
     with self.assertRaises(AssertionError):
-      pkg.add_buffer('buf2', 'unicode')
+      pkg.add_buffer("buf2", "unicode")
 
   def test_zipping(self):
-    data = {'a': b'123', 'b/c': b'456'}
+    data = {"a": b"123", "b/c": b"456"}
     self.stage_files(data)
     pkg = zip_package.ZipPackage(self.temp_dir)
     pkg.add_directory(self.temp_dir)
@@ -200,9 +207,9 @@
       self.assertEqual(data, self.read_zip(io.BytesIO(buf)))
     # Test zip_into_file produces readable zip with same content.
     for compress in (True, False):
-      path = os.path.join(self.temp_dir, 'pkg.zip')
+      path = os.path.join(self.temp_dir, "pkg.zip")
       pkg.zip_into_file(path, compress=compress)
-      with open(path, 'rb') as f:
+      with open(path, "rb") as f:
         self.assertEqual(data, self.read_zip(f))
 
   def test_repeatable_content(self):
@@ -210,7 +217,7 @@
     for _ in range(2):
       # Build temp dir content from scratch.
       assert not os.listdir(self.temp_dir)
-      self.stage_files({'a': b'123', 'b': b'456', 'c': b'789'})
+      self.stage_files({"a": b"123", "b": b"456", "c": b"789"})
       # Zip it.
       pkg = zip_package.ZipPackage(self.temp_dir)
       pkg.add_directory(self.temp_dir)
@@ -225,68 +232,84 @@
     # Test assumes that it runs from a normal checkout, not a zip.
     self.assertFalse(zip_package.is_zipped_module(sys.modules[__name__]))
     self.assertIsNone(zip_package.get_module_zip_archive(sys.modules[__name__]))
-    self.assertTrue(os.path.abspath(
-        zip_package.get_main_script_path()).startswith(test_env.CLIENT_DIR))
+    self.assertTrue(
+      os.path.abspath(zip_package.get_main_script_path()).startswith(
+        test_env.CLIENT_DIR
+      )
+    )
 
     # Build executable zip that calls same functions.
     pkg = zip_package.ZipPackage(self.temp_dir)
-    pkg.add_directory(os.path.join(test_env.CLIENT_DIR, 'utils'), 'utils')
+    pkg.add_directory(os.path.join(test_env.CLIENT_DIR, "utils"), "utils")
     pkg.add_buffer(
-        '__main__.py', b'\n'.join([
-            b'import sys',
-            b'',
-            b'from utils import zip_package',
-            b'',
-            b'print(zip_package.is_zipped_module(sys.modules[__name__]))',
-            b'print(zip_package.get_module_zip_archive(sys.modules[__name__]))',
-            b'print(zip_package.get_main_script_path())',
-        ]))
-    zip_file = os.path.join(self.temp_dir, 'out.zip')
+      "__main__.py",
+      b"\n".join(
+        [
+          b"import sys",
+          b"",
+          b"from utils import zip_package",
+          b"",
+          b"print(zip_package.is_zipped_module(sys.modules[__name__]))",
+          b"print(zip_package.get_module_zip_archive(sys.modules[__name__]))",
+          b"print(zip_package.get_main_script_path())",
+        ]
+      ),
+    )
+    zip_file = os.path.join(self.temp_dir, "out.zip")
     pkg.zip_into_file(zip_file)
 
     # Run the zip, validate results.
     actual = check_output([sys.executable, zip_file]).strip().splitlines()
-    self.assertEqual(['True', zip_file, zip_file], actual)
+    self.assertEqual(["True", zip_file, zip_file], actual)
 
   def test_extract_resource(self):
     pkg = zip_package.ZipPackage(self.temp_dir)
-    pkg.add_directory(os.path.join(test_env.CLIENT_DIR, 'utils'), 'utils')
-    pkg.add_buffer('cert.pem', b'Certificate\n')
+    pkg.add_directory(os.path.join(test_env.CLIENT_DIR, "utils"), "utils")
+    pkg.add_buffer("cert.pem", b"Certificate\n")
     pkg.add_buffer(
-        '__main__.py', b'\n'.join([
-            b'import sys',
-            b'from utils import zip_package',
-            b'print(zip_package.extract_resource(',
-            b'    sys.modules[__name__], \'cert.pem\'))',
-        ]))
-    zip_file = os.path.join(self.temp_dir, 'out.zip')
+      "__main__.py",
+      b"\n".join(
+        [
+          b"import sys",
+          b"from utils import zip_package",
+          b"print(zip_package.extract_resource(",
+          b"    sys.modules[__name__], 'cert.pem'))",
+        ]
+      ),
+    )
+    zip_file = os.path.join(self.temp_dir, "out.zip")
     pkg.zip_into_file(zip_file)
     actual = check_output([sys.executable, zip_file]).strip()
     self.assertEqual(tempfile.gettempdir(), os.path.dirname(actual))
     basename = os.path.basename(actual)
-    self.assertTrue(basename.startswith('.zip_pkg-'), actual)
-    self.assertTrue(basename.endswith('-cert.pem'), actual)
+    self.assertTrue(basename.startswith(".zip_pkg-"), actual)
+    self.assertTrue(basename.endswith("-cert.pem"), actual)
 
   def test_extract_resource_temp_dir(self):
     pkg = zip_package.ZipPackage(self.temp_dir)
-    pkg.add_directory(os.path.join(test_env.CLIENT_DIR, 'utils'), 'utils')
-    pkg.add_buffer('cert.pem', b'Certificate\n')
+    pkg.add_directory(os.path.join(test_env.CLIENT_DIR, "utils"), "utils")
+    pkg.add_buffer("cert.pem", b"Certificate\n")
     pkg.add_buffer(
-        '__main__.py', b'\n'.join([
-            b'import sys',
-            b'from utils import zip_package',
-            b'print(zip_package.extract_resource(',
-            b'  sys.modules[__name__], \'cert.pem\', %r))' % self.temp_dir,
-        ]))
-    zip_file = os.path.join(self.temp_dir, 'out.zip')
+      "__main__.py",
+      b"\n".join(
+        [
+          b"import sys",
+          b"from utils import zip_package",
+          b"print(zip_package.extract_resource(",
+          b"  sys.modules[__name__], 'cert.pem', %r))" % self.temp_dir,
+        ]
+      ),
+    )
+    zip_file = os.path.join(self.temp_dir, "out.zip")
     pkg.zip_into_file(zip_file)
     actual = check_output([sys.executable, zip_file]).strip()
     expected = os.path.join(
-        self.temp_dir,
-        'e47a41780d9cb4a1234e4915b14443bdaa8fae9f821b00f0f2fed719661572f6-cert.'
-            'pem')
+      self.temp_dir,
+      "e47a41780d9cb4a1234e4915b14443bdaa8fae9f821b00f0f2fed719661572f6-cert."
+      "pem",
+    )
     self.assertEqual(expected, actual)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
   test_env.main()
diff --git a/utils/auth_server.py b/utils/auth_server.py
index 7fe34f0..077bd5b 100755
--- a/utils/auth_server.py
+++ b/utils/auth_server.py
@@ -16,10 +16,13 @@
 import time
 
 # Access or ID token with its expiration time.
-AccessToken = collections.namedtuple('AccessToken', [
-  'access_token',  # urlsafe str with the token
-  'expiry',        # expiration time as unix timestamp in seconds
-])
+AccessToken = collections.namedtuple(
+  "AccessToken",
+  [
+    "access_token",  # urlsafe str with the token
+    "expiry",  # expiration time as unix timestamp in seconds
+  ],
+)
 
 
 class TokenError(Exception):
@@ -42,7 +45,7 @@
 
 
 # Account describes one logical account.
-Account = collections.namedtuple('Account', ['id', 'email'])
+Account = collections.namedtuple("Account", ["id", "email"])
 
 
 class TokenProvider:
@@ -90,7 +93,7 @@
   """
 
   def __init__(self):
-    self._lock = threading.Lock() # guards everything below
+    self._lock = threading.Lock()  # guards everything below
     self._accept_thread = None
     self._cache = {}  # see get_cached_token
     self._token_provider = None
@@ -113,20 +116,20 @@
     assert all(isinstance(acc, Account) for acc in accounts), accounts
 
     # 'default_account_id' is either not set, or one of the supported accounts.
-    assert (
-        not default_account_id or
-        any(default_account_id == acc.id for acc in accounts))
+    assert not default_account_id or any(
+      default_account_id == acc.id for acc in accounts
+    )
 
-    server = _HTTPServer(self, ('127.0.0.1', port))
+    server = _HTTPServer(self, ("127.0.0.1", port))
 
     # This secret will be placed in a file on disk accessible only to current
     # user processes. RPC requests are expected to send this secret verbatim.
     # That way we authenticate RPCs as coming from current user's processes.
-    rpc_secret = base64.b64encode(os.urandom(48)).decode('ascii')
+    rpc_secret = base64.b64encode(os.urandom(48)).decode("ascii")
 
     with self._lock:
-      assert not self._server, 'Already running'
-      logging.info('Local auth server: http://127.0.0.1:%d', server.server_port)
+      assert not self._server, "Already running"
+      logging.info("Local auth server: http://127.0.0.1:%d", server.server_port)
       self._token_provider = token_provider
       self._accounts = frozenset(accounts)
       self._rpc_secret = rpc_secret
@@ -134,19 +137,16 @@
       self._accept_thread = threading.Thread(target=self._server.serve_forever)
       self._accept_thread.start()
       local_auth = {
-          'rpc_port':
-              self._server.server_port,
-          'secret':
-              self._rpc_secret,
-          'accounts': [{
-              'id': acc.id,
-              'email': acc.email
-          } for acc in sorted(accounts)],
+        "rpc_port": self._server.server_port,
+        "secret": self._rpc_secret,
+        "accounts": [
+          {"id": acc.id, "email": acc.email} for acc in sorted(accounts)
+        ],
       }
       # TODO(vadimsh): Some clients don't understand 'null' value for
       # default_account_id, so just omit it completely for now.
       if default_account_id:
-        local_auth['default_account_id'] = default_account_id
+        local_auth["default_account_id"] = default_account_id
       return local_auth
 
   def stop(self):
@@ -160,11 +160,11 @@
       self._accounts = frozenset()
       self._rpc_secret = None
       self._cache.clear()
-    logging.debug('Stopping the local auth server...')
+    logging.debug("Stopping the local auth server...")
     server.shutdown()
     thread.join()
     server.server_close()
-    logging.info('The local auth server is stopped')
+    logging.info("The local auth server is stopped")
 
   def handle_rpc(self, method, request):
     """Called by _RequestHandler to handle one RPC call.
@@ -183,9 +183,9 @@
     Raises:
       RPCError to return non-200 HTTP code and an error message as plain text.
     """
-    if method == 'GetOAuthToken':
+    if method == "GetOAuthToken":
       return self.handle_get_oauth_token(request)
-    if method == 'GetIDToken':
+    if method == "GetIDToken":
       return self.handle_get_id_token(request)
     raise RPCError(404, 'Unknown RPC method "%s".' % method)
 
@@ -216,31 +216,33 @@
     account_id = self.check_account_and_secret(request)
 
     # Validate scopes. It is conceptually a set, so remove duplicates.
-    scopes = request.get('scopes')
+    scopes = request.get("scopes")
     if not scopes:
       raise RPCError(400, 'Field "scopes" is required.')
-    if (not isinstance(scopes, list)
-        or not all(isinstance(s, str) for s in scopes)):
+    if not isinstance(scopes, list) or not all(
+      isinstance(s, str) for s in scopes
+    ):
       raise RPCError(400, 'Field "scopes" must be a list of strings.')
     scopes = tuple(sorted(set(map(str, scopes))))
 
     # Get the cached token or generate a new one.
     tok_or_err = self.get_cached_token(
-        cache_key=('access_token', account_id, scopes),
-        refresh_callback=lambda p: p.generate_access_token(account_id, scopes))
+      cache_key=("access_token", account_id, scopes),
+      refresh_callback=lambda p: p.generate_access_token(account_id, scopes),
+    )
 
     # Done.
     if isinstance(tok_or_err, AccessToken):
       return {
-        'access_token': tok_or_err.access_token,
-        'expiry': int(tok_or_err.expiry),
+        "access_token": tok_or_err.access_token,
+        "expiry": int(tok_or_err.expiry),
       }
     if isinstance(tok_or_err, TokenError):
       return {
-          'error_code': tok_or_err.code,
-          'error_message': str(tok_or_err) or 'unknown',
+        "error_code": tok_or_err.code,
+        "error_message": str(tok_or_err) or "unknown",
       }
-    raise AssertionError('impossible')
+    raise AssertionError("impossible")
 
   def handle_get_id_token(self, request):
     """Returns an ID token representing the task service account.
@@ -267,7 +269,7 @@
     account_id = self.check_account_and_secret(request)
 
     # An audience is a string and it is required.
-    audience = request.get('audience')
+    audience = request.get("audience")
     if not audience:
       raise RPCError(400, 'Field "audience" is required.')
     if not isinstance(audience, str):
@@ -276,21 +278,22 @@
 
     # Get the cached token or generate a new one.
     tok_or_err = self.get_cached_token(
-        cache_key=('id_token', account_id, audience),
-        refresh_callback=lambda p: p.generate_id_token(account_id, audience))
+      cache_key=("id_token", account_id, audience),
+      refresh_callback=lambda p: p.generate_id_token(account_id, audience),
+    )
 
     # Done.
     if isinstance(tok_or_err, AccessToken):
       return {
-        'id_token': tok_or_err.access_token,
-        'expiry': int(tok_or_err.expiry),
+        "id_token": tok_or_err.access_token,
+        "expiry": int(tok_or_err.expiry),
       }
     if isinstance(tok_or_err, TokenError):
       return {
-          'error_code': tok_or_err.code,
-          'error_message': str(tok_or_err) or 'unknown',
+        "error_code": tok_or_err.code,
+        "error_message": str(tok_or_err) or "unknown",
       }
-    raise AssertionError('impossible')
+    raise AssertionError("impossible")
 
   ### Utilities used by RPC handlers. Called from internal threads.
 
@@ -304,7 +307,7 @@
       RPCError on validation errors.
     """
     # Logical account to get a token for (e.g. "task" or "system").
-    account_id = request.get('account_id')
+    account_id = request.get("account_id")
     if not account_id:
       raise RPCError(400, 'Field "account_id" is required.')
     if not isinstance(account_id, str):
@@ -312,7 +315,7 @@
     account_id = str(account_id)
 
     # Validate the secret format.
-    secret = request.get('secret')
+    secret = request.get("secret")
     if not secret:
       raise RPCError(400, 'Field "secret" is required.')
     if not isinstance(secret, str):
@@ -322,7 +325,7 @@
     # Grab the state from the lock-guarded area.
     with self._lock:
       if not self._server:
-        raise RPCError(503, 'Stopped already.')
+        raise RPCError(503, "Stopped already.")
       rpc_secret = self._rpc_secret
       accounts = self._accounts
 
@@ -333,7 +336,7 @@
 
     # Make sure we know about the requested account.
     if not any(account_id == acc.id for acc in accounts):
-      raise RPCError(404, 'Unrecognized account ID %r.' % account_id)
+      raise RPCError(404, "Unrecognized account ID %r." % account_id)
 
     return account_id
 
@@ -360,7 +363,7 @@
     # expiration time. Grab _token_provider while we are holding the lock.
     with self._lock:
       if not self._server:
-        raise RPCError(503, 'Stopped already.')
+        raise RPCError(503, "Stopped already.")
       tok_or_err = self._cache.get(cache_key)
       if isinstance(tok_or_err, TokenError):
         return tok_or_err  # cached fatal error
@@ -381,7 +384,7 @@
     # Cache the token or fatal errors (to avoid useless retry later).
     with self._lock:
       if not self._server:
-        raise RPCError(503, 'Stopped already.')
+        raise RPCError(503, "Stopped already.")
       self._cache[cache_key] = tok_or_err
 
     return tok_or_err
@@ -401,7 +404,7 @@
   """Returns True if the token must be refreshed because it expires soon."""
   # LUCI_CONTEXT protocol requires that returned tokens are alive for at least
   # 2.5 min. See LUCI_CONTEXT.md. Add 30 sec extra of leeway.
-  return time.time() > tok.expiry - 3*60
+  return time.time() > tok.expiry - 3 * 60
 
 
 class _HTTPServer(socketserver.ThreadingMixIn, http.server.HTTPServer):
@@ -424,12 +427,13 @@
 
   def serve_forever(self, poll_interval=None):
     """Overrides default poll interval."""
-    http.server.HTTPServer.serve_forever(self, poll_interval
-                                         or self.poll_interval)
+    http.server.HTTPServer.serve_forever(
+      self, poll_interval or self.poll_interval
+    )
 
   def handle_error(self, _request, _client_address):
     """Overrides default handle_error that dumbs stuff to stdout."""
-    logging.exception('local auth server: Exception happened')
+    logging.exception("local auth server: Exception happened")
 
 
 ERROR_MESSAGE = """\
@@ -451,61 +455,62 @@
   # Overrides to send 'text/plain' error response.
   error_message_format = ERROR_MESSAGE
 
-  error_content_type = 'text/plain;charset=utf-8'
+  error_content_type = "text/plain;charset=utf-8"
 
   def log_message(self, fmt, *args):  # pylint: disable=arguments-differ
     """Overrides default log_message to not abuse stderr."""
-    logging.debug('local auth server: ' + fmt, *args)
+    logging.debug("local auth server: " + fmt, *args)
 
   def do_POST(self):
     """Implements POST handler."""
     # Parse URL to extract method name.
-    m = re.match(r'^/rpc/LuciLocalAuthService\.([a-zA-Z0-9_]+)$', self.path)
+    m = re.match(r"^/rpc/LuciLocalAuthService\.([a-zA-Z0-9_]+)$", self.path)
     if not m:
-      self.send_error(404, 'Expecting /rpc/LuciLocalAuthService.*')
+      self.send_error(404, "Expecting /rpc/LuciLocalAuthService.*")
       return
     method = m.group(1)
 
     # The request body MUST be JSON. Ignore charset, we don't care.
-    ct = self.headers.get('content-type')
-    if not ct or ct.split(';')[0] != 'application/json':
+    ct = self.headers.get("content-type")
+    if not ct or ct.split(";")[0] != "application/json":
       self.send_error(
-          400, 'Expecting "application/json" Content-Type, got %r' % ct)
+        400, 'Expecting "application/json" Content-Type, got %r' % ct
+      )
       return
 
     # Read the body. Chunked transfer encoding or compression is no supported.
     try:
-      content_len = int(self.headers['content-length'])
+      content_len = int(self.headers["content-length"])
     except ValueError:
-      self.send_error(400, 'Missing on invalid Content-Length header')
+      self.send_error(400, "Missing on invalid Content-Length header")
       return
     try:
       req = json.loads(self.rfile.read(content_len))
     except ValueError as exc:
-      self.send_error(400, 'Not a JSON: %s' % exc)
+      self.send_error(400, "Not a JSON: %s" % exc)
       return
     if not isinstance(req, dict):
-      self.send_error(400, 'Not a JSON dictionary')
+      self.send_error(400, "Not a JSON dictionary")
       return
 
     # Let the LocalAuthServer handle the request. Prepare the response body.
     try:
       resp = self.server.local_auth_server.handle_rpc(method, req)
-      response_body = json.dumps(resp) + '\n'
+      response_body = json.dumps(resp) + "\n"
     except RPCError as exc:
       self.send_error(exc.code, str(exc))
       return
     except Exception as exc:
-      self.send_error(500, 'Internal error: %s' % exc)
+      self.send_error(500, "Internal error: %s" % exc)
       return
 
     # Send the response.
     self.send_response(200)
-    self.send_header('Connection', 'close')
-    self.send_header('Content-Length', str(len(response_body)))
-    self.send_header('Content-Type', 'application/json')
+    self.send_header("Connection", "close")
+    self.send_header("Content-Length", str(len(response_body)))
+    self.send_header("Content-Type", "application/json")
     self.end_headers()
-    self.wfile.write(response_body.encode('utf-8'))
+    self.wfile.write(response_body.encode("utf-8"))
 
 
 def testing_main():
@@ -522,26 +527,28 @@
 
   class DumbProvider:
     def generate_access_token(self, account_id, scopes):
-      logging.info('generate_access_token(%r, %r) called', account_id, scopes)
-      return AccessToken('fake_access_tok_%s' % account_id, time.time() + 300)
+      logging.info("generate_access_token(%r, %r) called", account_id, scopes)
+      return AccessToken("fake_access_tok_%s" % account_id, time.time() + 300)
+
     def generate_id_token(self, account_id, audience):
-      logging.info('generate_id_token(%r, %r) called', account_id, audience)
-      return AccessToken('fake_id_tok_%s' % account_id, time.time() + 300)
+      logging.info("generate_id_token(%r, %r) called", account_id, audience)
+      return AccessToken("fake_id_tok_%s" % account_id, time.time() + 300)
 
   server = LocalAuthServer()
   ctx = server.start(
-      token_provider=DumbProvider(),
-      accounts=[
-          Account('a', 'a@example.com'),
-          Account('b', 'b@example.com'),
-          Account('c', 'c@example.com'),
-      ],
-      default_account_id='a',
-      port=11111)
+    token_provider=DumbProvider(),
+    accounts=[
+      Account("a", "a@example.com"),
+      Account("b", "b@example.com"),
+      Account("c", "c@example.com"),
+    ],
+    default_account_id="a",
+    port=11111,
+  )
   try:
     with luci_context.write(local_auth=ctx):
-      print('Copy-paste this into another shell:')
-      print('export LUCI_CONTEXT=%s' % os.getenv('LUCI_CONTEXT'))
+      print("Copy-paste this into another shell:")
+      print("export LUCI_CONTEXT=%s" % os.getenv("LUCI_CONTEXT"))
       while True:
         time.sleep(1)
   except KeyboardInterrupt:
@@ -550,5 +557,5 @@
     server.stop()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
   testing_main()
diff --git a/utils/authenticators.py b/utils/authenticators.py
index da6ba68..dd827de 100644
--- a/utils/authenticators.py
+++ b/utils/authenticators.py
@@ -56,16 +56,19 @@
           need_refresh = False
       if need_refresh:
         self._access_token = oauth.create_access_token(
-            self.urlhost, self.config, False)
+          self.urlhost, self.config, False
+        )
       if self._access_token:
-        request.headers['Authorization'] = (
-            'Bearer %s' % self._access_token.token)
+        request.headers["Authorization"] = (
+          "Bearer %s" % self._access_token.token
+        )
 
   def login(self, allow_user_interaction):
     with self._lock:
       # Forcefully refresh the token.
       self._access_token = oauth.create_access_token(
-          self.urlhost, self.config, allow_user_interaction)
+        self.urlhost, self.config, allow_user_interaction
+      )
       return self._access_token is not None
 
   def logout(self):
@@ -98,12 +101,12 @@
           self._access_token = access_token
 
     if access_token:
-      request.headers['Authorization'] = 'Bearer %s' % access_token.token
+      request.headers["Authorization"] = "Bearer %s" % access_token.token
 
   def login(self, allow_user_interaction):
     """Run interactive authentication flow refreshing the token."""
-    raise RuntimeError('Interactive login not supported.')
+    raise RuntimeError("Interactive login not supported.")
 
   def logout(self):
     """Purges access credentials from local cache."""
-    raise RuntimeError('Interactive logout not supported.')
+    raise RuntimeError("Interactive logout not supported.")
diff --git a/utils/file_path.py b/utils/file_path.py
index aeb0641..28910cb 100644
--- a/utils/file_path.py
+++ b/utils/file_path.py
@@ -28,71 +28,83 @@
 
 # Types of action accepted by link_file().
 HARDLINK, HARDLINK_WITH_FALLBACK, SYMLINK, SYMLINK_WITH_FALLBACK, COPY = range(
-    1, 6)
+  1, 6
+)
 
 
 ## OS-specific imports
 
 
-if sys.platform == 'win32':
+if sys.platform == "win32":
   import locale
   from ctypes import wintypes  # pylint: disable=ungrouped-imports
   from ctypes import windll  # pylint: disable=ungrouped-imports
 
-if sys.platform == 'win32':
+if sys.platform == "win32":
+
   class LUID(ctypes.Structure):
     _fields_ = [
-      ('low_part', wintypes.DWORD), ('high_part', wintypes.LONG),
+      ("low_part", wintypes.DWORD),
+      ("high_part", wintypes.LONG),
     ]
 
-
   class LUID_AND_ATTRIBUTES(ctypes.Structure):
-    _fields_ = [('LUID', LUID), ('attributes', wintypes.DWORD)]
-
+    _fields_ = [("LUID", LUID), ("attributes", wintypes.DWORD)]
 
   class TOKEN_PRIVILEGES(ctypes.Structure):
     _fields_ = [
-      ('count', wintypes.DWORD), ('privileges', LUID_AND_ATTRIBUTES*0),
+      ("count", wintypes.DWORD),
+      ("privileges", LUID_AND_ATTRIBUTES * 0),
     ]
 
     def get_array(self):
       array_type = LUID_AND_ATTRIBUTES * self.count
       return ctypes.cast(self.privileges, ctypes.POINTER(array_type)).contents
 
-
   GetCurrentProcess = windll.kernel32.GetCurrentProcess
   GetCurrentProcess.restype = wintypes.HANDLE
   OpenProcessToken = windll.advapi32.OpenProcessToken
   OpenProcessToken.argtypes = (
-      wintypes.HANDLE, wintypes.DWORD, ctypes.POINTER(wintypes.HANDLE))
+    wintypes.HANDLE,
+    wintypes.DWORD,
+    ctypes.POINTER(wintypes.HANDLE),
+  )
   OpenProcessToken.restype = wintypes.BOOL
   LookupPrivilegeValue = windll.advapi32.LookupPrivilegeValueW
   LookupPrivilegeValue.argtypes = (
-      wintypes.LPCWSTR, wintypes.LPCWSTR, ctypes.POINTER(LUID))
+    wintypes.LPCWSTR,
+    wintypes.LPCWSTR,
+    ctypes.POINTER(LUID),
+  )
   LookupPrivilegeValue.restype = wintypes.BOOL
   LookupPrivilegeName = windll.advapi32.LookupPrivilegeNameW
   LookupPrivilegeName.argtypes = (
-      wintypes.LPCWSTR, ctypes.POINTER(LUID), wintypes.LPWSTR,
-      ctypes.POINTER(wintypes.DWORD))
+    wintypes.LPCWSTR,
+    ctypes.POINTER(LUID),
+    wintypes.LPWSTR,
+    ctypes.POINTER(wintypes.DWORD),
+  )
   LookupPrivilegeName.restype = wintypes.BOOL
   PTOKEN_PRIVILEGES = ctypes.POINTER(TOKEN_PRIVILEGES)
   AdjustTokenPrivileges = windll.advapi32.AdjustTokenPrivileges
   AdjustTokenPrivileges.restype = wintypes.BOOL
   AdjustTokenPrivileges.argtypes = (
-      wintypes.HANDLE, wintypes.BOOL, PTOKEN_PRIVILEGES,
-      wintypes.DWORD, PTOKEN_PRIVILEGES,
-      ctypes.POINTER(wintypes.DWORD))
-
+    wintypes.HANDLE,
+    wintypes.BOOL,
+    PTOKEN_PRIVILEGES,
+    wintypes.DWORD,
+    PTOKEN_PRIVILEGES,
+    ctypes.POINTER(wintypes.DWORD),
+  )
 
   def FormatError(err):
     """Returns a formatted error on Windows."""
     # We need to take in account the current code page.
     return ctypes.FormatError(err)
 
-
   def QueryDosDevice(drive_letter):
     """Returns the Windows 'native' path for a DOS drive letter."""
-    assert re.match(r'^[a-zA-Z]:$', drive_letter), drive_letter
+    assert re.match(r"^[a-zA-Z]:$", drive_letter), drive_letter
     assert isinstance(drive_letter, str)
     # Guesswork. QueryDosDeviceW never returns the required number of bytes.
     chars = 1024
@@ -101,12 +113,14 @@
       err = ctypes.GetLastError()
       if err:
         # pylint: disable=undefined-variable
-        msg = 'QueryDosDevice(%s): %s (%d)' % (drive_letter, FormatError(err),
-                                               err)
-        raise WindowsError(err, msg.encode('utf-8'))
+        msg = "QueryDosDevice(%s): %s (%d)" % (
+          drive_letter,
+          FormatError(err),
+          err,
+        )
+        raise WindowsError(err, msg.encode("utf-8"))
     return p.value
 
-
   def GetShortPathName(long_path):
     """Returns the Windows short path equivalent for a 'long' path."""
     path = fs.extend(long_path)
@@ -119,11 +133,10 @@
     err = ctypes.GetLastError()
     if err:
       # pylint: disable=undefined-variable
-      msg = 'GetShortPathName(%s): %s (%d)' % (long_path, FormatError(err), err)
-      raise WindowsError(err, msg.encode('utf-8'))
+      msg = "GetShortPathName(%s): %s (%d)" % (long_path, FormatError(err), err)
+      raise WindowsError(err, msg.encode("utf-8"))
     return None
 
-
   def GetLongPathName(short_path):
     """Returns the Windows long path equivalent for a 'short' path."""
     path = fs.extend(short_path)
@@ -136,11 +149,10 @@
     err = ctypes.GetLastError()
     if err:
       # pylint: disable=undefined-variable
-      msg = 'GetLongPathName(%s): %s (%d)' % (short_path, FormatError(err), err)
-      raise WindowsError(err, msg.encode('utf-8'))
+      msg = "GetLongPathName(%s): %s (%d)" % (short_path, FormatError(err), err)
+      raise WindowsError(err, msg.encode("utf-8"))
     return None
 
-
   def MoveFileEx(oldpath, newpath, flags):
     """Calls MoveFileEx, converting errors to WindowsError exceptions."""
     old_p = fs.extend(oldpath)
@@ -148,13 +160,18 @@
     if not windll.kernel32.MoveFileExW(old_p, new_p, int(flags)):
       # pylint: disable=undefined-variable
       err = ctypes.GetLastError()
-      msg = 'MoveFileEx(%s, %s, %d): %s (%d)' % (oldpath, newpath, flags,
-                                                 FormatError(err), err)
-      raise WindowsError(err, msg.encode('utf-8'))
-
+      msg = "MoveFileEx(%s, %s, %d): %s (%d)" % (
+        oldpath,
+        newpath,
+        flags,
+        FormatError(err),
+        err,
+      )
+      raise WindowsError(err, msg.encode("utf-8"))
 
   class DosDriveMap:
     """Maps \\Device\\HarddiskVolumeN to N: on Windows."""
+
     # Keep one global cache.
     _MAPPING = {}
 
@@ -162,21 +179,24 @@
       """Lazy loads the cache."""
       if not self._MAPPING:
         # This is related to UNC resolver on windows. Ignore that.
-        self._MAPPING['\\Device\\Mup'] = None
-        self._MAPPING['\\SystemRoot'] = os.environ['SystemRoot']
+        self._MAPPING["\\Device\\Mup"] = None
+        self._MAPPING["\\SystemRoot"] = os.environ["SystemRoot"]
 
-        for letter in (chr(l) for l in range(ord('C'), ord('Z') + 1)):
+        for letter in (chr(l) for l in range(ord("C"), ord("Z") + 1)):
           try:
-            letter = '%s:' % letter
+            letter = "%s:" % letter
             mapped = QueryDosDevice(letter)
             if mapped in self._MAPPING:
               logging.warning(
-                  ('Two drives: \'%s\' and \'%s\', are mapped to the same disk'
-                   '. Drive letters are a user-mode concept and the kernel '
-                   'traces only have NT path, so all accesses will be '
-                   'associated with the first drive letter, independent of the '
-                   'actual letter used by the code') % (self._MAPPING[mapped],
-                                                        letter))
+                (
+                  "Two drives: '%s' and '%s', are mapped to the same disk"
+                  ". Drive letters are a user-mode concept and the kernel "
+                  "traces only have NT path, so all accesses will be "
+                  "associated with the first drive letter, independent of the "
+                  "actual letter used by the code"
+                )
+                % (self._MAPPING[mapped], letter)
+              )
             else:
               self._MAPPING[mapped] = letter
           except WindowsError:  # pylint: disable=undefined-variable
@@ -184,11 +204,11 @@
 
     def to_win32(self, path):
       """Converts a native NT path to Win32/DOS compatible path."""
-      match = re.match(r'(^\\Device\\[a-zA-Z0-9]+)(\\.*)?$', path)
+      match = re.match(r"(^\\Device\\[a-zA-Z0-9]+)(\\.*)?$", path)
       if not match:
         raise ValueError(
-            'Can\'t convert %s into a Win32 compatible path' % path,
-            path)
+          "Can't convert %s into a Win32 compatible path" % path, path
+        )
       if not match.group(1) in self._MAPPING:
         # Unmapped partitions may be accessed by windows for the
         # fun of it while the test is running. Discard these.
@@ -198,7 +218,6 @@
         return drive
       return drive + match.group(2)
 
-
   def change_acl_for_delete(path):
     """Zaps the SECURITY_DESCRIPTOR's DACL on a directory entry that is tedious
     to delete.
@@ -208,58 +227,59 @@
 
     Used as last resort.
     """
-    STANDARD_RIGHTS_REQUIRED = 0xf0000
+    STANDARD_RIGHTS_REQUIRED = 0xF0000
     SYNCHRONIZE = 0x100000
-    FILE_ALL_ACCESS = STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0x3ff
+    FILE_ALL_ACCESS = STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0x3FF
 
     import win32security
+
     user, _domain, _type = win32security.LookupAccountName(
-        '', getpass.getuser())
+      "", getpass.getuser()
+    )
     sd = win32security.SECURITY_DESCRIPTOR()
     sd.Initialize()
     sd.SetSecurityDescriptorOwner(user, False)
     dacl = win32security.ACL()
     dacl.Initialize()
     dacl.AddAccessAllowedAce(
-        win32security.ACL_REVISION_DS, FILE_ALL_ACCESS, user)
+      win32security.ACL_REVISION_DS, FILE_ALL_ACCESS, user
+    )
     sd.SetSecurityDescriptorDacl(1, dacl, 0)
     # Note that this assumes the object is either owned by the current user or
     # its group or that the current ACL permits this. Otherwise it will silently
     # fail.
     win32security.SetFileSecurity(
-        fs.extend(path), win32security.DACL_SECURITY_INFORMATION, sd)
+      fs.extend(path), win32security.DACL_SECURITY_INFORMATION, sd
+    )
     # It's important to also look for the read only bit after, as it's possible
     # the set_read_only() call to remove the read only bit had silently failed
     # because there was no DACL for the user.
     if not (os.stat(path).st_mode & stat.S_IWUSR):
       os.chmod(path, 0o777)
 
-
   def isabs(path):
     """Accepts X: as an absolute path, unlike python's os.path.isabs()."""
-    return os.path.isabs(path) or len(path) == 2 and path[1] == ':'
-
+    return os.path.isabs(path) or len(path) == 2 and path[1] == ":"
 
   def get_process_token():
     """Get the current process token."""
     TOKEN_ALL_ACCESS = 0xF01FF
     token = ctypes.wintypes.HANDLE()
     if not OpenProcessToken(
-        GetCurrentProcess(), TOKEN_ALL_ACCESS, ctypes.byref(token)):
+      GetCurrentProcess(), TOKEN_ALL_ACCESS, ctypes.byref(token)
+    ):
       # pylint: disable=undefined-variable
-      raise WindowsError('Couldn\'t get process token')
+      raise WindowsError("Couldn't get process token")
     return token
 
-
   def get_luid(name):
     """Returns the LUID for a privilege."""
     luid = LUID()
     if not LookupPrivilegeValue(None, str(name), ctypes.byref(luid)):
       # pylint: disable=undefined-variable
-      raise WindowsError('Couldn\'t lookup privilege value')
+      raise WindowsError("Couldn't lookup privilege value")
     return luid
 
-
   def enable_privilege(name):
     """Enables the privilege for the current process token.
 
@@ -279,13 +299,14 @@
     try:
       if not AdjustTokenPrivileges(token, False, tp, 0, None, None):
         # pylint: disable=undefined-variable
-        raise WindowsError('AdjustTokenPrivileges(%r): failed: %s' %
-                           (name, ctypes.GetLastError()))
+        raise WindowsError(
+          "AdjustTokenPrivileges(%r): failed: %s"
+          % (name, ctypes.GetLastError())
+        )
     finally:
       windll.kernel32.CloseHandle(token)
     return ctypes.GetLastError() != ERROR_NOT_ALL_ASSIGNED
 
-
   def enable_symlink():
     """Enable SeCreateSymbolicLinkPrivilege for the current token.
 
@@ -305,8 +326,7 @@
     Returns:
     - True if symlink support is enabled.
     """
-    return enable_privilege('SeCreateSymbolicLinkPrivilege')
-
+    return enable_privilege("SeCreateSymbolicLinkPrivilege")
 
   def kill_children_processes(root):
     """Try to kill all children processes indistriminately and prints updates to
@@ -318,24 +338,27 @@
     processes = _get_children_processes_win(root)
     if not processes:
       return False
-    logging.debug('Enumerating processes:\n')
+    logging.debug("Enumerating processes:\n")
     for _, proc in sorted(processes.items()):
-      logging.debug('- pid %d; Handles: %d; Exe: %s; Cmd: %s\n', proc.ProcessId,
-                    proc.HandleCount, proc.ExecutablePath, proc.CommandLine)
-    logging.debug('Terminating %d processes:\n', len(processes))
+      logging.debug(
+        "- pid %d; Handles: %d; Exe: %s; Cmd: %s\n",
+        proc.ProcessId,
+        proc.HandleCount,
+        proc.ExecutablePath,
+        proc.CommandLine,
+      )
+    logging.debug("Terminating %d processes:\n", len(processes))
     for pid in sorted(processes):
       try:
         # Killing is asynchronous.
         os.kill(pid, 9)
-        logging.debug('- %d killed\n', pid)
+        logging.debug("- %d killed\n", pid)
       except OSError as e:
-        logging.error('- failed to kill %s, error %s\n', pid, e)
+        logging.error("- failed to kill %s, error %s\n", pid, e)
     return True
 
-
   ## Windows private code.
 
-
   def _enum_processes_win():
     """Returns all processes on the system that are accessible to this process.
 
@@ -344,15 +367,16 @@
       http://msdn.microsoft.com/library/aa394372.aspx for more details.
     """
     import win32com.client  # pylint: disable=F0401
-    wmi_service = win32com.client.Dispatch('WbemScripting.SWbemLocator')
-    wbem = wmi_service.ConnectServer('.', 'root\\cimv2')
-    return list(wbem.ExecQuery('SELECT * FROM Win32_Process'))
 
+    wmi_service = win32com.client.Dispatch("WbemScripting.SWbemLocator")
+    wbem = wmi_service.ConnectServer(".", "root\\cimv2")
+    return list(wbem.ExecQuery("SELECT * FROM Win32_Process"))
 
   def _filter_processes_dir_win(processes, root_dir):
     """Returns all processes which has their main executable located inside
     root_dir.
     """
+
     def normalize_path(filename):
       try:
         return GetLongPathName(str(filename)).lower()
@@ -376,11 +400,11 @@
     long_names = ((process_name(proc), proc) for proc in processes)
 
     return [
-      proc for name, proc in long_names
+      proc
+      for name, proc in long_names
       if name is not None and name.startswith(root_dir)
     ]
 
-
   def _filter_processes_tree_win(processes):
     """Returns all the processes under the current process."""
     # Convert to dict.
@@ -391,15 +415,14 @@
       found = set()
       for pid in out:
         found.update(
-            p.ProcessId for p in processes.values()
-            if p.ParentProcessId == pid)
+          p.ProcessId for p in processes.values() if p.ParentProcessId == pid
+        )
       found -= set(out)
       if not found:
         break
       out.update((p, processes[p]) for p in found)
     return out.values()
 
-
   def _get_children_processes_win(root):
     """Returns a list of processes.
 
@@ -421,9 +444,7 @@
     return processes
 
 
-elif sys.platform == 'darwin':
-
-
+elif sys.platform == "darwin":
   # On non-windows, keep the stdlib behavior.
   isabs = os.path.isabs
 
@@ -431,8 +452,6 @@
     return True
 
 else:  # OSes other than Windows and OSX.
-
-
   # On non-windows, keep the stdlib behavior.
   isabs = os.path.isabs
 
@@ -440,8 +459,7 @@
     return True
 
 
-if sys.platform != 'win32':  # All non-Windows OSes.
-
+if sys.platform != "win32":  # All non-Windows OSes.
 
   def safe_join(*args):
     """Joins path elements like os.path.join() but doesn't abort on absolute
@@ -450,7 +468,7 @@
     os.path.join('foo', '/bar') == '/bar'
     but safe_join('foo', '/bar') == 'foo/bar'.
     """
-    out = ''
+    out = ""
     for element in args:
       if element.startswith(os.path.sep):
         if out.endswith(os.path.sep):
@@ -464,7 +482,6 @@
           out += os.path.sep + element
     return out
 
-
   @tools.profile
   def split_at_symlink(base_dir, relfile):
     """Scans each component of relfile and cut the string at the symlink if
@@ -498,15 +515,15 @@
         symlink = os.path.basename(relfile[:index])
         rest = relfile[index:]
         logging.debug(
-            'split_at_symlink(%s, %s) -> (%s, %s, %s)' %
-            (base_dir, relfile, base, symlink, rest))
+          "split_at_symlink(%s, %s) -> (%s, %s, %s)"
+          % (base_dir, relfile, base, symlink, rest)
+        )
         return base, symlink, rest
       if index == len(relfile):
         break
       index += 1
     return relfile, None, None
 
-
   def kill_children_processes(root):
     """Not yet implemented on posix."""
     # pylint: disable=unused-argument
@@ -531,7 +548,7 @@
   try:
     return os.path.relpath(filepath, basepath)
   except ValueError:
-    assert sys.platform == 'win32'
+    assert sys.platform == "win32"
     return filepath
 
 
@@ -549,14 +566,14 @@
   It is different from relpath() since it can be used on Windows.
   """
   out = posixpath.relpath(path, root)
-  if path.endswith('/'):
-    out += '/'
+  if path.endswith("/"):
+    out += "/"
   return out
 
 
 def is_url(path):
   """Returns True if it looks like an HTTP url instead of a file path."""
-  return bool(re.match(r'^https?://.+$', path))
+  return bool(re.match(r"^https?://.+$", path))
 
 
 def path_starts_with(prefix, path):
@@ -564,15 +581,16 @@
   initial components of |path| (or all of the components of |path|). The paths
   must be absolute.
   """
-  #assert os.path.isabs(prefix) and os.path.isabs(path)
+  # assert os.path.isabs(prefix) and os.path.isabs(path)
   prefix = os.path.normpath(prefix)
   path = os.path.normpath(path)
-  #assert prefix == get_native_path_case(prefix), prefix
-  #assert path == get_native_path_case(path), path
+  # assert prefix == get_native_path_case(prefix), prefix
+  # assert path == get_native_path_case(path), path
   prefix = prefix.rstrip(os.path.sep) + os.path.sep
   path = path.rstrip(os.path.sep) + os.path.sep
   return path.startswith(prefix)
 
+
 def ensure_command_has_abs_path(command, cwd):
   """Ensures that an isolate command uses absolute path.
 
@@ -590,12 +608,12 @@
   """
   assert os.path.isabs(path1), path1
   assert os.path.isabs(path2), path2
-  if sys.platform == 'win32':
+  if sys.platform == "win32":
     # If the drive letter mismatches, assume it's a separate partition.
     # TODO(maruel): It should look at the underlying drive, a drive letter could
     # be a mount point to a directory on another drive.
-    assert re.match(r'^[a-zA-Z]\:\\.*', path1), path1
-    assert re.match(r'^[a-zA-Z]\:\\.*', path2), path2
+    assert re.match(r"^[a-zA-Z]\:\\.*", path1), path1
+    assert re.match(r"^[a-zA-Z]\:\\.*", path2), path2
     if path1[0].lower() != path2[0].lower():
       return False
   return fs.stat(path1).st_dev == fs.stat(path2).st_dev
@@ -608,10 +626,11 @@
   user. On some systems, there's a percentage of the free space on the partition
   that is only accessible as the root user.
   """
-  if sys.platform == 'win32':
+  if sys.platform == "win32":
     free_bytes = ctypes.c_ulonglong(0)
     windll.kernel32.GetDiskFreeSpaceExW(
-        ctypes.c_wchar_p(path), None, None, ctypes.pointer(free_bytes))
+      ctypes.c_wchar_p(path), None, None, ctypes.pointer(free_bytes)
+    )
     return free_bytes.value
   # For OSes other than Windows.
   f = fs.statvfs(path)  # pylint: disable=E1101
@@ -628,9 +647,10 @@
   """
   assert isinstance(source, str), source
   assert isinstance(link_name, str), link_name
-  if sys.platform == 'win32':
+  if sys.platform == "win32":
     if not windll.kernel32.CreateHardLinkW(
-        fs.extend(link_name), fs.extend(source), 0):
+      fs.extend(link_name), fs.extend(source), 0
+    ):
       raise OSError()
   else:
     fs.link(source, link_name)
@@ -640,8 +660,9 @@
   """Makes a copy of the file that is readable by everyone."""
   fs.copy2(infile, outfile)
   fs.chmod(
-      outfile,
-      fs.stat(outfile).st_mode | stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH)
+    outfile,
+    fs.stat(outfile).st_mode | stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH,
+  )
 
 
 def set_read_only(path, read_only, orig_mode=None):
@@ -657,9 +678,9 @@
     mode &= stat.S_IRUSR | stat.S_IXUSR  # 0500
   else:
     mode |= stat.S_IRUSR | stat.S_IWUSR  # 0600
-    if sys.platform != 'win32' and stat.S_ISDIR(mode):
+    if sys.platform != "win32" and stat.S_ISDIR(mode):
       mode |= stat.S_IXUSR  # 0100
-  if hasattr(os, 'lchmod'):
+  if hasattr(os, "lchmod"):
     fs.lchmod(path, mode)  # pylint: disable=E1101
   else:
     if stat.S_ISLNK(orig_mode):
@@ -683,7 +704,7 @@
   """Removes a file, even if it is read-only."""
   # TODO(maruel): Not do it unless necessary since it slows this function
   # down.
-  if sys.platform == 'win32':
+  if sys.platform == "win32":
     # Deleting a read-only file will fail if it is read-only.
     set_read_only(filepath, False)
   else:
@@ -712,14 +733,15 @@
     True if the action was carried on, False if fallback was used.
   """
   if action < 1 or action > COPY:
-    raise ValueError('Unknown mapping action %s' % action)
+    raise ValueError("Unknown mapping action %s" % action)
   # TODO(maruel): Skip these checks.
   if not fs.isfile(infile):
-    raise OSError('%s is missing' % infile)
+    raise OSError("%s is missing" % infile)
   if fs.isfile(outfile):
     raise OSError(
-        '%s already exist; insize:%d; outsize:%d' %
-        (outfile, fs.stat(infile).st_size, fs.stat(outfile).st_size))
+      "%s already exist; insize:%d; outsize:%d"
+      % (outfile, fs.stat(infile).st_size, fs.stat(outfile).st_size)
+    )
 
   if action == COPY:
     readable_copy(outfile, infile)
@@ -733,8 +755,8 @@
       if action == SYMLINK:
         raise
       logging.warning(
-          'Failed to symlink, falling back to copy %s to %s' % (
-            infile, outfile))
+        "Failed to symlink, falling back to copy %s to %s" % (infile, outfile)
+      )
       # Signal caller that fallback copy was used.
       readable_copy(outfile, infile)
       return False
@@ -745,12 +767,12 @@
     return True
   except OSError as e:
     if action == HARDLINK:
-      raise OSError('Failed to hardlink %s to %s: %s' % (infile, outfile, e))
+      raise OSError("Failed to hardlink %s to %s: %s" % (infile, outfile, e))
 
   # Probably a different file system.
   logging.warning(
-      'Failed to hardlink, falling back to copy %s to %s' % (
-        infile, outfile))
+    "Failed to hardlink, falling back to copy %s to %s" % (infile, outfile)
+  )
   readable_copy(outfile, infile)
   # Signal caller that fallback copy was used.
   return False
@@ -771,26 +793,28 @@
   path = os.path.abspath(path)
   dir_name, base_name = os.path.split(path)
 
-  fd, tmp_name = tempfile.mkstemp(dir=dir_name, prefix=base_name+'_')
+  fd, tmp_name = tempfile.mkstemp(dir=dir_name, prefix=base_name + "_")
   try:
-    with os.fdopen(fd, 'wb') as f:
+    with os.fdopen(fd, "wb") as f:
       f.write(body)
       f.flush()
       os.fsync(fd)
-    if sys.platform != 'win32':
+    if sys.platform != "win32":
       os.rename(tmp_name, path)
     else:
       # Flags are MOVEFILE_REPLACE_EXISTING|MOVEFILE_WRITE_THROUGH.
       MoveFileEx(tmp_name, path, 0x1 | 0x8)
-    tmp_name = None # no need to remove it in 'finally' block anymore
+    tmp_name = None  # no need to remove it in 'finally' block anymore
   finally:
     if tmp_name:
       try:
         os.remove(tmp_name)
       except OSError as e:
         logging.warning(
-            'Failed to delete temp file %s in replace_file_content: %s',
-            tmp_name, e)
+          "Failed to delete temp file %s in replace_file_content: %s",
+          tmp_name,
+          e,
+        )
 
 
 ### Write directory functions.
@@ -809,7 +833,7 @@
 
 def create_directories(base_directory, files):
   """Creates the directory structure needed by the given list of files."""
-  logging.debug('create_directories(%s, %d)', base_directory, len(files))
+  logging.debug("create_directories(%s, %d)", base_directory, len(files))
   # Creates the tree of directories to create.
   directories = set(os.path.dirname(f) for f in files)
   for item in list(directories):
@@ -829,13 +853,13 @@
 
   This means files can be created or deleted.
   """
-  logging.debug('make_tree_files_read_only(%s)', root)
-  if sys.platform != 'win32':
+  logging.debug("make_tree_files_read_only(%s)", root)
+  if sys.platform != "win32":
     set_read_only(root, False)
   for dirpath, dirnames, filenames in fs.walk(root, topdown=True):
     for filename in filenames:
       set_read_only(os.path.join(dirpath, filename), True)
-    if sys.platform != 'win32':
+    if sys.platform != "win32":
       # It must not be done on Windows.
       for dirname in dirnames:
         set_read_only(os.path.join(dirpath, dirname), False)
@@ -852,14 +876,14 @@
   modified. This means that for hard-linked files, every directory entry for the
   file node has its file permission modified.
   """
-  if sys.platform == 'win32':
+  if sys.platform == "win32":
     make_tree_deleteable_win(root)
   else:
     make_tree_deleteable_posix(root)
 
 
 def make_tree_deleteable_win(root):
-  logging.debug('Using file_path.make_tree_deleteable_win')
+  logging.debug("Using file_path.make_tree_deleteable_win")
   err = None
 
   dirs = deque([root])
@@ -879,7 +903,7 @@
 
 
 def make_tree_deleteable_posix(root):
-  logging.debug('Using file_path.make_tree_deleteable_posix')
+  logging.debug("Using file_path.make_tree_deleteable_posix")
   err = None
   sudo_failed = False
 
@@ -888,10 +912,10 @@
       return True
     # Try passwordless sudo, just in case. In practice, it is preferable
     # to use linux capabilities.
-    with open(os.devnull, 'rb') as f:
-      if not subprocess42.call(['sudo', '-n', 'chmod', 'a+rwX,-t', p], stdin=f):
+    with open(os.devnull, "rb") as f:
+      if not subprocess42.call(["sudo", "-n", "chmod", "a+rwX,-t", p], stdin=f):
         return False
-    logging.debug('sudo chmod %s failed', p)
+    logging.debug("sudo chmod %s failed", p)
     return True
 
   e = set_read_only_swallow(root, False)
@@ -924,110 +948,127 @@
 
   Raises an exception if it failed.
   """
-  logging.info('file_path.rmtree(%s)', root)
+  logging.info("file_path.rmtree(%s)", root)
   assert isinstance(root, str), repr(root)
 
   def change_tree_permission():
-    logging.debug('file_path.make_tree_deleteable(%s) starting', root)
+    logging.debug("file_path.make_tree_deleteable(%s) starting", root)
     start = time.time()
     try:
       make_tree_deleteable(root)
     except OSError as e:
-      logging.warning('Swallowing make_tree_deleteable() error: %s', e)
-    logging.debug('file_path.make_tree_deleteable(%s) took %s seconds', root,
-                  time.time() - start)
+      logging.warning("Swallowing make_tree_deleteable() error: %s", e)
+    logging.debug(
+      "file_path.make_tree_deleteable(%s) took %s seconds",
+      root,
+      time.time() - start,
+    )
 
   # First try the soft way: tries 3 times to delete and sleep a bit in between.
   # On Windows, try 6 times with a total of up to 30 seconds of sleep.
   # Retries help if test subprocesses outlive main process and try to actively
   # use or write to the directory while it is being deleted.
-  max_tries = 6 if sys.platform == 'win32' else 3
+  max_tries = 6 if sys.platform == "win32" else 3
   has_called_change_tree_permission = False
   has_called_change_acl_for_delete = False
   for i in range(max_tries):
     # pylint: disable=cell-var-from-loop
     # errors is a list of tuple(function, path, excinfo).
     errors = []
-    logging.debug('file_path.rmtree(%s) try=%d', root, i)
+    logging.debug("file_path.rmtree(%s) try=%d", root, i)
     start = time.time()
     fs.rmtree(root, onerror=lambda *args: errors.append(args))
-    logging.debug('file_path.rmtree(%s) try=%d took %s seconds', root, i,
-                  time.time() - start)
+    logging.debug(
+      "file_path.rmtree(%s) try=%d took %s seconds",
+      root,
+      i,
+      time.time() - start,
+    )
     if not errors or not fs.exists(root):
       if i:
-        logging.debug('Succeeded.\n')
+        logging.debug("Succeeded.\n")
       return
 
     # Try to change tree permission.
     if not has_called_change_tree_permission:
       logging.warning(
-          'Failed to delete %s (%d files remaining).\n'
-          '  Maybe tree permission needs to be changed.\n', root, len(errors))
+        "Failed to delete %s (%d files remaining).\n"
+        "  Maybe tree permission needs to be changed.\n",
+        root,
+        len(errors),
+      )
       change_tree_permission()
       has_called_change_tree_permission = True
       # do not sleep here.
       continue
 
     # Try change_acl_for_delete on Windows.
-    if not has_called_change_acl_for_delete and sys.platform == 'win32':
+    if not has_called_change_acl_for_delete and sys.platform == "win32":
       for path in sorted(set(path for _, path, _ in errors)):
         try:
           change_acl_for_delete(path)
         except Exception as e:
-          logging.error('- %s (failed to update ACL: %s)\n', path, e)
+          logging.error("- %s (failed to update ACL: %s)\n", path, e)
       has_called_change_acl_for_delete = True
 
     if i < max_tries - 1:
-      delay = (i+1)*2
+      delay = (i + 1) * 2
       logging.warning(
-          'Failed to delete %s (%d files remaining).\n'
-          '  Maybe the test has a subprocess outliving it.\n'
-          '  Sleeping %d seconds.\n', root, len(errors), delay)
+        "Failed to delete %s (%d files remaining).\n"
+        "  Maybe the test has a subprocess outliving it.\n"
+        "  Sleeping %d seconds.\n",
+        root,
+        len(errors),
+        delay,
+      )
       time.sleep(delay)
 
-  logging.error('Failed to delete %s. The following files remain:\n', root)
+  logging.error("Failed to delete %s. The following files remain:\n", root)
   # The same path may be listed multiple times.
   for path in sorted(set(path for _, path, _ in errors)):
-    logging.error('- %s\n', path)
+    logging.error("- %s\n", path)
 
   # If soft retries fail on Linux, there's nothing better we can do.
-  if sys.platform != 'win32':
+  if sys.platform != "win32":
     raise errors[0][2][1]
 
   # The soft way was not good enough. Try the hard way.
   start = time.time()
-  logging.debug('file_path.rmtree(%s) killing children processes', root)
+  logging.debug("file_path.rmtree(%s) killing children processes", root)
   for i in range(max_tries):
     if not kill_children_processes(root):
       break
     if i != max_tries - 1:
-      time.sleep((i+1)*2)
+      time.sleep((i + 1) * 2)
   else:
     processes = _get_children_processes_win(root)
     if processes:
-      logging.error('Failed to terminate processes.\n')
+      logging.error("Failed to terminate processes.\n")
       raise errors[0][2][1]
   logging.debug(
-      'file_path.rmtree(%s) killing children processes took %d seconds', root,
-      time.time() - start)
+    "file_path.rmtree(%s) killing children processes took %d seconds",
+    root,
+    time.time() - start,
+  )
 
   # Now that annoying processes in root are evicted, try again.
   start = time.time()
   errors = []
-  logging.debug('file_path.rmtree(%s) final try', root)
+  logging.debug("file_path.rmtree(%s) final try", root)
   fs.rmtree(root, onerror=lambda *args: errors.append(args))
-  logging.debug('file_path.rmtree(%s) final try took %d seconds', root,
-                time.time() - start)
+  logging.debug(
+    "file_path.rmtree(%s) final try took %d seconds", root, time.time() - start
+  )
   if not errors or not fs.exists(root):
-    logging.debug('Succeeded at final try.\n')
+    logging.debug("Succeeded at final try.\n")
     return
 
   # There's no hope: the directory was tried to be removed 4 times. Give up
   # and raise an exception.
-  logging.error('Failed to delete %s. The following files remain:\n', root)
+  logging.error("Failed to delete %s. The following files remain:\n", root)
   # The same path may be listed multiple times.
   for path in sorted(set(path for _, path, _ in errors)):
-    logging.error('- %s\n', path)
+    logging.error("- %s\n", path)
   raise errors[0][2][1]
 
 
@@ -1040,15 +1081,22 @@
   start = time.time()
   try:
     total, n_dirs, n_files, n_links, n_others = _get_recur_size_with_scandir(
-        path)
+      path
+    )
     elapsed = time.time() - start
     logging.debug(
-        '_get_recursive_size: traversed %s took %s seconds. '
-        'files: %d, links: %d, dirs: %d, others: %d', path, elapsed, n_files,
-        n_links, n_dirs, n_others)
+      "_get_recursive_size: traversed %s took %s seconds. "
+      "files: %d, links: %d, dirs: %d, others: %d",
+      path,
+      elapsed,
+      n_files,
+      n_links,
+      n_dirs,
+      n_others,
+    )
     return total
   except (IOError, OSError, UnicodeEncodeError):
-    logging.exception('Exception while getting the size of %s', path)
+    logging.exception("Exception while getting the size of %s", path)
     return None
 
 
@@ -1058,12 +1106,13 @@
 def _is_symlink_entry(entry):
   if entry.is_symlink():
     return True
-  if sys.platform != 'win32':
+  if sys.platform != "win32":
     return False
   # both st_file_attributes and FILE_ATTRIBUTE_REPARSE_POINT are
   # windows-only symbols.
-  return bool(entry.stat().st_file_attributes
-              & stat.FILE_ATTRIBUTE_REPARSE_POINT)
+  return bool(
+    entry.stat().st_file_attributes & stat.FILE_ATTRIBUTE_REPARSE_POINT
+  )
 
 
 def _get_recur_size_with_scandir(path):
@@ -1087,7 +1136,7 @@
           stack.append(entry.path)
         else:
           n_others += 1
-          logging.warning('non directory/file entry: %s', entry)
+          logging.warning("non directory/file entry: %s", entry)
     except (PermissionError, FileNotFoundError):
-      logging.warning('Failed to scan directory', exc_info=True)
+      logging.warning("Failed to scan directory", exc_info=True)
   return total, n_dirs, n_files, n_links, n_others
diff --git a/utils/fs.py b/utils/fs.py
index 0bedb08..9d3db39 100644
--- a/utils/fs.py
+++ b/utils/fs.py
@@ -13,15 +13,17 @@
 import subprocess
 import sys
 
-if sys.platform == 'win32':
+if sys.platform == "win32":
   import ctypes
   from ctypes import wintypes
   from ctypes import windll
 
-
   CreateSymbolicLinkW = windll.kernel32.CreateSymbolicLinkW
   CreateSymbolicLinkW.argtypes = (
-      wintypes.LPCWSTR, wintypes.LPCWSTR, wintypes.DWORD)
+    wintypes.LPCWSTR,
+    wintypes.LPCWSTR,
+    wintypes.DWORD,
+  )
   CreateSymbolicLinkW.restype = wintypes.BOOL
   DeleteFile = windll.kernel32.DeleteFileW
   DeleteFile.argtypes = (wintypes.LPCWSTR,)
@@ -34,9 +36,15 @@
   RemoveDirectory.restype = wintypes.BOOL
   DeviceIoControl = windll.kernel32.DeviceIoControl
   DeviceIoControl.argtypes = (
-      wintypes.HANDLE, wintypes.DWORD, wintypes.LPVOID, wintypes.DWORD,
-      wintypes.LPVOID, wintypes.DWORD, ctypes.POINTER(wintypes.DWORD),
-      wintypes.LPVOID)
+    wintypes.HANDLE,
+    wintypes.DWORD,
+    wintypes.LPVOID,
+    wintypes.DWORD,
+    wintypes.LPVOID,
+    wintypes.DWORD,
+    ctypes.POINTER(wintypes.DWORD),
+    wintypes.LPVOID,
+  )
   DeviceIoControl.restype = wintypes.BOOL
 
   # It's *much* faster to temporarily waste 32Kb of memory than call
@@ -46,37 +54,37 @@
 
   class _SYMBOLIC_LINK_REPARSE_BUFFER(ctypes.Structure):
     _fields_ = (
-      ('SubstituteNameOffset', wintypes.USHORT),
-      ('SubstituteNameLength', wintypes.USHORT),
-      ('PrintNameOffset', wintypes.USHORT),
-      ('PrintNameLength', wintypes.USHORT),
-      ('Flags', wintypes.ULONG),
-      ('PathBuffer', wintypes.WCHAR * _MAX_WIN_PATH_LENGTH),
+      ("SubstituteNameOffset", wintypes.USHORT),
+      ("SubstituteNameLength", wintypes.USHORT),
+      ("PrintNameOffset", wintypes.USHORT),
+      ("PrintNameLength", wintypes.USHORT),
+      ("Flags", wintypes.ULONG),
+      ("PathBuffer", wintypes.WCHAR * _MAX_WIN_PATH_LENGTH),
     )
 
   class _MOUNT_POINT_REPARSE_BUFFER(ctypes.Structure):
     _fields_ = (
-      ('SubstituteNameOffset', wintypes.USHORT),
-      ('SubstituteNameLength', wintypes.USHORT),
-      ('PrintNameOffset', wintypes.USHORT),
-      ('PrintNameLength', wintypes.USHORT),
-      ('PathBuffer', wintypes.WCHAR * _MAX_WIN_PATH_LENGTH),
+      ("SubstituteNameOffset", wintypes.USHORT),
+      ("SubstituteNameLength", wintypes.USHORT),
+      ("PrintNameOffset", wintypes.USHORT),
+      ("PrintNameLength", wintypes.USHORT),
+      ("PathBuffer", wintypes.WCHAR * _MAX_WIN_PATH_LENGTH),
     )
 
   class _REPARSE_BUFFER(ctypes.Union):
     _fields_ = (
-      ('SymbolicLinkReparseBuffer', _SYMBOLIC_LINK_REPARSE_BUFFER),
-      ('MountPointReparseBuffer', _MOUNT_POINT_REPARSE_BUFFER),
+      ("SymbolicLinkReparseBuffer", _SYMBOLIC_LINK_REPARSE_BUFFER),
+      ("MountPointReparseBuffer", _MOUNT_POINT_REPARSE_BUFFER),
     )
 
   # https://msdn.microsoft.com/en-us/data/ff552012(v=vs.96)
   class REPARSE_DATA_BUFFER(ctypes.Structure):
     _fields_ = (
       # A bitpacked value.
-      ('ReparseTag', wintypes.DWORD),
-      ('ReparseDataLength', wintypes.WORD),
-      ('Reserved', wintypes.WORD),
-      ('ReparseBuffer', _REPARSE_BUFFER),
+      ("ReparseTag", wintypes.DWORD),
+      ("ReparseDataLength", wintypes.WORD),
+      ("Reserved", wintypes.WORD),
+      ("ReparseBuffer", _REPARSE_BUFFER),
     )
 
   # Flags for GetFileAttributesW().
@@ -98,17 +106,15 @@
   SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE = 2
 
   # Flag for DeviceIoControl().
-  FSCTL_GET_REPARSE_POINT = 0x900a8
+  FSCTL_GET_REPARSE_POINT = 0x900A8
 
   # https://msdn.microsoft.com/en-us/library/dd541667.aspx
-  IO_REPARSE_TAG_MOUNT_POINT = 0xa0000003
-  IO_REPARSE_TAG_SYMLINK = 0xa000000c
-
+  IO_REPARSE_TAG_MOUNT_POINT = 0xA0000003
+  IO_REPARSE_TAG_SYMLINK = 0xA000000C
 
   # Set to true or false once symlink support is initialized.
   _SUPPORTS_SYMLINKS = None
 
-
   def _supports_unprivileged_symlinks():
     """Returns True if the OS supports sane symlinks without any user privilege
     modification.
@@ -132,8 +138,8 @@
     # - Win10: Microsoft Windows [Version 10.0.10240]
     # - Win7 or Win2K8R2: Microsoft Windows [Version 6.1.7601]
     try:
-      out = subprocess.check_output(['cmd.exe', '/c', 'ver'], text=True).strip()
-      match = re.search(r'\[Version (\d+\.\d+)\.(\d+)\]', out, re.IGNORECASE)
+      out = subprocess.check_output(["cmd.exe", "/c", "ver"], text=True).strip()
+      match = re.search(r"\[Version (\d+\.\d+)\.(\d+)\]", out, re.IGNORECASE)
       if match:
         # That's a bit gross but good enough.
         major = float(match.group(1))
@@ -147,27 +153,24 @@
       pass
     return _SUPPORTS_SYMLINKS
 
-
   def extend(path):
     """Adds '\\\\?\\' when given an absolute path so the MAX_PATH (260) limit is
     not enforced.
     """
     assert os.path.isabs(path), path
     assert isinstance(path, str), "%s, type: %s" % (path, type(path))
-    prefix = '\\\\?\\'
+    prefix = "\\\\?\\"
     return path if path.startswith(prefix) else prefix + path
 
-
   def trim(path):
     """Removes '\\\\?\\' when receiving a path."""
     assert isinstance(path, str), "%s, type: %s" % (path, type(path))
-    prefix = '\\\\?\\'
+    prefix = "\\\\?\\"
     if path.startswith(prefix):
-      path = path[len(prefix):]
+      path = path[len(prefix) :]
     assert os.path.isabs(path), path
     return path
 
-
   def islink(path):
     """Proper implementation of islink() for Windows.
 
@@ -183,7 +186,6 @@
       return False
     return bool(res & FILE_ATTRIBUTE_REPARSE_POINT)
 
-
   def symlink(source, link_name):
     """Creates a symlink on Windows 7 and later.
 
@@ -206,7 +208,8 @@
     real_source = source
     if not os.path.isabs(source):
       real_source = extend(
-          os.path.normpath(os.path.join(os.path.dirname(link_name), source)))
+        os.path.normpath(os.path.join(os.path.dirname(link_name), source))
+      )
     # pylint: disable=undefined-variable
     # isdir is generated dynamically.
     flags = SYMBOLIC_LINK_FLAG_DIRECTORY if isdir(real_source) else 0
@@ -225,11 +228,15 @@
       err = ctypes.GetLastError()
       if err == 1314:
         raise WindowsError(
-            ('symlink(%r, %r) failed: ERROR_PRIVILEGE_NOT_HELD(1314). Try '
-             'calling file_path.enable_symlink() first') % (source, link_name))
-      raise WindowsError('symlink(%r, %r) failed: %s' %
-                         (source, link_name, err))
-
+          (
+            "symlink(%r, %r) failed: ERROR_PRIVILEGE_NOT_HELD(1314). Try "
+            "calling file_path.enable_symlink() first"
+          )
+          % (source, link_name)
+        )
+      raise WindowsError(
+        "symlink(%r, %r) failed: %s" % (source, link_name, err)
+      )
 
   def remove(path):
     """Removes a symlink on Windows 7 and later.
@@ -253,41 +260,54 @@
     if isdir(path):
       if not RemoveDirectory(path):
         # pylint: disable=undefined-variable
-        raise WindowsError('unlink(%r): could not remove directory: %s' %
-                           (path, ctypes.GetLastError()))
+        raise WindowsError(
+          "unlink(%r): could not remove directory: %s"
+          % (path, ctypes.GetLastError())
+        )
     else:
       if DeleteFile(path):
         return
-      logging.warning('failed to call DeleteFile(%r): win error: %s', path,
-                      ctypes.GetLastError())
+      logging.warning(
+        "failed to call DeleteFile(%r): win error: %s",
+        path,
+        ctypes.GetLastError(),
+      )
 
       # fallback to unlink if it fails to call DeleteFile.
       os.unlink(path)
 
-
   def readlink(path):
     """Reads a symlink on Windows."""
     # Interestingly, when using FILE_FLAG_OPEN_REPARSE_POINT and the destination
     # is not a reparse point, the actual file will be opened. It's the
     # DeviceIoControl() below that will fail with 4390.
     handle = windll.kernel32.CreateFileW(
-        extend(path),
-        FILE_READ_EA,
-        FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
-        None,
-        OPEN_ALWAYS,
-        FILE_FLAG_BACKUP_SEMANTICS|FILE_FLAG_OPEN_REPARSE_POINT,
-        None)
+      extend(path),
+      FILE_READ_EA,
+      FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+      None,
+      OPEN_ALWAYS,
+      FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT,
+      None,
+    )
     if handle == INVALID_HANDLE_VALUE:
       # pylint: disable=undefined-variable
-      raise WindowsError('readlink(%r): failed to open: %s' %
-                         (path, ctypes.GetLastError()))
+      raise WindowsError(
+        "readlink(%r): failed to open: %s" % (path, ctypes.GetLastError())
+      )
     try:
       buf = REPARSE_DATA_BUFFER()
       returned = wintypes.DWORD()
       ret = DeviceIoControl(
-          handle, FSCTL_GET_REPARSE_POINT, None, 0, ctypes.byref(buf),
-          ctypes.sizeof(buf), ctypes.byref(returned), None)
+        handle,
+        FSCTL_GET_REPARSE_POINT,
+        None,
+        0,
+        ctypes.byref(buf),
+        ctypes.sizeof(buf),
+        ctypes.byref(returned),
+        None,
+      )
       if not ret:
         err = ctypes.GetLastError()
         # ERROR_MORE_DATA(234) should not happen because we preallocate the
@@ -295,25 +315,25 @@
         if err == 4390:
           # pylint: disable=undefined-variable
           raise WindowsError(
-              'readlink(%r): failed to read: ERROR_NOT_A_REPARSE_POINT(4390)' %
-              path)
+            "readlink(%r): failed to read: ERROR_NOT_A_REPARSE_POINT(4390)"
+            % path
+          )
         # pylint: disable=undefined-variable
-        raise WindowsError('readlink(%r): failed to read: %s' % (path, err))
+        raise WindowsError("readlink(%r): failed to read: %s" % (path, err))
       if buf.ReparseTag == IO_REPARSE_TAG_SYMLINK:
         actual = buf.ReparseBuffer.SymbolicLinkReparseBuffer
       elif buf.ReparseTag == IO_REPARSE_TAG_MOUNT_POINT:
         actual = buf.ReparseBuffer.MountPointReparseBuffer
       else:
         raise WindowsError(  # pylint: disable=undefined-variable
-            'readlink(%r): succeeded but doesn\'t know how to parse result!' %
-            path)
+          "readlink(%r): succeeded but doesn't know how to parse result!" % path
+        )
       off = actual.PrintNameOffset // 2
       end = off + actual.PrintNameLength // 2
       return actual.PathBuffer[off:end]
     finally:
       windll.kernel32.CloseHandle(handle)
 
-
   def walk(top, topdown=True, onerror=None, followlinks=False):
     # We need to reimplement walk() here because the standard library ignores
     # the flag followlinks=False. This is because ntpath.islink() is hardcoded
@@ -328,7 +348,7 @@
 
     dirs, nondirs = [], []
     for name in names:
-      if isdir(os.path.join(top, name)):   # pylint: disable=undefined-variable
+      if isdir(os.path.join(top, name)):  # pylint: disable=undefined-variable
         dirs.append(name)
       else:
         nondirs.append(name)
@@ -346,38 +366,31 @@
 
 else:
 
-
   def extend(path):
     """Path extending is not needed on POSIX."""
     assert os.path.isabs(path), path
     assert isinstance(path, str), "%s, type: %s" % (path, type(path))
     return path
 
-
   def trim(path):
     """Path mangling is not needed on POSIX."""
     assert os.path.isabs(path), path
     assert isinstance(path, str), "%s, type: %s" % (path, type(path))
     return path
 
-
   def islink(path):
     return os.path.islink(extend(path))
 
-
   def symlink(source, link_name):
     return os.symlink(source, extend(link_name))
 
-
   def readlink(path):
     return os.readlink(extend(path))
 
-
   def walk(top, *args, **kwargs):
     for root, dirs, files in os.walk(extend(top), *args, **kwargs):
       yield trim(root), dirs, files
 
-
   def remove(path):
     return os.remove(extend(path))
 
@@ -427,26 +440,53 @@
 
 
 def _is_path_fn(func):
-  return (inspect.getargspec(func)[0] or [None]) == 'path'
+  return (inspect.getargspec(func)[0] or [None]) == "path"
 
 
 _os_fns = (
-  'access', 'chdir', 'chflags', 'chroot', 'chmod', 'chown', 'lchflags',
-  'lchmod', 'lchown', 'listdir', 'lstat', 'mknod', 'mkdir', 'makedirs',
-  'removedirs', 'rmdir', 'stat', 'statvfs', 'utime')
+  "access",
+  "chdir",
+  "chflags",
+  "chroot",
+  "chmod",
+  "chown",
+  "lchflags",
+  "lchmod",
+  "lchown",
+  "listdir",
+  "lstat",
+  "mknod",
+  "mkdir",
+  "makedirs",
+  "removedirs",
+  "rmdir",
+  "stat",
+  "statvfs",
+  "utime",
+)
 
 _os_path_fns = (
-  'exists', 'lexists', 'getatime', 'getmtime', 'getctime', 'getsize', 'isfile',
-  'isdir', 'ismount')
+  "exists",
+  "lexists",
+  "getatime",
+  "getmtime",
+  "getctime",
+  "getsize",
+  "isfile",
+  "isdir",
+  "ismount",
+)
 
 
 for _fn in _os_fns:
   if hasattr(os, _fn):
     sys.modules[__name__].__dict__.setdefault(
-        _fn, _get_lambda(getattr(os, _fn)))
+      _fn, _get_lambda(getattr(os, _fn))
+    )
 
 
 for _fn in _os_path_fns:
   if hasattr(os.path, _fn):
     sys.modules[__name__].__dict__.setdefault(
-        _fn, _get_lambda(getattr(os.path, _fn)))
+      _fn, _get_lambda(getattr(os.path, _fn))
+    )
diff --git a/utils/graph.py b/utils/graph.py
index 918506a..13a7fa1 100644
--- a/utils/graph.py
+++ b/utils/graph.py
@@ -9,14 +9,14 @@
 import colorama
 
 
-UNITS = ('', 'k', 'm', 'g', 't', 'p', 'e', 'z', 'y')
+UNITS = ("", "k", "m", "g", "t", "p", "e", "z", "y")
 
 
 def get_console_width(default=80):
   """Returns the console width, if available."""
   # TODO(maruel): Implement Windows.
   try:
-    _, columns = os.popen('stty size', 'r').read().split()
+    _, columns = os.popen("stty size", "r").read().split()
   except (IOError, OSError, ValueError):
     columns = default
   return int(columns)
@@ -39,11 +39,11 @@
     return {data[0]: len(data)}
 
   buckets = min(len(data), buckets)
-  bucket_size = (maximum-minimum)/buckets
+  bucket_size = (maximum - minimum) / buckets
   out = dict((i, 0) for i in range(buckets))
   for i in data:
-    out[min(int((i-minimum)/bucket_size), buckets-1)] += 1
-  return dict(((k*bucket_size)+minimum, v) for k, v in out.items())
+    out[min(int((i - minimum) / bucket_size), buckets - 1)] += 1
+  return dict(((k * bucket_size) + minimum, v) for k, v in out.items())
 
 
 def print_histogram(data, columns=0, key_format=None):
@@ -60,7 +60,7 @@
     return
 
   columns = columns or get_console_width()
-  key_format = key_format or '%s'
+  key_format = key_format or "%s"
 
   max_key_width = max(len(key_format % k) for k in data)
   # 3 == 1 for ' ' prefix, 2 for ': ' suffix.
@@ -72,9 +72,9 @@
     width = maxvalue
   norm = float(maxvalue) / width
 
-  form = '%s: %s%s%s'
+  form = "%s: %s%s%s"
   for k in sorted(data):
-    line = '*' * int(data[k] / norm)
+    line = "*" * int(data[k] / norm)
     key = (key_format % k).rjust(max_key_width)
     print(form % (key, colorama.Fore.GREEN, line, colorama.Fore.RESET))
 
@@ -82,14 +82,14 @@
 def to_units(number):
   """Convert a string to numbers."""
   unit = 0
-  while number >= 1024.:
+  while number >= 1024.0:
     unit += 1
-    number = number / 1024.
+    number = number / 1024.0
     if unit == len(UNITS) - 1:
       break
   if unit:
-    return '%.2f%s' % (number, UNITS[unit])
-  return '%d' % number
+    return "%.2f%s" % (number, UNITS[unit])
+  return "%d" % number
 
 
 def from_units(text):
@@ -97,25 +97,31 @@
 
   Example: from_unit('0.1k') == 102
   """
-  match = re.match(r'^([0-9\.]+)(|[' + ''.join(UNITS[1:]) + r'])$', text)
+  match = re.match(r"^([0-9\.]+)(|[" + "".join(UNITS[1:]) + r"])$", text)
   if not match:
     return None
 
   number = float(match.group(1))
   unit = match.group(2)
-  return int(number * 1024**UNITS.index(unit))
+  return int(number * 1024 ** UNITS.index(unit))
 
 
 def unit_arg(option, opt, value, parser):
   """OptionParser callback that supports units like 10.5m or 20k."""
   actual = from_units(value)
   if actual is None:
-    parser.error('Invalid value \'%s\' for %s' % (value, opt))
+    parser.error("Invalid value '%s' for %s" % (value, opt))
   setattr(parser.values, option.dest, actual)
 
 
 def unit_option(parser, *args, **kwargs):
   """Add an option that uses unit_arg()."""
   parser.add_option(
-      *args, type='str', metavar='N', action='callback', callback=unit_arg,
-      nargs=1, **kwargs)
+    *args,
+    type="str",
+    metavar="N",
+    action="callback",
+    callback=unit_arg,
+    nargs=1,
+    **kwargs,
+  )
diff --git a/utils/logging_utils.py b/utils/logging_utils.py
index 879e03c..681faa9 100644
--- a/utils/logging_utils.py
+++ b/utils/logging_utils.py
@@ -29,7 +29,7 @@
 # the file in the parent process, it fails with:
 #     WindowsError: [Error 32] The process cannot access the file because
 #     it is being used by another process
-if sys.platform == 'win32':
+if sys.platform == "win32":
   import ctypes
   import msvcrt  # pylint: disable=F0401
 
@@ -44,7 +44,6 @@
   # TODO(maruel): Make it work in cygwin too if necessary. This would have to
   # use ctypes.cdll.kernel32 instead of msvcrt.
 
-
   def shared_open(path):
     """Opens a file with full sharing mode and without inheritance.
 
@@ -53,16 +52,16 @@
     See https://bugs.python.org/issue15244 for inspiration.
     """
     handle = ctypes.windll.kernel32.CreateFileW(
-        path,
-        GENERIC_READ|GENERIC_WRITE,
-        FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
-        None,
-        OPEN_ALWAYS,
-        FILE_ATTRIBUTE_NORMAL,
-        None)
+      path,
+      GENERIC_READ | GENERIC_WRITE,
+      FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+      None,
+      OPEN_ALWAYS,
+      FILE_ATTRIBUTE_NORMAL,
+      None,
+    )
     ctr_handle = msvcrt.open_osfhandle(handle, os.O_BINARY | os.O_NOINHERIT)
-    return os.fdopen(ctr_handle, 'r+b')
-
+    return os.fdopen(ctr_handle, "r+b")
 
   class NoInheritRotatingFileHandler(logging.handlers.RotatingFileHandler):
     def _open(self):
@@ -76,14 +75,13 @@
         # codecs.open(self.baseFilename, self.mode, self.encoding)
         info = codecs.lookup(self.encoding)
         f = codecs.StreamReaderWriter(
-            f, info.streamreader, info.streamwriter, 'replace')
+          f, info.streamreader, info.streamwriter, "replace"
+        )
         f.encoding = self.encoding
       return f
 
 
 else:  # Not Windows.
-
-
   NoInheritRotatingFileHandler = logging.handlers.RotatingFileHandler
 
 # INFO has a priority of 20
@@ -95,13 +93,15 @@
 
 class CaptureLogs:
   """Captures all the logs in a context."""
+
   def __init__(self, prefix, root=None):
-    handle, self._path = tempfile.mkstemp(prefix=prefix, suffix='.log')
+    handle, self._path = tempfile.mkstemp(prefix=prefix, suffix=".log")
     os.close(handle)
-    self._handler = logging.FileHandler(self._path, 'w')
+    self._handler = logging.FileHandler(self._path, "w")
     self._handler.setLevel(logging.DEBUG)
     formatter = UTCFormatter(
-        '%(process)d %(asctime)s: %(levelname)-5s %(message)s')
+      "%(process)d %(asctime)s: %(levelname)-5s %(message)s"
+    )
     self._handler.setFormatter(formatter)
     self._root = root or logging.getLogger()
     self._root.addHandler(self._handler)
@@ -115,10 +115,10 @@
     self._disconnect()
     assert self._path
     try:
-      with open(self._path, 'rb') as f:
+      with open(self._path, "rb") as f:
         return f.read()
     except IOError as e:
-      return 'Failed to read %s: %s' % (self._path, e)
+      return "Failed to read %s: %s" % (self._path, e)
 
   def close(self):
     """Closes and delete the log."""
@@ -127,7 +127,7 @@
       try:
         os.remove(self._path)
       except OSError as e:
-        logging.error('Failed to delete log file %s: %s', self._path, e)
+        logging.error("Failed to delete log file %s: %s", self._path, e)
       self._path = None
 
   def __enter__(self):
@@ -170,19 +170,20 @@
 def find_stderr(root=None):
   """Returns the logging.handler streaming to stderr, if any."""
   for log in (root or logging.getLogger()).handlers:
-    if getattr(log, 'stream', None) is sys.stderr:
+    if getattr(log, "stream", None) is sys.stderr:
       return log
 
 
 def new_rotating_file_handler(
-    filename,
-    utc_formatter=UTCFormatter(
-        '%(process)d %(asctime)s %(severity)s: %(message)s')):
+  filename,
+  utc_formatter=UTCFormatter(
+    "%(process)d %(asctime)s %(severity)s: %(message)s"
+  ),
+):
   file_path.ensure_tree(os.path.dirname(os.path.abspath(filename)))
-  rotating_file = NoInheritRotatingFileHandler(filename,
-                                               maxBytes=10 * 1024 * 1024,
-                                               backupCount=5,
-                                               encoding='utf-8')
+  rotating_file = NoInheritRotatingFileHandler(
+    filename, maxBytes=10 * 1024 * 1024, backupCount=5, encoding="utf-8"
+  )
   rotating_file.setLevel(logging.DEBUG)
   rotating_file.setFormatter(utc_formatter)
   rotating_file.addFilter(SeverityFilter())
@@ -201,12 +202,13 @@
   logger = root or logging.getLogger()
   if not logger:
     # Better print insanity than crash.
-    print('OMG NO ROOT', file=sys.stderr)
+    print("OMG NO ROOT", file=sys.stderr)
     return
   logger.setLevel(logging.DEBUG)
 
   utc_formatter = UTCFormatter(
-      '%(process)d %(asctime)s %(severity)s: %(message)s')
+    "%(process)d %(asctime)s %(severity)s: %(message)s"
+  )
 
   stderr = logging.StreamHandler()
   stderr.setFormatter(utc_formatter)
@@ -222,7 +224,7 @@
       logger.addHandler(new_rotating_file_handler(filename, utc_formatter))
     except Exception:
       # May happen on cygwin. Do not crash.
-      logging.exception('Failed to open %s', filename)
+      logging.exception("Failed to open %s", filename)
 
 
 def set_console_level(level, root=None):
@@ -230,7 +232,7 @@
   handler = find_stderr(root)
   if not handler:
     # Better print insanity than crash.
-    print('OMG NO STDERR', file=sys.stderr)
+    print("OMG NO STDERR", file=sys.stderr)
     return
   handler.setLevel(level)
 
@@ -268,7 +270,8 @@
 
   logging.addLevelName(USER_LOGS, "USER_LOGS")
   user_logs_formatter = UTCFormatter(
-      "swarming_bot_logs: %(asctime)s: %(message)s")
+    "swarming_bot_logs: %(asctime)s: %(message)s"
+  )
 
   stdout_handler = logging.StreamHandler(stream=sys.stdout)
   stdout_handler.setLevel(USER_LOGS)
@@ -292,22 +295,30 @@
   logger_root = None
 
   def __init__(self, verbose=0, log_file=None, **kwargs):
-    kwargs.setdefault('description', sys.modules['__main__'].__doc__)
+    kwargs.setdefault("description", sys.modules["__main__"].__doc__)
     optparse.OptionParser.__init__(self, **kwargs)
-    self.group_logging = optparse.OptionGroup(self, 'Logging')
+    self.group_logging = optparse.OptionGroup(self, "Logging")
     self.group_logging.add_option(
-        '-v', '--verbose',
-        action='count',
-        default=verbose,
-        help='Use multiple times to increase verbosity')
+      "-v",
+      "--verbose",
+      action="count",
+      default=verbose,
+      help="Use multiple times to increase verbosity",
+    )
     if self.enable_log_file:
       self.group_logging.add_option(
-          '-l', '--log-file',
-          default=log_file,
-          help='The name of the file to store rotating log details')
+        "-l",
+        "--log-file",
+        default=log_file,
+        help="The name of the file to store rotating log details",
+      )
       self.group_logging.add_option(
-          '--no-log', action='store_const', const='', dest='log_file',
-          help='Disable log file')
+        "--no-log",
+        action="store_const",
+        const="",
+        dest="log_file",
+        help="Disable log file",
+      )
 
   def parse_args(self, *args, **kwargs):
     # Make sure this group is always the last one.
@@ -316,7 +327,8 @@
     options, args = optparse.OptionParser.parse_args(self, *args, **kwargs)
     prepare_logging(self.enable_log_file and options.log_file, self.logger_root)
     set_console_level(
-        LEVELS[min(len(LEVELS) - 1, options.verbose)], self.logger_root)
+      LEVELS[min(len(LEVELS) - 1, options.verbose)], self.logger_root
+    )
 
     return options, args
 
@@ -328,27 +340,35 @@
   enable_log_file = True
 
   def __init__(self, verbose=0, log_file=None, **kwargs):
-    kwargs.setdefault('description', sys.modules['__main__'].__doc__)
-    kwargs.setdefault('conflict_handler', 'resolve')
+    kwargs.setdefault("description", sys.modules["__main__"].__doc__)
+    kwargs.setdefault("conflict_handler", "resolve")
     self.__verbose = verbose
     self.__log_file = log_file
     super(ArgumentParserWithLogging, self).__init__(**kwargs)
 
   def _add_logging_group(self):
-    group = self.add_argument_group('Logging')
+    group = self.add_argument_group("Logging")
     group.add_argument(
-        '-v', '--verbose',
-        action='count',
-        default=self.__verbose,
-        help='Use multiple times to increase verbosity')
+      "-v",
+      "--verbose",
+      action="count",
+      default=self.__verbose,
+      help="Use multiple times to increase verbosity",
+    )
     if self.enable_log_file:
       group.add_argument(
-          '-l', '--log-file',
-          default=self.__log_file,
-          help='The name of the file to store rotating log details')
+        "-l",
+        "--log-file",
+        default=self.__log_file,
+        help="The name of the file to store rotating log details",
+      )
       group.add_argument(
-          '--no-log', action='store_const', const='', dest='log_file',
-          help='Disable log file')
+        "--no-log",
+        action="store_const",
+        const="",
+        dest="log_file",
+        help="Disable log file",
+      )
 
   def parse_args(self, *args, **kwargs):
     # Make sure this group is always the last one.
@@ -357,6 +377,7 @@
     args = super(ArgumentParserWithLogging, self).parse_args(*args, **kwargs)
     prepare_logging(self.enable_log_file and args.log_file, self.logger_root)
     set_console_level(
-        LEVELS[min(len(LEVELS) - 1, args.verbose)], self.logger_root)
+      LEVELS[min(len(LEVELS) - 1, args.verbose)], self.logger_root
+    )
 
     return args
diff --git a/utils/lru.py b/utils/lru.py
index d9e8292..b907c5e 100644
--- a/utils/lru.py
+++ b/utils/lru.py
@@ -22,6 +22,7 @@
 
   Can also store its state as *.json file on disk.
   """
+
   @staticmethod
   def time_fn():
     """Called to determine current timestamp when adding an entry.
@@ -66,45 +67,53 @@
 
     try:
       json_state = None
-      with open(state_file, 'r') as f:
+      with open(state_file, "r") as f:
         json_state = f.read()
         state = json.loads(json_state)
     except (IOError, ValueError) as e:
       raise ValueError(
-          'Broken state file %s with "%s": %s' % (state_file, json_state, e))
+        'Broken state file %s with "%s": %s' % (state_file, json_state, e)
+      )
     if not isinstance(state, dict):
       raise ValueError(
-          'Broken state file %s, should be json object or list' % (state_file,))
-    state_ver = state.get('version')
+        "Broken state file %s, should be json object or list" % (state_file,)
+      )
+    state_ver = state.get("version")
     if state_ver != CURRENT_VERSION:
       raise ValueError(
-          'Unsupported state file %s, version is %s. '
-          'Latest supported is %d' % (state_file, state_ver, CURRENT_VERSION))
-    state_items = state.get('items')
+        "Unsupported state file %s, version is %s. "
+        "Latest supported is %d" % (state_file, state_ver, CURRENT_VERSION)
+      )
+    state_items = state.get("items")
     if not isinstance(state_items, list):
       raise ValueError(
-          'Broken state file %s, items should be json list' % (state_file,))
+        "Broken state file %s, items should be json list" % (state_file,)
+      )
     lru = cls()
     # Items are stored oldest to newest. Put them back in the same order.
     for item in state_items:
       if not isinstance(item, list) or len(item) != 2:
         raise ValueError(
-            'Broken state file %s, expecting pairs: %s' % (state_file, item))
+          "Broken state file %s, expecting pairs: %s" % (state_file, item)
+        )
       if not isinstance(item[1], list) or len(item[1]) != 2:
         raise ValueError(
-            'Broken state file %s, expecting second item to be a item: %s' % (
-              state_file, item))
+          "Broken state file %s, expecting second item to be a item: %s"
+          % (state_file, item)
+        )
       if not isinstance(item[1][1], (int, float)):
         raise ValueError(
-            'Broken state file %s, expecting second item of the second item '
-            'to be a number: %s' % (state_file, item))
+          "Broken state file %s, expecting second item of the second item "
+          "to be a number: %s" % (state_file, item)
+        )
 
     lru._items = collections.OrderedDict(state_items)
 
     # Check for duplicate keys.
     if len(lru) != len(state_items):
       raise ValueError(
-          'Broken state file %s, found duplicate keys' % (state_file,))
+        "Broken state file %s, found duplicate keys" % (state_file,)
+      )
 
     # Now state from the file corresponds to state in the memory.
     lru._dirty = False
@@ -115,12 +124,12 @@
     if not self._dirty:
       return False
 
-    with open(state_file, 'w') as f:
+    with open(state_file, "w") as f:
       contents = {
-          'version': CURRENT_VERSION,
-          'items': list(self._items.items()),
+        "version": CURRENT_VERSION,
+        "items": list(self._items.items()),
       }
-      json.dump(contents, f, sort_keys=True, separators=(',', ':'))
+      json.dump(contents, f, sort_keys=True, separators=(",", ":"))
 
     self._dirty = False
     return True
@@ -162,7 +171,7 @@
     # self._items.items() is slow if self._items has many items.
     for key in self._items:
       return (key, self._items[key])
-    raise KeyError('dictionary is empty')
+    raise KeyError("dictionary is empty")
 
   def pop_oldest(self):
     """Removes oldest item and returns it as (key, (value, timestamp)).
diff --git a/utils/net.py b/utils/net.py
index 57637b4..f074374 100644
--- a/utils/net.py
+++ b/utils/net.py
@@ -21,6 +21,7 @@
 import urllib.parse
 
 from utils import tools
+
 tools.force_local_third_party()
 
 # third_party/
@@ -47,29 +48,29 @@
 URL_OPEN_MAX_ATTEMPTS = 30
 
 # Default timeout when retrying.
-URL_OPEN_TIMEOUT = 6*60.
+URL_OPEN_TIMEOUT = 6 * 60.0
 
 # Default timeout when reading from open HTTP connection.
 URL_READ_TIMEOUT = 60
 
 # Content type for url encoded POST body.
-URL_ENCODED_FORM_CONTENT_TYPE = 'application/x-www-form-urlencoded'
+URL_ENCODED_FORM_CONTENT_TYPE = "application/x-www-form-urlencoded"
 # Content type for JSON body.
-JSON_CONTENT_TYPE = 'application/json; charset=UTF-8'
+JSON_CONTENT_TYPE = "application/json; charset=UTF-8"
 # Default content type for POST body.
 DEFAULT_CONTENT_TYPE = URL_ENCODED_FORM_CONTENT_TYPE
 
 # Content type -> function that encodes a request body.
 CONTENT_ENCODERS = {
-    URL_ENCODED_FORM_CONTENT_TYPE:
-        urllib.parse.urlencode,
-    JSON_CONTENT_TYPE:
-        lambda x: json.dumps(x, sort_keys=True, separators=(',', ':')),
+  URL_ENCODED_FORM_CONTENT_TYPE: urllib.parse.urlencode,
+  JSON_CONTENT_TYPE: lambda x: json.dumps(
+    x, sort_keys=True, separators=(",", ":")
+  ),
 }
 
 
 # Google Storage URL regular expression.
-GS_STORAGE_HOST_URL_RE = re.compile(r'https://(.+\.)?storage\.googleapis\.com')
+GS_STORAGE_HOST_URL_RE = re.compile(r"https://(.+\.)?storage\.googleapis\.com")
 
 # Global (for now) map: server URL (http://example.com) -> HttpService instance.
 # Used by get_http_service to cache HttpService instances.
@@ -113,7 +114,8 @@
   def __init__(self, response, inner_exc=None):
     assert isinstance(response, HttpResponse), response
     super(HttpError, self).__init__(
-        inner_exc or 'Server returned HTTP code %d' % response.code)
+      inner_exc or "Server returned HTTP code %d" % response.code
+    )
     self.response = response
     self._body_for_desc = None
 
@@ -132,39 +134,39 @@
       try:
         self._body_for_desc = self.response.read().decode()
       except Exception as exc:
-        self._body_for_desc = '<failed to read the response body: %s>' % exc
+        self._body_for_desc = "<failed to read the response body: %s>" % exc
 
     desc = str(self)
 
     # If the body is JSON, assume it is Cloud Endpoints response and fish out an
     # error message from it.
-    if self.response.content_type.startswith('application/json'):
+    if self.response.content_type.startswith("application/json"):
       msg = _fish_out_error_message(self._body_for_desc)
       if msg:
-        desc += ' - ' + msg
+        desc += " - " + msg
 
     if not verbose:
       return desc
 
-    out = [desc, '----------']
+    out = [desc, "----------"]
     if self.response.headers:
       for header, value in sorted(self.response.headers.items()):
-        if not header.lower().startswith('x-'):
-          out.append('%s: %s' % (header.capitalize(), value))
-      out.append('')
-    out.append(self._body_for_desc or '<empty body>')
-    out.append('----------')
-    return '\n'.join(out)
+        if not header.lower().startswith("x-"):
+          out.append("%s: %s" % (header.capitalize(), value))
+      out.append("")
+    out.append(self._body_for_desc or "<empty body>")
+    out.append("----------")
+    return "\n".join(out)
 
 
 def _fish_out_error_message(maybe_json_blob):
   try:
     as_json = json.loads(maybe_json_blob)
-    err = as_json.get('error')
+    err = as_json.get("error")
     if isinstance(err, str):
       return err
     if isinstance(err, dict):
-      return str(err.get('message') or '<no error message>')
+      return str(err.get("message") or "<no error message>")
   except (ValueError, KeyError, TypeError):
     pass
   return None  # not a JSON we recognize
@@ -247,7 +249,7 @@
   if not response:
     return False
   try:
-    with io.open(filepath, 'wb') as f:
+    with io.open(filepath, "wb") as f:
       for buf in response.iter_content(65536):
         f.write(buf)
     return True
@@ -262,25 +264,25 @@
 def split_server_request_url(url):
   """Splits the url into scheme+netloc and path+params+query+fragment."""
   url_parts = list(urllib.parse.urlparse(url))
-  urlhost = '%s://%s' % (url_parts[0], url_parts[1])
-  urlpath = urllib.parse.urlunparse(['', ''] + url_parts[2:])
+  urlhost = "%s://%s" % (url_parts[0], url_parts[1])
+  urlpath = urllib.parse.urlunparse(["", ""] + url_parts[2:])
   return urlhost, urlpath
 
 
 def fix_url(url):
   """Fixes an url to https."""
-  parts = urllib.parse.urlparse(url, 'https')
+  parts = urllib.parse.urlparse(url, "https")
   if parts.query:
-    raise ValueError('doesn\'t support query parameter.')
+    raise ValueError("doesn't support query parameter.")
   if parts.fragment:
-    raise ValueError('doesn\'t support fragment in the url.')
+    raise ValueError("doesn't support fragment in the url.")
   # urllib.parse.urlparse('foo.com') will result in netloc='', path='foo.com',
   # which is not what is desired here.
   new = list(parts)
   if not new[1] and new[2]:
-    new[1] = new[2].rstrip('/')
-    new[2] = ''
-  new[2] = new[2].rstrip('/')
+    new[1] = new[2].rstrip("/")
+    new[2] = ""
+  new[2] = new[2].rstrip("/")
   return urllib.parse.urlunparse(new)
 
 
@@ -288,6 +290,7 @@
   """Returns existing or creates new instance of HttpService that can send
   requests to given base urlhost.
   """
+
   def new_service():
     # Create separate authenticator only if engine is not providing
     # authentication already. Also we use signed URLs for Google Storage, no
@@ -298,16 +301,16 @@
     conf = get_oauth_config()
     if not engine_cls.provides_auth and not is_gs and not conf.disabled:
       authenticator = (
-          authenticators.LuciContextAuthenticator()
-          if conf.use_luci_context_auth else
-          authenticators.OAuthAuthenticator(urlhost, conf))
+        authenticators.LuciContextAuthenticator()
+        if conf.use_luci_context_auth
+        else authenticators.OAuthAuthenticator(urlhost, conf)
+      )
     return HttpService(
-        urlhost,
-        engine=engine_cls(),
-        authenticator=authenticator)
+      urlhost, engine=engine_cls(), authenticator=authenticator
+    )
 
   # Ensure consistency in url naming.
-  urlhost = str(urlhost).lower().rstrip('/')
+  urlhost = str(urlhost).lower().rstrip("/")
 
   if not allow_cached:
     return new_service()
@@ -354,15 +357,15 @@
   """
   normalized = structures.CaseInsensitiveDict(original or {})
   if len(normalized) != len(original):
-    raise ValueError('Duplicate keys in: %s' % repr(original))
+    raise ValueError("Duplicate keys in: %s" % repr(original))
   return normalized
 
 
 class HttpService:
   """Base class for a class that provides an API to HTTP based service:
-    - Provides 'request' method.
-    - Supports automatic request retries.
-    - Thread safe.
+  - Provides 'request' method.
+  - Supports automatic request retries.
+  - Thread safe.
   """
 
   def __init__(self, urlhost, engine, authenticator=None):
@@ -382,8 +385,9 @@
       # Transparently retry 404 IIF it is a CloudEndpoints API call *and* the
       # result is not JSON. This assumes that we only use JSON encoding. This
       # is workaround for known Cloud Endpoints bug.
-      return ('/api/' in suburl and
-              not resp.content_type.startswith('application/json'))
+      return "/api/" in suburl and not resp.content_type.startswith(
+        "application/json"
+      )
     # All other 4** errors are fatal. All 5** errors are transient.
     return resp.code >= 500
 
@@ -396,9 +400,9 @@
     if isinstance(body, str):
       return body.encode()
     # Any body should have content type set.
-    assert content_type, 'Request has body, but no content type'
+    assert content_type, "Request has body, but no content type"
     encoder = CONTENT_ENCODERS.get(content_type)
-    assert encoder, ('Unknown content type %s' % content_type)
+    assert encoder, "Unknown content type %s" % content_type
     return encoder(body).encode()
 
   def login(self, allow_user_interaction):
@@ -426,18 +430,19 @@
       self.authenticator.logout()
 
   def request(
-      self,
-      urlpath,
-      data=None,
-      content_type=None,
-      max_attempts=URL_OPEN_MAX_ATTEMPTS,
-      expected_error_codes=None,
-      timeout=URL_OPEN_TIMEOUT,
-      read_timeout=URL_READ_TIMEOUT,
-      stream=True,
-      method=None,
-      headers=None,
-      follow_redirects=True):
+    self,
+    urlpath,
+    data=None,
+    content_type=None,
+    max_attempts=URL_OPEN_MAX_ATTEMPTS,
+    expected_error_codes=None,
+    timeout=URL_OPEN_TIMEOUT,
+    read_timeout=URL_READ_TIMEOUT,
+    stream=True,
+    method=None,
+    headers=None,
+    follow_redirects=True,
+  ):
     """Attempts to open the given url multiple times.
 
     |urlpath| is relative to the server root, i.e. '/some/request?param=1'.
@@ -484,30 +489,30 @@
 
     The returned value has a property |code| with the response code.
     """
-    assert urlpath and urlpath[0] == '/', urlpath
+    assert urlpath and urlpath[0] == "/", urlpath
 
     if data is not None:
-      assert method in (None, 'DELETE', 'POST', 'PUT')
-      method = method or 'POST'
+      assert method in (None, "DELETE", "POST", "PUT")
+      method = method or "POST"
       content_type = content_type or DEFAULT_CONTENT_TYPE
       body = self.encode_request_body(data, content_type)
     else:
-      assert method in (None, 'DELETE', 'GET')
-      method = method or 'GET'
+      assert method in (None, "DELETE", "GET")
+      method = method or "GET"
       body = None
-      assert not content_type, 'Can\'t use content_type on %s' % method
+      assert not content_type, "Can't use content_type on %s" % method
 
     # Prepare request info.
-    parsed = urllib.parse.urlparse('/' + urlpath.lstrip('/'))
+    parsed = urllib.parse.urlparse("/" + urlpath.lstrip("/"))
     resource_url = urllib.parse.urljoin(self.urlhost, parsed.path)
     query_params = urllib.parse.parse_qsl(parsed.query)
 
     # Prepare headers.
     headers = get_case_insensitive_dict(headers or {})
     if body is not None:
-      headers['Content-Length'] = str(len(body))
+      headers["Content-Length"] = str(len(body))
       if content_type:
-        headers['Content-Type'] = content_type
+        headers["Content-Type"] = content_type
 
     last_error = None
     auth_attempted = False
@@ -516,25 +521,38 @@
       # Log non-first attempt.
       if attempt.attempt:
         logging.warning(
-            'Retrying request %s, attempt %d/%d...',
-            resource_url, attempt.attempt, max_attempts)
+          "Retrying request %s, attempt %d/%d...",
+          resource_url,
+          attempt.attempt,
+          max_attempts,
+        )
 
       try:
         # Prepare and send a new request.
         request = HttpRequest(
-            method, resource_url, query_params, body,
-            headers, read_timeout, stream, follow_redirects)
+          method,
+          resource_url,
+          query_params,
+          body,
+          headers,
+          read_timeout,
+          stream,
+          follow_redirects,
+        )
         if self.authenticator:
           self.authenticator.authorize(request)
         response = self.engine.perform_request(request)
-        logging.debug('Request %s succeeded', request.get_full_url())
+        logging.debug("Request %s succeeded", request.get_full_url())
         return response
 
       except (ConnectionError, TimeoutError) as e:
         last_error = e
         logging.warning(
-            'Unable to open url %s on attempt %d: %s',
-            request.get_full_url(), attempt.attempt, e)
+          "Unable to open url %s on attempt %d: %s",
+          request.get_full_url(),
+          attempt.attempt,
+          e,
+        )
         continue
 
       except HttpError as e:
@@ -543,16 +561,21 @@
         # If it is one of the expected codes, we are done.
         if expected_error_codes and e.response.code in expected_error_codes:
           logging.debug(
-              'Request %s succeeded with one of the expected codes %d',
-              request.get_full_url(), e.response.code)
+            "Request %s succeeded with one of the expected codes %d",
+            request.get_full_url(),
+            e.response.code,
+          )
           return e.response
 
         # Access denied -> authenticate.
         if e.response.code in (401, 403):
           logging.warning(
-              'Got a reply with HTTP status code %d for %s on attempt %d: %s',
-              e.response.code, request.get_full_url(), attempt.attempt,
-              e.description())
+            "Got a reply with HTTP status code %d for %s on attempt %d: %s",
+            e.response.code,
+            request.get_full_url(),
+            attempt.attempt,
+            e.description(),
+          )
           # Try forcefully refresh the token. If it doesn't help, then server
           # does not support authentication or user doesn't have required
           # access.
@@ -564,12 +587,17 @@
               continue
           # Authentication attempt was unsuccessful.
           logging.error(
-              'Request to %s failed with HTTP status code %d: %s',
-              request.get_full_url(), e.response.code, e.description())
+            "Request to %s failed with HTTP status code %d: %s",
+            request.get_full_url(),
+            e.response.code,
+            e.description(),
+          )
           if self.authenticator and self.authenticator.supports_login:
             logging.error(
-                'Use auth.py to login if haven\'t done so already:\n'
-                '    python auth.py login --service=%s', self.urlhost)
+              "Use auth.py to login if haven't done so already:\n"
+              "    python auth.py login --service=%s",
+              self.urlhost,
+            )
           return None
 
         # Hit a error that can not be retried -> stop retry loop.
@@ -578,18 +606,26 @@
           # with the request, so don't retry. Dump entire reply to debug log and
           # only a friendly error message to error log.
           logging.debug(
-              'Request to %s failed with HTTP status code %d.\n%s',
-              request.get_full_url(), e.response.code,
-              e.description(verbose=True))
+            "Request to %s failed with HTTP status code %d.\n%s",
+            request.get_full_url(),
+            e.response.code,
+            e.description(verbose=True),
+          )
           logging.error(
-              'Request to %s failed with HTTP status code %d: %s',
-              request.get_full_url(), e.response.code, e.description())
+            "Request to %s failed with HTTP status code %d: %s",
+            request.get_full_url(),
+            e.response.code,
+            e.description(),
+          )
           return None
 
         # Retry all other errors.
         logging.warning(
-            'Server responded with error on %s on attempt %d: %s',
-            request.get_full_url(), attempt.attempt, e.description())
+          "Server responded with error on %s on attempt %d: %s",
+          request.get_full_url(),
+          attempt.attempt,
+          e.description(),
+        )
         continue
 
     if isinstance(last_error, HttpError):
@@ -597,8 +633,12 @@
     else:
       error_msg = str(last_error)
     logging.error(
-        'Unable to open given url, %s, after %d attempts or %d timeout.\n%s',
-        request.get_full_url(), max_attempts, timeout, error_msg)
+      "Unable to open given url, %s, after %d attempts or %d timeout.\n%s",
+      request.get_full_url(),
+      max_attempts,
+      timeout,
+      error_msg,
+    )
 
     return None
 
@@ -616,7 +656,8 @@
     """
     content_type = JSON_CONTENT_TYPE if data is not None else None
     response = self.request(
-        urlpath, content_type=content_type, data=data, stream=False, **kwargs)
+      urlpath, content_type=content_type, data=data, stream=False, **kwargs
+    )
     if not response:
       return None
     try:
@@ -628,8 +669,12 @@
     try:
       return json.loads(text)
     except ValueError as e:
-      logging.error('Not a JSON response when calling %s: %s; full text: %s',
-                    urlpath, e, text)
+      logging.error(
+        "Not a JSON response when calling %s: %s; full text: %s",
+        urlpath,
+        e,
+        text,
+      )
       return None
 
 
@@ -637,17 +682,17 @@
   """Request to HttpService."""
 
   def __init__(
-      self, method, url, params, body,
-      headers, timeout, stream, follow_redirects):
+    self, method, url, params, body, headers, timeout, stream, follow_redirects
+  ):
     """Arguments:
-      |method| - HTTP method to use
-      |url| - relative URL to the resource, without query parameters
-      |params| - list of (key, value) pairs to put into GET parameters
-      |body| - encoded body of the request (None or str)
-      |headers| - dict with request headers
-      |timeout| - socket read timeout (None to disable)
-      |stream| - True to stream response from socket
-      |follow_redirects| - True to follow HTTP redirects.
+    |method| - HTTP method to use
+    |url| - relative URL to the resource, without query parameters
+    |params| - list of (key, value) pairs to put into GET parameters
+    |body| - encoded body of the request (None or str)
+    |headers| - dict with request headers
+    |timeout| - socket read timeout (None to disable)
+    |stream| - True to stream response from socket
+    |follow_redirects| - True to follow HTTP redirects.
     """
     self.method = method
     self.url = url
@@ -670,7 +715,7 @@
     """Resource URL with url-encoded GET parameters."""
     if not self.params:
       return self.url
-    return '%s?%s' % (self.url, urllib.parse.urlencode(self.params))
+    return "%s?%s" % (self.url, urllib.parse.urlencode(self.params))
 
 
 class HttpResponse:
@@ -697,7 +742,7 @@
     assert all(issubclass(e, Exception) for e in self._timeout_exc_classes)
     try:
       read = 0
-      if hasattr(self._response, 'iter_content'):
+      if hasattr(self._response, "iter_content"):
         # request.Response.
         for buf in self._response.iter_content(chunk_size):
           read += len(buf)
@@ -711,8 +756,13 @@
           read += len(buf)
           yield buf
     except self._timeout_exc_classes as e:
-      logging.error('Timeout while reading from %s, read %d of %s: %s',
-          self._url, read, self.get_header('Content-Length'), e)
+      logging.error(
+        "Timeout while reading from %s, read %d of %s: %s",
+        self._url,
+        read,
+        self.get_header("Content-Length"),
+        e,
+      )
       raise TimeoutError(e)
 
   def read(self):
@@ -722,14 +772,18 @@
     """
     assert all(issubclass(e, Exception) for e in self._timeout_exc_classes)
     try:
-      if hasattr(self._response, 'content'):
+      if hasattr(self._response, "content"):
         # request.Response.
         return self._response.content
       # File-like object.
       return self._response.read()
     except self._timeout_exc_classes as e:
-      logging.error('Timeout while reading from %s, expected %s bytes: %s',
-          self._url, self.get_header('Content-Length'), e)
+      logging.error(
+        "Timeout while reading from %s, expected %s bytes: %s",
+        self._url,
+        self.get_header("Content-Length"),
+        e,
+      )
       raise TimeoutError(e)
 
   def get_header(self, header):
@@ -749,11 +803,10 @@
   @property
   def content_type(self):
     """Response content type or empty string if not presented by the server."""
-    return self.get_header('Content-Type') or ''
+    return self.get_header("Content-Type") or ""
 
 
 class _UserAgentHolder:
-
   def __init__(self):
     # TODO(crbug/1084410): Consider guarding it with a RWLock
     self._user_agent = None
@@ -777,7 +830,7 @@
   def wrapped(engine, request, **kwargs):
     ua = _user_agent_holder.user_agent
     if ua is not None:
-      request.headers['User-Agent'] = ua
+      request.headers["User-Agent"] = ua
     return func(engine, request, **kwargs)
 
   return wrapped
@@ -799,11 +852,13 @@
   # Will be caught while reading a streaming response in HttpResponse.read and
   # transformed to TimeoutError.
   timeout_exception_classes = (
-      socket.timeout, ssl.SSLError,
-      requests.Timeout,
-      requests.ConnectionError,
-      urllib3.exceptions.ProtocolError,
-      urllib3.exceptions.TimeoutError)
+    socket.timeout,
+    ssl.SSLError,
+    requests.Timeout,
+    requests.ConnectionError,
+    urllib3.exceptions.ProtocolError,
+    urllib3.exceptions.TimeoutError,
+  )
 
   def __init__(self):
     super(RequestsLibEngine, self).__init__()
@@ -812,12 +867,13 @@
     self.session.trust_env = True
     self.session.verify = tools.get_cacerts_bundle()
     # Configure connection pools.
-    for protocol in ('https://', 'http://'):
-      self.session.mount(protocol, adapters.HTTPAdapter(
-          pool_connections=64,
-          pool_maxsize=64,
-          max_retries=0,
-          pool_block=False))
+    for protocol in ("https://", "http://"):
+      self.session.mount(
+        protocol,
+        adapters.HTTPAdapter(
+          pool_connections=64, pool_maxsize=64, max_retries=0, pool_block=False
+        ),
+      )
 
   @maybe_inject_user_agent
   def perform_request(self, request):
@@ -834,22 +890,24 @@
     try:
       # response is a requests.models.Response.
       response = self.session.request(
-          method=request.method,
-          url=request.url,
-          params=request.params,
-          data=request.body,
-          headers=request.headers,
-          cookies=request.cookies,
-          timeout=request.timeout,
-          stream=request.stream,
-          allow_redirects=request.follow_redirects)
+        method=request.method,
+        url=request.url,
+        params=request.params,
+        data=request.body,
+        headers=request.headers,
+        cookies=request.cookies,
+        timeout=request.timeout,
+        stream=request.stream,
+        allow_redirects=request.follow_redirects,
+      )
       # Convert it to HttpResponse (that doesn't depend on the engine).
       resp = HttpResponse(
-          response=response,
-          url=request.get_full_url(),
-          code=response.status_code,
-          headers=response.headers,
-          timeout_exc_classes=self.timeout_exception_classes)
+        response=response,
+        url=request.get_full_url(),
+        code=response.status_code,
+        headers=response.headers,
+        timeout_exc_classes=self.timeout_exception_classes,
+      )
       response.raise_for_status()
       return resp
     except requests.Timeout as e:
@@ -869,8 +927,8 @@
 
   def __init__(self, attempt, remaining):
     """Information about current attempt in retry loop:
-      |attempt| - zero based index of attempt.
-      |remaining| - how much time is left before retry loop finishes retries.
+    |attempt| - zero based index of attempt.
+    |remaining| - how much time is left before retry loop finishes retries.
     """
     self.attempt = attempt
     self.remaining = remaining
@@ -881,7 +939,7 @@
   """How long to sleep before retrying an attempt in retry_loop."""
   # Maximum sleeping time. We're hammering a cloud-distributed service, it'll
   # survive.
-  MAX_SLEEP = 10.
+  MAX_SLEEP = 10.0
   # random.random() returns [0.0, 1.0). Starts with relatively short waiting
   # time by starting with 1.5/2+1.5^-1 median offset.
   duration = (random.random() * 1.5) + math.pow(1.5, (attempt - 1))
diff --git a/utils/oauth.py b/utils/oauth.py
index 2d06be4..2f75781 100644
--- a/utils/oauth.py
+++ b/utils/oauth.py
@@ -20,12 +20,14 @@
 import webbrowser
 
 from utils import tools
+
 tools.force_local_third_party()
 
 # third_party/
 import httplib2
 from oauth2client import client
 from oauth2client.contrib import locked_file
+
 # Handle the internal use case, where multistore_file has
 # 2 copies in oauth2client. One is in root folder, one is
 # in contrib folder.
@@ -44,62 +46,75 @@
 # Path to a file with cached OAuth2 credentials used by default. Can be
 # overridden by command line option or env variable.
 DEFAULT_OAUTH_TOKENS_CACHE = os.path.join(
-    os.path.expanduser('~'), '.isolated_oauth')
+  os.path.expanduser("~"), ".isolated_oauth"
+)
 
 # List of space separated OAuth scopes for generated tokens. GAE apps usually
 # use userinfo.email scope for authentication.
-OAUTH_SCOPES = 'https://www.googleapis.com/auth/userinfo.email'
+OAUTH_SCOPES = "https://www.googleapis.com/auth/userinfo.email"
 
 # Endpoint to generate access tokens.
-OAUTH_TOKEN_ENDPOINT = 'https://www.googleapis.com/oauth2/v3/token'
+OAUTH_TOKEN_ENDPOINT = "https://www.googleapis.com/oauth2/v3/token"
 
 
 # OAuth authentication method configuration, used by utils/net.py.
 # See doc string for 'make_oauth_config' for meaning of fields.
-OAuthConfig = collections.namedtuple('OAuthConfig', [
-  'disabled',
-  'tokens_cache',
-  'no_local_webserver',
-  'webserver_port',
-  'service_account_json',
-  'use_luci_context_auth',
-])
+OAuthConfig = collections.namedtuple(
+  "OAuthConfig",
+  [
+    "disabled",
+    "tokens_cache",
+    "no_local_webserver",
+    "webserver_port",
+    "service_account_json",
+    "use_luci_context_auth",
+  ],
+)
 
 
 # Indicates that no OAuth-based authentication performed by this module should
 # be automatically used.
 DISABLED_OAUTH_CONFIG = OAuthConfig(
-    disabled=True,
-    tokens_cache=None,
-    no_local_webserver=None,
-    webserver_port=None,
-    service_account_json=None,
-    use_luci_context_auth=None)
+  disabled=True,
+  tokens_cache=None,
+  no_local_webserver=None,
+  webserver_port=None,
+  service_account_json=None,
+  use_luci_context_auth=None,
+)
 
 
 # Access token with its expiration time (UTC datetime, or None if not known).
-AccessToken = collections.namedtuple('AccessToken', [
-  'token',
-  'expires_at',
-])
+AccessToken = collections.namedtuple(
+  "AccessToken",
+  [
+    "token",
+    "expires_at",
+  ],
+)
 
 
 # Service account credentials as loaded from JSON file.
-ServiceAccountCredentials = collections.namedtuple('ServiceAccountCredentials',
-[
-  'client_email',
-  'client_id',
-  'private_key', # PEM encoded.
-  'private_key_id',
-])
+ServiceAccountCredentials = collections.namedtuple(
+  "ServiceAccountCredentials",
+  [
+    "client_email",
+    "client_id",
+    "private_key",  # PEM encoded.
+    "private_key_id",
+  ],
+)
 
 
 # Configuration fetched from a service, returned by _fetch_service_config.
-_ServiceConfig = collections.namedtuple('_ServiceConfig', [
-  'client_id',
-  'client_secret',
-  'primary_url',
-])
+_ServiceConfig = collections.namedtuple(
+  "_ServiceConfig",
+  [
+    "client_id",
+    "client_secret",
+    "primary_url",
+  ],
+)
 
 # Process cache of _fetch_service_config results.
 _service_config_cache = {}
@@ -109,17 +124,23 @@
 # LUCI context parameters as loaded from JSON file.
 #
 # https://chromium.googlesource.com/infra/luci/luci-py.git/+/master/client/LUCI_CONTEXT.md
-LocalAuthParameters = collections.namedtuple('LocalAuthParameters', [
-  'rpc_port',
-  'secret',
-  'accounts',
-  'default_account_id',
-])
+LocalAuthParameters = collections.namedtuple(
+  "LocalAuthParameters",
+  [
+    "rpc_port",
+    "secret",
+    "accounts",
+    "default_account_id",
+  ],
+)
 
 # Values of 'accounts' section of LUCI_CONTEXT["local_auth"].
-LocalAuthAccount = collections.namedtuple('LocalAuthAccount', [
-  'id',
-])
+LocalAuthAccount = collections.namedtuple(
+  "LocalAuthAccount",
+  [
+    "id",
+  ],
+)
 
 
 class BadServiceAccountCredentials(Exception):
@@ -131,11 +152,12 @@
 
 
 def make_oauth_config(
-    disabled=None,
-    tokens_cache=None,
-    no_local_webserver=None,
-    webserver_port=None,
-    service_account_json=None):
+  disabled=None,
+  tokens_cache=None,
+  no_local_webserver=None,
+  webserver_port=None,
+  service_account_json=None,
+):
   """Returns new instance of OAuthConfig.
 
   If some config option is not provided or None, it will be set to a reasonable
@@ -152,79 +174,90 @@
   """
   if tokens_cache is None:
     tokens_cache = os.environ.get(
-        'SWARMING_AUTH_TOKENS_CACHE', DEFAULT_OAUTH_TOKENS_CACHE)
+      "SWARMING_AUTH_TOKENS_CACHE", DEFAULT_OAUTH_TOKENS_CACHE
+    )
   if no_local_webserver is None:
     no_local_webserver = tools.get_bool_env_var(
-        'SWARMING_AUTH_NO_LOCAL_WEBSERVER')
+      "SWARMING_AUTH_NO_LOCAL_WEBSERVER"
+    )
   if webserver_port is None:
     webserver_port = 8090
 
   if service_account_json is None:
-    service_account_json = os.environ.get('SWARMING_AUTH_SERVICE_ACCOUNT_JSON')
+    service_account_json = os.environ.get("SWARMING_AUTH_SERVICE_ACCOUNT_JSON")
 
   use_luci_context_auth = has_local_auth()
   if disabled is None:
-    disabled = (tools.is_headless()
-                and not service_account_json and not use_luci_context_auth)
+    disabled = (
+      tools.is_headless()
+      and not service_account_json
+      and not use_luci_context_auth
+    )
 
   if disabled:
     service_account_json = None
     use_luci_context_auth = False
   elif service_account_json and use_luci_context_auth:
-    raise ValueError('Cannot use both service account and LUCI_CONTEXT')
+    raise ValueError("Cannot use both service account and LUCI_CONTEXT")
 
   return OAuthConfig(
-      disabled,
-      tokens_cache,
-      no_local_webserver,
-      webserver_port,
-      service_account_json,
-      use_luci_context_auth)
+    disabled,
+    tokens_cache,
+    no_local_webserver,
+    webserver_port,
+    service_account_json,
+    use_luci_context_auth,
+  )
 
 
 def add_oauth_options(parser):
   """Appends OAuth related options to OptionParser."""
   default_config = make_oauth_config()
-  parser.oauth_group = optparse.OptionGroup(parser, 'OAuth options')
+  parser.oauth_group = optparse.OptionGroup(parser, "OAuth options")
   parser.oauth_group.add_option(
-      '--auth-disabled',
-      action='store_true',
-      default=False,
-      help='Use it to disable OAuth and rely only on IP allowlist for '
-      'authentication. OAuth gets disabled by default on bots that '
-      'do not have credentials.')
+    "--auth-disabled",
+    action="store_true",
+    default=False,
+    help="Use it to disable OAuth and rely only on IP allowlist for "
+    "authentication. OAuth gets disabled by default on bots that "
+    "do not have credentials.",
+  )
   parser.oauth_group.add_option(
-      '--auth-tokens-cache',
-      default=default_config.tokens_cache,
-      metavar='FILE',
-      help='Path to a file with oauth2client tokens cache. It should be a '
-           'safe location accessible only to a current user: knowing content '
-           'of this file is roughly equivalent to knowing account password. '
-           'Can also be set with SWARMING_AUTH_TOKENS_CACHE environment '
-           'variable. [default: %default]')
+    "--auth-tokens-cache",
+    default=default_config.tokens_cache,
+    metavar="FILE",
+    help="Path to a file with oauth2client tokens cache. It should be a "
+    "safe location accessible only to a current user: knowing content "
+    "of this file is roughly equivalent to knowing account password. "
+    "Can also be set with SWARMING_AUTH_TOKENS_CACHE environment "
+    "variable. [default: %default]",
+  )
   parser.oauth_group.add_option(
-      '--auth-no-local-webserver',
-      action='store_true',
-      default=default_config.no_local_webserver,
-      help='Do not run a local web server when performing OAuth2 login flow. '
-           'Can also be set with SWARMING_AUTH_NO_LOCAL_WEBSERVER=1 '
-           'environment variable. [default: %default]')
+    "--auth-no-local-webserver",
+    action="store_true",
+    default=default_config.no_local_webserver,
+    help="Do not run a local web server when performing OAuth2 login flow. "
+    "Can also be set with SWARMING_AUTH_NO_LOCAL_WEBSERVER=1 "
+    "environment variable. [default: %default]",
+  )
   parser.oauth_group.add_option(
-      '--auth-host-port',
-      type=int,
-      default=default_config.webserver_port,
-      metavar='PORT',
-      help='Port a local web server should listen on. Used only if '
-           '--auth-no-local-webserver is not set. [default: %default]')
+    "--auth-host-port",
+    type=int,
+    default=default_config.webserver_port,
+    metavar="PORT",
+    help="Port a local web server should listen on. Used only if "
+    "--auth-no-local-webserver is not set. [default: %default]",
+  )
   parser.oauth_group.add_option(
-      '--auth-service-account-json',
-      default=default_config.service_account_json,
-      metavar='FILE',
-      help='Path to a JSON file with service account credentials to use. '
-           'Can be generated by "Generate new JSON key" button in '
-           '"Credentials" section of any Cloud Console project. The value can '
-           'also be set with SWARMING_AUTH_SERVICE_ACCOUNT_JSON environment '
-           'variable. [default: %default]')
+    "--auth-service-account-json",
+    default=default_config.service_account_json,
+    metavar="FILE",
+    help="Path to a JSON file with service account credentials to use. "
+    'Can be generated by "Generate new JSON key" button in '
+    '"Credentials" section of any Cloud Console project. The value can '
+    "also be set with SWARMING_AUTH_SERVICE_ACCOUNT_JSON environment "
+    "variable. [default: %default]",
+  )
   parser.add_option_group(parser.oauth_group)
   # Use this occasion to monkey patch oauth2client's LockedFile to do retries by
   # default.
@@ -237,16 +270,17 @@
   OptionParser should be populated with oauth options by 'add_oauth_options'.
   """
   if options.auth_service_account_json and options.auth_disabled:
-    raise ValueError('Can\'t use service account together with --auth-disabled')
+    raise ValueError("Can't use service account together with --auth-disabled")
 
   # If '--auth-disabled' wasn't provided, let 'make_oauth_config' decide whether
   # to disable auth or not (by passing in None).
   cfg = make_oauth_config(
-      disabled=True if options.auth_disabled else None,
-      tokens_cache=options.auth_tokens_cache,
-      no_local_webserver=options.auth_no_local_webserver,
-      webserver_port=options.auth_host_port,
-      service_account_json=options.auth_service_account_json)
+    disabled=True if options.auth_disabled else None,
+    tokens_cache=options.auth_tokens_cache,
+    no_local_webserver=options.auth_no_local_webserver,
+    webserver_port=options.auth_host_port,
+    service_account_json=options.auth_service_account_json,
+  )
 
   # Validate service account JSON is correct by trying to load it.
   if cfg.service_account_json:
@@ -254,14 +288,14 @@
       acc = _load_service_account_json(cfg.service_account_json)
       _parse_private_key(acc.private_key)
     except BadServiceAccountCredentials as exc:
-      raise ValueError('Bad service account credentials: %s' % exc)
+      raise ValueError("Bad service account credentials: %s" % exc)
 
   # Validate LUCI context JSON is correct by trying to load it.
   if cfg.use_luci_context_auth:
     try:
       _load_local_auth()
     except BadLuciContextParameters as exc:
-      raise ValueError('Bad LUCI_CONTEXT local_auth parameters: %s' % exc)
+      raise ValueError("Bad LUCI_CONTEXT local_auth parameters: %s" % exc)
 
   return cfg
 
@@ -313,45 +347,50 @@
     try:
       service_account = _load_service_account_json(config.service_account_json)
     except BadServiceAccountCredentials as e:
-      logging.error('Bad service account credentials: %s', e)
+      logging.error("Bad service account credentials: %s", e)
       return None
 
     # Body of token refresh request (with JWT assertion signed with secret key).
-    body = urllib.parse.urlencode({
-        'assertion': _make_assertion_jwt(service_account),
-        'grant_type': 'urn:ietf:params:oauth:grant-type:jwt-bearer',
-    })
+    body = urllib.parse.urlencode(
+      {
+        "assertion": _make_assertion_jwt(service_account),
+        "grant_type": "urn:ietf:params:oauth:grant-type:jwt-bearer",
+      }
+    )
 
     # Exchange it for access_token.
     resp, content = httplib2.Http(ca_certs=tools.get_cacerts_bundle()).request(
-        uri=OAUTH_TOKEN_ENDPOINT,
-        method='POST',
-        body=body,
-        headers={'Content-Type': 'application/x-www-form-urlencoded'})
+      uri=OAUTH_TOKEN_ENDPOINT,
+      method="POST",
+      body=body,
+      headers={"Content-Type": "application/x-www-form-urlencoded"},
+    )
     if resp.status != 200:
       logging.error(
-          'Failed to grab access token for service account: %r', content)
+        "Failed to grab access token for service account: %r", content
+      )
       return None
 
     try:
       token = json.loads(content)
-      access_token = token['access_token']
+      access_token = token["access_token"]
       expires_at = None
-      if 'expires_in' in token:
+      if "expires_in" in token:
         expires_at = datetime.datetime.utcnow()
-        expires_at += datetime.timedelta(seconds=int(token['expires_in']))
+        expires_at += datetime.timedelta(seconds=int(token["expires_in"]))
     except (KeyError, ValueError) as e:
-      logging.error('Unexpected access token response format: %s', e)
+      logging.error("Unexpected access token response format: %s", e)
       return None
 
     credentials = client.OAuth2Credentials(
-        access_token=access_token,
-        client_id=service_account.client_id,
-        client_secret=None,
-        refresh_token=None,
-        token_expiry=expires_at,
-        token_uri=None,
-        user_agent=None)
+      access_token=access_token,
+      client_id=service_account.client_id,
+      client_secret=None,
+      refresh_token=None,
+      token_expiry=expires_at,
+      token_uri=None,
+      user_agent=None,
+    )
   else:
     # 3-legged flow with (perhaps cached) refresh token.
     credentials = storage.get()
@@ -361,7 +400,7 @@
         credentials.refresh(httplib2.Http(ca_certs=tools.get_cacerts_bundle()))
         refreshed = True
       except client.Error as err:
-        logging.error('OAuth error: %s', err)
+        logging.error("OAuth error: %s", err)
 
     # Refresh token is missing or invalid, go through full flow.
     if not refreshed:
@@ -372,8 +411,10 @@
         return None
 
   # Success.
-  logging.info('OAuth access_token refreshed. Expires in %s.',
-      credentials.token_expiry - datetime.datetime.utcnow())
+  logging.info(
+    "OAuth access_token refreshed. Expires in %s.",
+    credentials.token_expiry - datetime.datetime.utcnow(),
+  )
   credentials.set_store(storage)
   storage.put(credentials)
   return AccessToken(credentials.access_token, credentials.token_expiry)
@@ -392,11 +433,12 @@
   # Do not mix access_token caches for different service accounts.
   if config.service_account_json:
     creds = _load_service_account_json(config.service_account_json)
-    key = 'sa:%s:%s' % (creds.client_id, urlhost.rstrip('/'))
+    key = "sa:%s:%s" % (creds.client_id, urlhost.rstrip("/"))
   else:
-    key = urlhost.rstrip('/')
+    key = urlhost.rstrip("/")
   return multistore_file.get_credential_storage_custom_string_key(
-      config.tokens_cache, key)
+    config.tokens_cache, key
+  )
 
 
 def _fetch_auth_service_url(urlhost):
@@ -410,9 +452,10 @@
   service_config = _fetch_service_config(urlhost)
   if not service_config:
     return None
-  url = (service_config.primary_url or urlhost).rstrip('/')
+  url = (service_config.primary_url or urlhost).rstrip("/")
   assert url.startswith(
-      ('https://', 'http://127.0.0.1:', 'http://localhost:')), url
+    ("https://", "http://127.0.0.1:", "http://localhost:")
+  ), url
   return url
 
 
@@ -425,6 +468,7 @@
   Returns:
     Instance of _ServiceConfig on success, None on failure.
   """
+
   def do_fetch():
     # client_secret is not really a secret in that case. So an attacker can
     # impersonate service's identity in OAuth2 flow. But that's generally
@@ -433,7 +477,7 @@
     # attacker needs some process running on user's machine to successfully
     # complete the flow and grab access_token. When you have malicious code
     # running on your machine you're screwed anyway.
-    url = '%s/auth/api/v1/server/oauth_config' % urlhost.rstrip('/')
+    url = "%s/auth/api/v1/server/oauth_config" % urlhost.rstrip("/")
     response = requests.get(url, verify=tools.get_cacerts_bundle())
     if response.status_code == 200:
       try:
@@ -441,15 +485,18 @@
         if not isinstance(config, dict):
           raise ValueError()
         return _ServiceConfig(
-            config['client_id'],
-            config['client_not_so_secret'],
-            config.get('primary_url'))
+          config["client_id"],
+          config["client_not_so_secret"],
+          config.get("primary_url"),
+        )
       except (KeyError, ValueError) as err:
-        logging.error('Invalid response from the service: %s', err)
+        logging.error("Invalid response from the service: %s", err)
     else:
       logging.warning(
-          'Error when fetching oauth_config from %s, HTTP status code %d', url,
-          response.status_code)
+        "Error when fetching oauth_config from %s, HTTP status code %d",
+        url,
+        response.status_code,
+      )
     return None
 
   # Use local cache to avoid unnecessary network calls.
@@ -481,19 +528,20 @@
   Raises BadServiceAccountCredentials if file is missing or not valid.
   """
   try:
-    with open(path, 'r') as f:
+    with open(path, "r") as f:
       data = json.load(f)
     return ServiceAccountCredentials(
-        client_email=str(data['client_email']),
-        client_id=str(data['client_id']),
-        private_key=str(data['private_key']),
-        private_key_id=str(data['private_key_id']))
+      client_email=str(data["client_email"]),
+      client_id=str(data["client_id"]),
+      private_key=str(data["private_key"]),
+      private_key_id=str(data["private_key_id"]),
+    )
   except IOError as e:
-    raise BadServiceAccountCredentials('Can\'t open %s: %s' % (path, e))
+    raise BadServiceAccountCredentials("Can't open %s: %s" % (path, e))
   except ValueError as e:
-    raise BadServiceAccountCredentials('Not a JSON file %s: %s' % (path, e))
+    raise BadServiceAccountCredentials("Not a JSON file %s: %s" % (path, e))
   except KeyError as e:
-    raise BadServiceAccountCredentials('Missing key in %s: %s' % (path, e))
+    raise BadServiceAccountCredentials("Missing key in %s: %s" % (path, e))
 
 
 def _parse_private_key(pem):
@@ -502,16 +550,18 @@
   # doesn't support them natively. Do some ASN unwrapping to extract naked
   # RSA key (in der-encoded form). See https://www.ietf.org/rfc/rfc2313.txt.
   try:
-    der = rsa.pem.load_pem(pem, 'PRIVATE KEY')
+    der = rsa.pem.load_pem(pem, "PRIVATE KEY")
     keyinfo, _ = decoder.decode(der)
-    if keyinfo[1][0] != univ.ObjectIdentifier('1.2.840.113549.1.1.1'):
+    if keyinfo[1][0] != univ.ObjectIdentifier("1.2.840.113549.1.1.1"):
       raise BadServiceAccountCredentials(
-          'Not a DER-encoded OpenSSL private RSA key')
+        "Not a DER-encoded OpenSSL private RSA key"
+      )
     private_key_der = keyinfo[2].asOctets()
   except IndexError:
     raise BadServiceAccountCredentials(
-        'Not a DER-encoded OpenSSL private RSA key')
-  return rsa.PrivateKey.load_pkcs1(private_key_der, format='DER')
+      "Not a DER-encoded OpenSSL private RSA key"
+    )
+  return rsa.PrivateKey.load_pkcs1(private_key_der, format="DER")
 
 
 def _make_assertion_jwt(service_account):
@@ -520,11 +570,11 @@
   # https://developers.google.com/accounts/docs/OAuth2ServiceAccount.
   now = long(time.time())
   payload = {
-    'aud': OAUTH_TOKEN_ENDPOINT,
-    'scope': OAUTH_SCOPES,
-    'iat': now,
-    'exp': now + 3600,
-    'iss': service_account.client_email,
+    "aud": OAUTH_TOKEN_ENDPOINT,
+    "scope": OAUTH_SCOPES,
+    "iat": now,
+    "exp": now + 3600,
+    "iss": service_account.client_email,
   }
   # oauth2client knows how to use PyCrypo or PyOpenSSL for signing. Both are
   # heavy libraries, that require compiled extensions. Use pure python 'rsa' lib
@@ -537,13 +587,14 @@
 def _make_signed_jwt(payload, pkey):
   """Wraps |payload| dict into signed JSON Web Token."""
   # See http://self-issued.info/docs/draft-jones-json-web-token.html.
-  as_json = lambda d: json.dumps(d, sort_keys=True, separators=(',', ':'))
-  b64encode = lambda d: base64.urlsafe_b64encode(d).rstrip('=')
-  to_sign = '%s.%s' % (
-      b64encode(as_json({'typ': 'JWT', 'alg': 'RS256'})),
-      b64encode(as_json(payload)))
-  signature = rsa.sign(to_sign, pkey, 'SHA-256')
-  return '%s.%s' % (to_sign, b64encode(signature))
+  as_json = lambda d: json.dumps(d, sort_keys=True, separators=(",", ":"))
+  b64encode = lambda d: base64.urlsafe_b64encode(d).rstrip("=")
+  to_sign = "%s.%s" % (
+    b64encode(as_json({"typ": "JWT", "alg": "RS256"})),
+    b64encode(as_json(payload)),
+  )
+  signature = rsa.sign(to_sign, pkey, "SHA-256")
+  return "%s.%s" % (to_sign, b64encode(signature))
 
 
 # The chunk of code below is based on oauth2client.tools module, but adapted for
@@ -552,32 +603,35 @@
 
 def _run_oauth_dance(urlhost, config):
   """Perform full OAuth2 dance with the browser."""
+
   def out(s):
     print(s)
+
   def err(s):
     print(s, file=sys.stderr)
 
   # Fetch client_id and client_secret from the service itself.
   service_config = _fetch_service_config(urlhost)
   if not service_config:
-    err('Couldn\'t fetch OAuth configuration')
+    err("Couldn't fetch OAuth configuration")
     return None
   if not service_config.client_id or not service_config.client_secret:
-    err('OAuth is not configured on the service')
+    err("OAuth is not configured on the service")
     return None
 
   flow = client.OAuth2WebServerFlow(
-      service_config.client_id,
-      service_config.client_secret,
-      OAUTH_SCOPES,
-      approval_prompt='force')
+    service_config.client_id,
+    service_config.client_secret,
+    OAUTH_SCOPES,
+    approval_prompt="force",
+  )
 
   use_local_webserver = not config.no_local_webserver
   port = config.webserver_port
   if use_local_webserver:
     success = False
     try:
-      httpd = ClientRedirectServer(('localhost', port), ClientRedirectHandler)
+      httpd = ClientRedirectServer(("localhost", port), ClientRedirectHandler)
     except socket.error:
       pass
     else:
@@ -585,14 +639,15 @@
     use_local_webserver = success
     if not success:
       out(
-        'Failed to start a local webserver listening on port %d.\n'
-        'Please check your firewall settings and locally running programs that '
-        'may be blocking or using those ports.\n\n'
-        'Falling back to --auth-no-local-webserver and continuing with '
-        'authentication.\n' % port)
+        "Failed to start a local webserver listening on port %d.\n"
+        "Please check your firewall settings and locally running programs that "
+        "may be blocking or using those ports.\n\n"
+        "Falling back to --auth-no-local-webserver and continuing with "
+        "authentication.\n" % port
+      )
 
   if use_local_webserver:
-    oauth_callback = 'http://localhost:%s/' % port
+    oauth_callback = "http://localhost:%s/" % port
   else:
     oauth_callback = client.OOB_CALLBACK_URN
   flow.redirect_uri = oauth_callback
@@ -601,39 +656,39 @@
   if use_local_webserver:
     webbrowser.open(authorize_url, new=1, autoraise=True)
     out(
-      'Your browser has been opened to visit:\n\n'
-      '    %s\n\n'
-      'If your browser is on a different machine then exit and re-run this '
-      'application with the command-line parameter\n\n'
-      '  --auth-no-local-webserver\n' % authorize_url)
+      "Your browser has been opened to visit:\n\n"
+      "    %s\n\n"
+      "If your browser is on a different machine then exit and re-run this "
+      "application with the command-line parameter\n\n"
+      "  --auth-no-local-webserver\n" % authorize_url
+    )
   else:
-    out(
-      'Go to the following link in your browser:\n\n'
-      '    %s\n' % authorize_url)
+    out("Go to the following link in your browser:\n\n    %s\n" % authorize_url)
 
   try:
     code = None
     if use_local_webserver:
       httpd.handle_request()
-      if 'error' in httpd.query_params:
-        err('Authentication request was rejected.')
+      if "error" in httpd.query_params:
+        err("Authentication request was rejected.")
         return None
-      if 'code' not in httpd.query_params:
+      if "code" not in httpd.query_params:
         err(
           'Failed to find "code" in the query parameters of the redirect.\n'
-          'Try running with --auth-no-local-webserver.')
+          "Try running with --auth-no-local-webserver."
+        )
         return None
-      code = httpd.query_params['code']
+      code = httpd.query_params["code"]
     else:
-      code = raw_input('Enter verification code: ').strip()
+      code = raw_input("Enter verification code: ").strip()
   except KeyboardInterrupt:
-    err('Canceled.')
+    err("Canceled.")
     return None
 
   try:
     return flow.step2_exchange(code)
   except client.FlowExchangeError as e:
-    err('Authentication has failed: %s' % e)
+    err("Authentication has failed: %s" % e)
     return None
 
 
@@ -642,7 +697,7 @@
 
 def has_local_auth():
   """Checks LUCI_CONTEXT to see if we should enable ambient authentication."""
-  if not luci_context.read('local_auth'):
+  if not luci_context.read("local_auth"):
     return False
   try:
     params = _load_local_auth()
@@ -673,22 +728,24 @@
   Raises:
     BadLuciContextParameters if file is missing or not valid.
   """
-  data = luci_context.read('local_auth')
+  data = luci_context.read("local_auth")
   if data is None:
     raise BadLuciContextParameters('Missing "local_auth" in LUCI_CONTEXT')
 
   try:
     return LocalAuthParameters(
-      rpc_port=int(data['rpc_port']),
-      secret=str(data['secret']),
+      rpc_port=int(data["rpc_port"]),
+      secret=str(data["secret"]),
       accounts=[
-        LocalAuthAccount(id=acc['id']) for acc in data.get('accounts', [])
+        LocalAuthAccount(id=acc["id"]) for acc in data.get("accounts", [])
       ],
-      default_account_id=data.get('default_account_id'))
+      default_account_id=data.get("default_account_id"),
+    )
   except (ValueError, KeyError):
-    data['secret'] = '...'  # note: 'data' is a copy, it's fine to mutate it
+    data["secret"] = "..."  # note: 'data' is a copy, it's fine to mutate it
     raise BadLuciContextParameters(
-        'Invalid "local_auth" section in LUCI_CONTEXT: %r' % (data,))
+      'Invalid "local_auth" section in LUCI_CONTEXT: %r' % (data,)
+    )
 
 
 def _get_luci_context_access_token(local_auth):
@@ -699,54 +756,65 @@
     None on failure.
   """
   logging.debug(
-      'local_auth: requesting an access token for account "%s"',
-      local_auth.default_account_id)
-  body = json.dumps({
-    'account_id': local_auth.default_account_id,  # may be None for old protocol
-    'scopes': [OAUTH_SCOPES],
-    'secret': local_auth.secret,
-  })
-  host = 'http://127.0.0.1:%d' % local_auth.rpc_port
+    'local_auth: requesting an access token for account "%s"',
+    local_auth.default_account_id,
+  )
+  body = json.dumps(
+    {
+      "account_id": local_auth.default_account_id,  # may be None for old protocol
+      "scopes": [OAUTH_SCOPES],
+      "secret": local_auth.secret,
+    }
+  )
+  host = "http://127.0.0.1:%d" % local_auth.rpc_port
   resp, content = httplib2.Http().request(
-      uri='%s/rpc/LuciLocalAuthService.GetOAuthToken' % host,
-      method='POST',
-      body=body,
-      headers={'Content-Type': 'application/json'})
+    uri="%s/rpc/LuciLocalAuthService.GetOAuthToken" % host,
+    method="POST",
+    body=body,
+    headers={"Content-Type": "application/json"},
+  )
   if resp.status != 200:
     logging.error(
-        'local_auth: Failed to grab access token for %s from LUCI context '
-        'server: %r', local_auth.default_account_id, content)
+      "local_auth: Failed to grab access token for %s from LUCI context "
+      "server: %r",
+      local_auth.default_account_id,
+      content,
+    )
     return None
 
   try:
     token = json.loads(content)
-    error_code = token.get('error_code')
-    error_message = token.get('error_message')
-    access_token = token.get('access_token')
-    expiry = token.get('expiry')
+    error_code = token.get("error_code")
+    error_message = token.get("error_message")
+    access_token = token.get("access_token")
+    expiry = token.get("expiry")
   except (KeyError, ValueError) as e:
-    logging.error('local_auth: Unexpected access token response format: %s', e)
+    logging.error("local_auth: Unexpected access token response format: %s", e)
     return None
 
   if error_code or not access_token:
     logging.error(
-        'local_auth: Error %s in retrieving access token: %s',
-        error_code, error_message)
+      "local_auth: Error %s in retrieving access token: %s",
+      error_code,
+      error_message,
+    )
     return None
 
   try:
     expiry_dt = datetime.datetime.utcfromtimestamp(expiry)
   except (TypeError, ValueError) as e:
-    logging.error('Invalid expiry in returned token: %s', e)
+    logging.error("Invalid expiry in returned token: %s", e)
     return None
 
   logging.debug(
-      'local_auth: got an access token for account "%s" that expires in %d sec',
-       local_auth.default_account_id, expiry - time.time())
+    'local_auth: got an access token for account "%s" that expires in %d sec',
+    local_auth.default_account_id,
+    expiry - time.time(),
+  )
 
   access_token = AccessToken(access_token, expiry_dt)
   if not _validate_luci_context_access_token(access_token):
-    logging.error('local_auth: the returned access token is invalid')
+    logging.error("local_auth: the returned access token is invalid")
     return None
   return access_token
 
@@ -764,9 +832,11 @@
   if isinstance(access_token, AccessToken) and access_token.token:
     # Valid if expires_at is None or it is not expired soon
     if access_token.expires_at:
-      if (not isinstance(access_token.expires_at, datetime.datetime) or
-          datetime.datetime.utcfromtimestamp(time.time()) >
-          access_token.expires_at - datetime.timedelta(seconds=60)):
+      if not isinstance(
+        access_token.expires_at, datetime.datetime
+      ) or datetime.datetime.utcfromtimestamp(
+        time.time()
+      ) > access_token.expires_at - datetime.timedelta(seconds=60):
         return False
     return True
   return False
@@ -778,6 +848,7 @@
   Waits for a single request and parses the query parameters
   into query_params and then stops serving.
   """
+
   query_params = {}
 
 
@@ -796,14 +867,14 @@
     if an error occurred.
     """
     self.send_response(200)
-    self.send_header('Content-type', 'text/html')
+    self.send_header("Content-type", "text/html")
     self.end_headers()
-    query = self.path.split('?', 1)[-1]
+    query = self.path.split("?", 1)[-1]
     query = dict(urllib.parse.parse_qsl(query))
     self.server.query_params = query
-    self.wfile.write('<html><head><title>Authentication Status</title></head>')
-    self.wfile.write('<body><p>The authentication flow has completed.</p>')
-    self.wfile.write('</body></html>')
+    self.wfile.write("<html><head><title>Authentication Status</title></head>")
+    self.wfile.write("<body><p>The authentication flow has completed.</p>")
+    self.wfile.write("</body></html>")
 
   def log_message(self, _format, *args):  # pylint: disable=arguments-differ
     """Do not log messages to stdout while running as command line program."""
diff --git a/utils/subprocess42.py b/utils/subprocess42.py
index 828d905..b94b4ec 100644
--- a/utils/subprocess42.py
+++ b/utils/subprocess42.py
@@ -49,7 +49,7 @@
 # Set to True when inhibit_crash_dump() has been called.
 _OS_ERROR_REPORTING_INHIBITED = False
 
-if sys.platform == 'win32':
+if sys.platform == "win32":
   import ctypes
   import msvcrt  # pylint: disable=F0401
   from ctypes import wintypes
@@ -100,15 +100,15 @@
 
   class JOBOBJECT_BASIC_LIMIT_INFORMATION(ctypes.Structure):
     _fields_ = [
-        ('PerProcessUserTimeLimit', ctypes.wintypes.LARGE_INTEGER),
-        ('PerJobUserTimeLimit', ctypes.wintypes.LARGE_INTEGER),
-        ('LimitFlags', ctypes.wintypes.DWORD),
-        ('MinimumWorkingSetSize', ctypes.c_size_t),
-        ('MaximumWorkingSetSize', ctypes.c_size_t),
-        ('ActiveProcessLimit', ctypes.wintypes.DWORD),
-        ('Affinity', ctypes.POINTER(ctypes.wintypes.ULONG)),
-        ('PriorityClass', ctypes.wintypes.DWORD),
-        ('SchedulingClass', ctypes.wintypes.DWORD),
+      ("PerProcessUserTimeLimit", ctypes.wintypes.LARGE_INTEGER),
+      ("PerJobUserTimeLimit", ctypes.wintypes.LARGE_INTEGER),
+      ("LimitFlags", ctypes.wintypes.DWORD),
+      ("MinimumWorkingSetSize", ctypes.c_size_t),
+      ("MaximumWorkingSetSize", ctypes.c_size_t),
+      ("ActiveProcessLimit", ctypes.wintypes.DWORD),
+      ("Affinity", ctypes.POINTER(ctypes.wintypes.ULONG)),
+      ("PriorityClass", ctypes.wintypes.DWORD),
+      ("SchedulingClass", ctypes.wintypes.DWORD),
     ]
 
     @property
@@ -118,23 +118,23 @@
   # https://docs.microsoft.com/windows/desktop/api/winnt/ns-winnt-io_counters
   class IO_COUNTERS(ctypes.Structure):
     _fields_ = [
-        ('ReadOperationCount', ctypes.c_ulonglong),
-        ('WriteOperationCount', ctypes.c_ulonglong),
-        ('OtherOperationCount', ctypes.c_ulonglong),
-        ('ReadTransferCount', ctypes.c_ulonglong),
-        ('WriteTransferCount', ctypes.c_ulonglong),
-        ('OtherTransferCount', ctypes.c_ulonglong),
+      ("ReadOperationCount", ctypes.c_ulonglong),
+      ("WriteOperationCount", ctypes.c_ulonglong),
+      ("OtherOperationCount", ctypes.c_ulonglong),
+      ("ReadTransferCount", ctypes.c_ulonglong),
+      ("WriteTransferCount", ctypes.c_ulonglong),
+      ("OtherTransferCount", ctypes.c_ulonglong),
     ]
 
   # https://docs.microsoft.com/windows/desktop/api/winnt/ns-winnt-_jobobject_extended_limit_information
   class JOBOBJECT_EXTENDED_LIMIT_INFORMATION(ctypes.Structure):
     _fields_ = [
-        ('BasicLimitInformation', JOBOBJECT_BASIC_LIMIT_INFORMATION),
-        ('IoInfo', IO_COUNTERS),
-        ('ProcessMemoryLimit', ctypes.c_size_t),
-        ('JobMemoryLimit', ctypes.c_size_t),
-        ('PeakProcessMemoryUsed', ctypes.c_size_t),
-        ('PeakJobMemoryUsed', ctypes.c_size_t),
+      ("BasicLimitInformation", JOBOBJECT_BASIC_LIMIT_INFORMATION),
+      ("IoInfo", IO_COUNTERS),
+      ("ProcessMemoryLimit", ctypes.c_size_t),
+      ("JobMemoryLimit", ctypes.c_size_t),
+      ("PeakProcessMemoryUsed", ctypes.c_size_t),
+      ("PeakJobMemoryUsed", ctypes.c_size_t),
     ]
 
     @property
@@ -149,7 +149,7 @@
   JOB_OBJECT_UILIMIT_HANDLES = 0x1
 
   class JOBOBJECT_BASIC_UI_RESTRICTIONS(ctypes.Structure):
-    _fields_ = [('UIRestrictionsClass', ctypes.wintypes.DWORD)]
+    _fields_ = [("UIRestrictionsClass", ctypes.wintypes.DWORD)]
 
     @property
     def info_type(self):
@@ -160,19 +160,20 @@
     c_read = wintypes.DWORD()
     buff = ctypes.create_string_buffer(desired_bytes + 1)
     # If it fails, the buffer will probably(?) not be affected.
-    windll.kernel32.ReadFile(handle, buff, desired_bytes,
-                             ctypes.byref(c_read), None)
+    windll.kernel32.ReadFile(
+      handle, buff, desired_bytes, ctypes.byref(c_read), None
+    )
     # NULL terminate it.
-    buff[c_read.value] = b'\x00'
+    buff[c_read.value] = b"\x00"
     return ctypes.GetLastError(), buff.value
 
   def PeekNamedPipe(handle):
     """Calls kernel32.PeekNamedPipe(). Simplified version."""
     c_avail = wintypes.DWORD()
     c_message = wintypes.DWORD()
-    success = windll.kernel32.PeekNamedPipe(handle, None, 0, None,
-                                            ctypes.byref(c_avail),
-                                            ctypes.byref(c_message))
+    success = windll.kernel32.PeekNamedPipe(
+      handle, None, 0, None, ctypes.byref(c_avail), ctypes.byref(c_message)
+    )
     if not success:
       raise OSError(ctypes.GetLastError())
     return c_avail.value
@@ -204,7 +205,7 @@
     # object in Popen or the file object.
     start = time.time()
     handles = [
-        (i, msvcrt.get_osfhandle(c.fileno())) for i, c in enumerate(conns)
+      (i, msvcrt.get_osfhandle(c.fileno())) for i, c in enumerate(conns)
     ]
     while True:
       for index, handle in handles:
@@ -231,8 +232,9 @@
       self._hjob = ctypes.windll.kernel32.CreateJobObjectW(None, None)
       if not self._hjob:
         # pylint: disable=undefined-variable
-        raise WindowsError('Failed to create job object: %s' %
-                           ctypes.GetLastError())
+        raise WindowsError(
+          "Failed to create job object: %s" % ctypes.GetLastError()
+        )
 
       # TODO(maruel): Use a completion port to listen to messages as described
       # at
@@ -242,11 +244,13 @@
       # processes, working set size.
       obj = JOBOBJECT_EXTENDED_LIMIT_INFORMATION()
       obj.BasicLimitInformation.LimitFlags = (
-          JOB_OBJECT_LIMIT_DIE_ON_UNHANDLED_EXCEPTION
-          | JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE)
+        JOB_OBJECT_LIMIT_DIE_ON_UNHANDLED_EXCEPTION
+        | JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE
+      )
       if containment.limit_processes:
         obj.BasicLimitInformation.ActiveProcessLimit = (
-            containment.limit_processes)
+          containment.limit_processes
+        )
         obj.BasicLimitInformation.LimitFlags |= JOB_OBJECT_LIMIT_ACTIVE_PROCESS
       if containment.limit_total_committed_memory:
         obj.BasicLimitInformation.LimitFlags |= JOB_OBJECT_LIMIT_JOB_MEMORY
@@ -258,9 +262,11 @@
       # testing needs. For example many unit tests use the clipboard, or change
       # the display settings (!)
       obj = JOBOBJECT_BASIC_UI_RESTRICTIONS(
-          UIRestrictionsClass=JOB_OBJECT_UILIMIT_DESKTOP
-          | JOB_OBJECT_UILIMIT_EXITWINDOWS | JOB_OBJECT_UILIMIT_GLOBALATOMS
-          | JOB_OBJECT_UILIMIT_HANDLES)
+        UIRestrictionsClass=JOB_OBJECT_UILIMIT_DESKTOP
+        | JOB_OBJECT_UILIMIT_EXITWINDOWS
+        | JOB_OBJECT_UILIMIT_GLOBALATOMS
+        | JOB_OBJECT_UILIMIT_HANDLES
+      )
       self._set_information(obj)
 
     def close(self):
@@ -277,27 +283,34 @@
       # "Kill" the job object instead of the process.
       # https://docs.microsoft.com/windows/desktop/api/jobapi2/nf-jobapi2-terminatejobobject
       return bool(
-          ctypes.windll.kernel32.TerminateJobObject(self._hjob, exit_code))
+        ctypes.windll.kernel32.TerminateJobObject(self._hjob, exit_code)
+      )
 
     def assign_proc(self, proc):
       """Assigns the process handle to the job object."""
       if not ctypes.windll.kernel32.AssignProcessToJobObject(
-          self._hjob, int(proc._handle)):
+        self._hjob, int(proc._handle)
+      ):
         # pylint: disable=undefined-variable
-        raise WindowsError('Failed to assign job object: %s' %
-                           ctypes.GetLastError())
+        raise WindowsError(
+          "Failed to assign job object: %s" % ctypes.GetLastError()
+        )
       if not ctypes.windll.kernel32.ResumeThread(int(proc._handle_thread)):
         # pylint: disable=undefined-variable
-        raise WindowsError('Failed to resume child process thread: %s' %
-                           ctypes.GetLastError())
+        raise WindowsError(
+          "Failed to resume child process thread: %s" % ctypes.GetLastError()
+        )
 
     def _set_information(self, obj):
       # https://docs.microsoft.com/windows/desktop/api/jobapi2/nf-jobapi2-setinformationjobobject
       if not ctypes.windll.kernel32.SetInformationJobObject(
-          self._hjob, obj.info_type, ctypes.byref(obj), ctypes.sizeof(obj)):
+        self._hjob, obj.info_type, ctypes.byref(obj), ctypes.sizeof(obj)
+      ):
         # pylint: disable=undefined-variable
-        raise WindowsError('Failed to adjust job object with type %s: %s' %
-                           (obj.info_type, ctypes.GetLastError()))
+        raise WindowsError(
+          "Failed to adjust job object with type %s: %s"
+          % (obj.info_type, ctypes.GetLastError())
+        )
 
 else:
   import fcntl  # pylint: disable=F0401
@@ -369,6 +382,7 @@
   On Windows, this is done via a Job Object.
   https://docs.microsoft.com/en-us/windows/desktop/procthread/job-objects
   """
+
   # AUTO will use containment if possible, but will not fail if not adequate on
   # this operating system.
   #
@@ -381,15 +395,17 @@
   NONE, AUTO, JOB_OBJECT = range(3)
 
   NAMES = {
-      NONE: 'NONE',
-      AUTO: 'AUTO',
-      JOB_OBJECT: 'JOB_OBJECT',
+    NONE: "NONE",
+    AUTO: "AUTO",
+    JOB_OBJECT: "JOB_OBJECT",
   }
 
-  def __init__(self,
-               containment_type=NONE,
-               limit_processes=0,
-               limit_total_committed_memory=0):
+  def __init__(
+    self,
+    containment_type=NONE,
+    limit_processes=0,
+    limit_total_committed_memory=0,
+  ):
     self.containment_type = containment_type
     # Limit on the number of active processes.
     self.limit_processes = limit_processes
@@ -398,15 +414,18 @@
   def __eq__(self, rhs):
     if not rhs:
       return False
-    return (self.containment_type == rhs.containment_type
-            and self.limit_processes == rhs.limit_processes
-            and self.limit_total_committed_memory
-            == rhs.limit_total_committed_memory)
+    return (
+      self.containment_type == rhs.containment_type
+      and self.limit_processes == rhs.limit_processes
+      and self.limit_total_committed_memory == rhs.limit_total_committed_memory
+    )
 
   def __str__(self):
-    return 'Containment<%s, %s, %s>' % (self.NAMES[self.containment_type],
-                                        self.limit_processes,
-                                        self.limit_total_committed_memory)
+    return "Containment<%s, %s, %s>" % (
+      self.NAMES[self.containment_type],
+      self.limit_processes,
+      self.limit_total_committed_memory,
+    )
 
   def __repr__(self):
     return self.__str__()
@@ -446,6 +465,7 @@
   - recv_any(): reads from stdout and/or stderr with optional timeout.
   - recv_out() & recv_err(): specialized version of recv_any().
   """
+
   # subprocess.Popen.__init__() is not threadsafe; there is a race between
   # creating the exec-error pipe for the child and setting it to CLOEXEC during
   # which another thread can fork and cause the pipe to be inherited by its
@@ -463,58 +483,59 @@
     self._handle = None
     self._job = None
 
-    self.detached = kwargs.pop('detached', False)
+    self.detached = kwargs.pop("detached", False)
     if self.detached:
-      if sys.platform == 'win32':
-        prev = kwargs.get('creationflags', 0)
-        kwargs['creationflags'] = prev | CREATE_NEW_PROCESS_GROUP
+      if sys.platform == "win32":
+        prev = kwargs.get("creationflags", 0)
+        kwargs["creationflags"] = prev | CREATE_NEW_PROCESS_GROUP
       else:
-        old_preexec_fn_1 = kwargs.get('preexec_fn')
+        old_preexec_fn_1 = kwargs.get("preexec_fn")
 
         def new_preexec_fn_1():
           if old_preexec_fn_1:
             old_preexec_fn_1()
           os.setpgid(0, 0)
 
-        kwargs['preexec_fn'] = new_preexec_fn_1
+        kwargs["preexec_fn"] = new_preexec_fn_1
 
-    if kwargs.pop('lower_priority', False):
-      if sys.platform == 'win32':
+    if kwargs.pop("lower_priority", False):
+      if sys.platform == "win32":
         # TODO(maruel): If already in this class, it should use
         # IDLE_PRIORITY_CLASS.
-        prev = kwargs.get('creationflags', 0)
-        kwargs['creationflags'] = prev | BELOW_NORMAL_PRIORITY_CLASS
+        prev = kwargs.get("creationflags", 0)
+        kwargs["creationflags"] = prev | BELOW_NORMAL_PRIORITY_CLASS
       else:
-        old_preexec_fn_2 = kwargs.get('preexec_fn')
+        old_preexec_fn_2 = kwargs.get("preexec_fn")
 
         def new_preexec_fn_2():
           if old_preexec_fn_2:
             old_preexec_fn_2()
           os.nice(1)
 
-        kwargs['preexec_fn'] = new_preexec_fn_2
+        kwargs["preexec_fn"] = new_preexec_fn_2
 
-    self.containment = kwargs.pop('containment', None) or Containment()
+    self.containment = kwargs.pop("containment", None) or Containment()
     if self.containment.containment_type != Containment.NONE:
       if self.containment.containment_type == Containment.JOB_OBJECT:
-        if sys.platform != 'win32':
+        if sys.platform != "win32":
           raise NotImplementedError(
-              'containment is not implemented on this platform')
-      if sys.platform == 'win32':
+            "containment is not implemented on this platform"
+          )
+      if sys.platform == "win32":
         # May throw an WindowsError.
         # pylint: disable=undefined-variable
         self._job = _JobObject(self.containment)
         # In this case, start the process suspended, so we can assign the job
         # object, then resume it.
-        prev = kwargs.get('creationflags', 0)
-        kwargs['creationflags'] = prev | CREATE_SUSPENDED
+        prev = kwargs.get("creationflags", 0)
+        kwargs["creationflags"] = prev | CREATE_SUSPENDED
 
     self.end = None
     self.pgid = None
     self.start = time.time()
     try:
       with self.popen_lock:
-        if sys.platform == 'win32':
+        if sys.platform == "win32":
           # We need the thread handle, save it.
           old = subprocess._winapi.CreateProcess
           old_closehandle = subprocess._winapi.CloseHandle
@@ -536,7 +557,7 @@
         try:
           super(Popen, self).__init__(args, **kwargs)
         finally:
-          if sys.platform == 'win32':
+          if sys.platform == "win32":
             subprocess._winapi.CreateProcess = old
             subprocess._winapi.CloseHandle = old_closehandle
     except:
@@ -544,7 +565,7 @@
       raise
 
     self.args = args
-    if self.detached and sys.platform != 'win32':
+    if self.detached and sys.platform != "win32":
       try:
         self.pgid = os.getpgid(self.pid)
       except OSError:
@@ -583,25 +604,27 @@
     if not timeout:
       return super(Popen, self).communicate(input=input)
 
-    if sys.platform != 'win32':
+    if sys.platform != "win32":
       return super(Popen, self).communicate(
-          input=input,
-          timeout=timeout,
+        input=input,
+        timeout=timeout,
       )
 
     assert isinstance(timeout, (int, float)), timeout
     if self.stdin or self.stdout or self.stderr:
       stdout = None
       if self.stdout:
-        stdout = '' if self.universal_newlines else b''
+        stdout = "" if self.universal_newlines else b""
       stderr = None
       if self.stderr:
-        stderr = '' if self.universal_newlines else b''
+        stderr = "" if self.universal_newlines else b""
 
       t = None
       if input is not None:
-        assert self.stdin, ('Can\'t use communicate(input) if not using '
-                            'Popen(stdin=subprocess42.PIPE')
+        assert self.stdin, (
+          "Can't use communicate(input) if not using "
+          "Popen(stdin=subprocess42.PIPE"
+        )
 
         # TODO(maruel): Switch back to non-threading.
         def write():
@@ -611,7 +634,7 @@
           except IOError:
             pass
 
-        t = threading.Thread(name='Popen.communicate', target=write)
+        t = threading.Thread(name="Popen.communicate", target=write)
         t.daemon = True
         t.start()
 
@@ -626,8 +649,8 @@
           for pipe, data in self.yield_any(timeout=remaining):
             if pipe is None:
               raise TimeoutExpired(self.args, timeout, stdout, stderr)
-            assert pipe in ('stdout', 'stderr'), pipe
-            if pipe == 'stdout':
+            assert pipe in ("stdout", "stderr"), pipe
+            if pipe == "stdout":
               stdout += data
             else:
               stderr += data
@@ -650,10 +673,9 @@
     self.wait()
     return stdout, stderr
 
-  def wait(self,
-           timeout=None,
-           poll_initial_interval=0.001,
-           poll_max_interval=0.05):  # pylint: disable=arguments-differ
+  def wait(
+    self, timeout=None, poll_initial_interval=0.001, poll_max_interval=0.05
+  ):  # pylint: disable=arguments-differ
     """Implements python3's timeout support.
 
     Raises:
@@ -666,18 +688,18 @@
     # to be called continuously within timeout seconds to make the
     # signal handler called right after a signal is sent.
     # timeout is not supported in Python 2 on every platform.
-    if timeout is None and not sys.platform == 'win32':
+    if timeout is None and not sys.platform == "win32":
       super(Popen, self).wait()
-    elif sys.platform != 'win32':
+    elif sys.platform != "win32":
       super(Popen, self).wait(timeout)
     elif self.returncode is None:
       # If you think the following code is horrible, it's because it is
       # inspired by python3's stdlib.
-      if sys.platform == 'win32' and timeout is None:
-        timeout = float('inf')
+      if sys.platform == "win32" and timeout is None:
+        timeout = float("inf")
       end = time.time() + timeout
       delay = poll_initial_interval
-      wait = self._wait_win if sys.platform == 'win32' else self._wait_non_win
+      wait = self._wait_win if sys.platform == "win32" else self._wait_non_win
       while not wait(delay):
         remaining = end - time.time()
         if remaining <= 0:
@@ -691,8 +713,9 @@
     return self.returncode
 
   def _wait_win(self, wait_time):
-    result = subprocess._winapi.WaitForSingleObject(self._handle,
-                                                    int(wait_time * 1000))
+    result = subprocess._winapi.WaitForSingleObject(
+      self._handle, int(wait_time * 1000)
+    )
     if result != _WAIT_TIMEOUT:
       self.returncode = subprocess._winapi.GetExitCodeProcess(self._handle)
       return True
@@ -763,7 +786,8 @@
       if to is not None:
         to = max(to - (time.time() - last_yield), 0)
       t, data = self.recv_any(
-          maxsize=maxsize() if callable(maxsize) else maxsize, timeout=to)
+        maxsize=maxsize() if callable(maxsize) else maxsize, timeout=to
+      )
       if data or to == 0:
         yield t, data
         last_yield = time.time()
@@ -803,7 +827,7 @@
     # to simplify call sites.
     while True:
       pipes = [
-          x for x in ((self.stderr, 'stderr'), (self.stdout, 'stdout')) if x[0]
+        x for x in ((self.stderr, "stderr"), (self.stdout, "stdout")) if x[0]
       ]
       # If both stdout and stderr have the exact file handle, they are
       # effectively the same pipe. Deduplicate it since otherwise it confuses
@@ -831,16 +855,16 @@
       if self.universal_newlines and data:
         if isinstance(data, str):
           data = data.encode()
-        data = self._translate_newlines(data, encoding='utf-8', errors='strict')
+        data = self._translate_newlines(data, encoding="utf-8", errors="strict")
       return names[index], data
 
   def recv_out(self, maxsize=None, timeout=None):
     """Reads from stdout synchronously with timeout."""
-    return self._recv('stdout', maxsize, timeout)
+    return self._recv("stdout", maxsize, timeout)
 
   def recv_err(self, maxsize=None, timeout=None):
     """Reads from stderr synchronously with timeout."""
-    return self._recv('stderr', maxsize, timeout)
+    return self._recv("stderr", maxsize, timeout)
 
   def terminate(self):
     """Tries to do something saner on Windows that the stdlib.
@@ -857,7 +881,7 @@
     On Posix, always send SIGTERM.
     """
     try:
-      if sys.platform == 'win32' and self.detached:
+      if sys.platform == "win32" and self.detached:
         return self.send_signal(signal.CTRL_BREAK_EVENT)
       super(Popen, self).terminate()
     except OSError:
@@ -957,7 +981,7 @@
 
 def call(*args, **kwargs):
   """Adds support for timeout."""
-  timeout = kwargs.pop('timeout', None)
+  timeout = kwargs.pop("timeout", None)
   return Popen(*args, **kwargs).wait(timeout)
 
 
@@ -965,20 +989,20 @@
   """Adds support for timeout."""
   retcode = call(*args, **kwargs)
   if retcode:
-    raise CalledProcessError(retcode, kwargs.get('args') or args[0])
+    raise CalledProcessError(retcode, kwargs.get("args") or args[0])
   return 0
 
 
 def check_output(*args, **kwargs):
   """Adds support for timeout."""
-  timeout = kwargs.pop('timeout', None)
-  if 'stdout' in kwargs:
-    raise ValueError('stdout argument not allowed, it will be overridden.')
+  timeout = kwargs.pop("timeout", None)
+  if "stdout" in kwargs:
+    raise ValueError("stdout argument not allowed, it will be overridden.")
   process = Popen(stdout=PIPE, *args, **kwargs)
   output, _ = process.communicate(timeout=timeout)
   retcode = process.poll()
   if retcode:
-    raise CalledProcessError(retcode, kwargs.get('args') or args[0], output)
+    raise CalledProcessError(retcode, kwargs.get("args") or args[0], output)
   return output
 
 
@@ -1003,7 +1027,7 @@
   global _OS_ERROR_REPORTING_INHIBITED
   if not _OS_ERROR_REPORTING_INHIBITED:
     _OS_ERROR_REPORTING_INHIBITED = True
-    if sys.platform == 'win32':
+    if sys.platform == "win32":
       # Windows has a bad habit of opening a dialog when a console program
       # crashes, rather than just letting it crash. Therefore, when a program
       # crashes on Windows, we don't find out until the build step times out.
@@ -1013,9 +1037,11 @@
       SEM_FAILCRITICALERRORS = 1
       SEM_NOGPFAULTERRORBOX = 2
       SEM_NOALIGNMENTFAULTEXCEPT = 0x8000
-      ctypes.windll.kernel32.SetErrorMode(SEM_FAILCRITICALERRORS
-                                          | SEM_NOGPFAULTERRORBOX
-                                          | SEM_NOALIGNMENTFAULTEXCEPT)
+      ctypes.windll.kernel32.SetErrorMode(
+        SEM_FAILCRITICALERRORS
+        | SEM_NOGPFAULTERRORBOX
+        | SEM_NOALIGNMENTFAULTEXCEPT
+      )
   # TODO(maruel): Other OSes.
   # - OSX, need to figure out a way to make the following process tree local:
   #     defaults write com.apple.CrashReporter UseUNC 1
@@ -1036,15 +1062,15 @@
     An iterator of tuples (pipe_name, bytes) where bytes is the input data
     but split by sep into separate tuples.
   """
-  sep = b'\n'
-  if sys.platform == 'win32':
+  sep = b"\n"
+  if sys.platform == "win32":
     # CRLF is used instead of LF in python3 on windows
-    sep = b'\r\n'
+    sep = b"\r\n"
   if universal_newlines:
     sep = sep.decode()
 
   def _join(d):
-    s = '' if universal_newlines else b''
+    s = "" if universal_newlines else b""
     return s.join(d)
 
   # A dict {pipe_name -> list of pending chunks without separators}
diff --git a/utils/threading_utils.py b/utils/threading_utils.py
index 5c764ad..5980fb2 100644
--- a/utils/threading_utils.py
+++ b/utils/threading_utils.py
@@ -34,7 +34,7 @@
     self._owner = threading.current_thread()
 
   def __exit__(self, _exc_type, _exec_value, _traceback):
-    self.assert_locked('Releasing unowned lock')
+    self.assert_locked("Releasing unowned lock")
     self._owner = None
     self._lock.release()
     return False
@@ -61,6 +61,7 @@
 
   When the priority of tasks match, it works in strict FIFO mode.
   """
+
   QUEUE_CLASS = queue.PriorityQueue
   # Enqueueing None causes the worker to stop.
   # Python3 doesn't support to compare None with any integer, so putting None
@@ -82,10 +83,14 @@
       prefix: Prefix to use for thread names. Pool's threads will be
               named '<prefix>-<thread index>'.
     """
-    prefix = prefix or 'tp-0x%0x' % id(self)
+    prefix = prefix or "tp-0x%0x" % id(self)
     logging.debug(
-        'New ThreadPool(%d, %d, %d): %s', initial_threads, max_threads,
-        queue_size, prefix)
+      "New ThreadPool(%d, %d, %d): %s",
+      initial_threads,
+      max_threads,
+      queue_size,
+      prefix,
+    )
     assert initial_threads <= max_threads
     assert max_threads <= 1024
 
@@ -126,10 +131,11 @@
       if len(self._workers) >= self._max_threads or self._is_closed:
         return False
       worker = threading.Thread(
-        name='%s-%d' % (self._prefix, len(self._workers)), target=self._run)
+        name="%s-%d" % (self._prefix, len(self._workers)), target=self._run
+      )
       self._workers.append(worker)
       self._starting += 1
-    logging.debug('Starting worker thread %s', worker.name)
+    logging.debug("Starting worker thread %s", worker.name)
     worker.daemon = True
     worker.start()
     return True
@@ -155,10 +161,11 @@
     assert callable(func)
     with self._lock:
       if self._is_closed:
-        raise ThreadPoolClosed('Can not add a task to a closed ThreadPool')
+        raise ThreadPoolClosed("Can not add a task to a closed ThreadPool")
       start_new_worker = (
         # Pending task count plus new task > number of available workers.
-        self.tasks.qsize() + 1 > self._ready + self._starting and
+        self.tasks.qsize() + 1 > self._ready + self._starting
+        and
         # Enough slots.
         len(self._workers) < self._max_threads
       )
@@ -195,9 +202,9 @@
           out = func(*args, **kwargs)
           self._output_append(out)
       except Exception as e:
-        logging.warning('Caught exception: %s', e)
+        logging.warning("Caught exception: %s", e)
         exc_info = sys.exc_info()
-        logging.info(''.join(traceback.format_tb(exc_info[2])))
+        logging.info("".join(traceback.format_tb(exc_info[2])))
         with self._outputs_exceptions_cond:
           self._exceptions.append(exc_info)
           self._outputs_exceptions_cond.notifyAll()
@@ -215,8 +222,9 @@
         except Exception as e:
           # We need to catch and log this error here because this is the root
           # function for the thread, nothing higher will catch the error.
-          logging.exception('Caught exception while marking task as done: %s',
-                            e)
+          logging.exception(
+            "Caught exception while marking task as done: %s", e
+          )
 
   def _output_append(self, out):
     if out is not None:
@@ -253,7 +261,7 @@
     for result in self.iter_results():
       return result
     # No results -> tasks queue is empty.
-    raise ThreadPoolEmpty('Task queue is empty')
+    raise ThreadPoolEmpty("Task queue is empty")
 
   def iter_results(self):
     """Yields results as they appear until all tasks are processed."""
@@ -285,7 +293,7 @@
     # a constant after that and can be accessed outside the lock.
     with self._lock:
       if self._is_closed:
-        raise ThreadPoolClosed('Can not close already closed ThreadPool')
+        raise ThreadPoolClosed("Can not close already closed ThreadPool")
       self._is_closed = True
     for _ in range(len(self._workers)):
       self.tasks.put(self.TASK_END_SENTINEL)
@@ -294,8 +302,10 @@
       while t.is_alive():
         t.join(30)
     logging.debug(
-      'Thread pool \'%s\' closed: spawned %d threads total',
-      self._prefix, len(self._workers))
+      "Thread pool '%s' closed: spawned %d threads total",
+      self._prefix,
+      len(self._workers),
+    )
 
   def abort(self):
     """Empties the queue.
@@ -328,8 +338,9 @@
 
 class AutoRetryThreadPool(ThreadPool):
   """Automatically retries enqueued operations on exception."""
+
   # See also PRIORITY_* module-level constants.
-  INTERNAL_PRIORITY_BITS = (1<<8) - 1
+  INTERNAL_PRIORITY_BITS = (1 << 8) - 1
 
   def __init__(self, exceptions, retries, *args, **kwargs):
     """
@@ -338,7 +349,8 @@
       retries: maximum number of retries to do.
     """
     assert exceptions and all(issubclass(e, Exception) for e in exceptions), (
-        exceptions)
+      exceptions
+    )
     assert 1 <= retries <= self.INTERNAL_PRIORITY_BITS
     super(AutoRetryThreadPool, self).__init__(*args, **kwargs)
     self._swallowed_exceptions = tuple(exceptions)
@@ -350,13 +362,8 @@
     """
     assert (priority & self.INTERNAL_PRIORITY_BITS) == 0
     return super(AutoRetryThreadPool, self).add_task(
-        priority,
-        self._task_executer,
-        priority,
-        None,
-        func,
-        *args,
-        **kwargs)
+      priority, self._task_executer, priority, None, func, *args, **kwargs
+    )
 
   def add_task_with_channel(self, channel, priority, func, *args, **kwargs):
     """Tasks added must not use the lower priority bits since they are reserved
@@ -364,13 +371,8 @@
     """
     assert (priority & self.INTERNAL_PRIORITY_BITS) == 0
     return super(AutoRetryThreadPool, self).add_task(
-        priority,
-        self._task_executer,
-        priority,
-        channel,
-        func,
-        *args,
-        **kwargs)
+      priority, self._task_executer, priority, channel, func, *args, **kwargs
+    )
 
   def _task_executer(self, priority, channel, func, *args, **kwargs):
     """Wraps the function and automatically retry on exceptions."""
@@ -386,16 +388,17 @@
       if actual_retries < self._retries:
         priority += 1
         logging.debug(
-            'Swallowed exception \'%s\'. Retrying at lower priority %X',
-            e, priority)
+          "Swallowed exception '%s'. Retrying at lower priority %X", e, priority
+        )
         super(AutoRetryThreadPool, self).add_task(
-            priority,
-            self._task_executer,
-            priority,
-            channel,
-            func,
-            *args,
-            **kwargs)
+          priority,
+          self._task_executer,
+          priority,
+          channel,
+          func,
+          *args,
+          **kwargs,
+        )
         return
       if channel is None:
         raise
@@ -412,6 +415,7 @@
   Supposed to be used for IO bound tasks, and thus default maximum number of
   worker threads is independent of number of CPU cores.
   """
+
   # Initial and maximum number of worker threads.
   INITIAL_WORKERS = 2
   MAX_WORKERS = 16 if sys.maxsize > 2**32 else 8
@@ -419,16 +423,13 @@
 
   def __init__(self):
     super(IOAutoRetryThreadPool, self).__init__(
-        [IOError],
-        self.RETRIES,
-        self.INITIAL_WORKERS,
-        self.MAX_WORKERS,
-        0,
-        'io')
+      [IOError], self.RETRIES, self.INITIAL_WORKERS, self.MAX_WORKERS, 0, "io"
+    )
 
 
 class Progress:
   """Prints progress and accepts updates thread-safely."""
+
   def __init__(self, columns):
     """Creates a Progress bar that will updates asynchronously from the worker
     threads.
@@ -438,13 +439,14 @@
                columns and their initial values.
     """
     assert all(
-        len(c) == 2 and isinstance(c[0], str) and isinstance(c[1], int)
-        for c in columns), columns
+      len(c) == 2 and isinstance(c[0], str) and isinstance(c[1], int)
+      for c in columns
+    ), columns
     # Members to be used exclusively in the primary thread.
     self.use_cr_only = True
     self.unfinished_commands = set()
     self.start = time.time()
-    self._last_printed_line = ''
+    self._last_printed_line = ""
     self._columns = [c[1] for c in columns]
     self._columns_lookup = dict((c[0], i) for i, c in enumerate(columns))
     # Setting it to True forces a print on the first print_update() call.
@@ -492,15 +494,15 @@
       got_one = True
       if raw:
         # Prints the data as-is.
-        self._last_printed_line = ''
-        sys.stdout.write('\n%s\n' % name.strip('\n'))
+        self._last_printed_line = ""
+        sys.stdout.write("\n%s\n" % name.strip("\n"))
       else:
         line, self._last_printed_line = self._gen_line(name)
         sys.stdout.write(line)
 
     if not got_one and self._value_changed:
       # Make sure a line is printed in that case where statistics changes.
-      line, self._last_printed_line = self._gen_line('')
+      line, self._last_printed_line = self._gen_line("")
       sys.stdout.write(line)
       got_one = True
     self._value_changed = False
@@ -510,32 +512,38 @@
       sys.stdout.flush()
 
     if self.unfinished_commands:
-      logging.debug('Waiting for the following commands to finish:\n%s',
-                    '\n'.join(self.unfinished_commands))
+      logging.debug(
+        "Waiting for the following commands to finish:\n%s",
+        "\n".join(self.unfinished_commands),
+      )
 
   def _gen_line(self, name):
     """Generates the line to be printed."""
-    next_line = ('[%s] %6.2fs %s') % (
-        self._render_columns(), time.time() - self.start, name)
+    next_line = ("[%s] %6.2fs %s") % (
+      self._render_columns(),
+      time.time() - self.start,
+      name,
+    )
     # Fill it with whitespace only if self.use_cr_only is set.
-    prefix = ''
+    prefix = ""
     if self.use_cr_only and self._last_printed_line:
-      prefix = '\r'
+      prefix = "\r"
     if self.use_cr_only:
-      suffix = ' ' * max(0, len(self._last_printed_line) - len(next_line))
+      suffix = " " * max(0, len(self._last_printed_line) - len(next_line))
     else:
-      suffix = '\n'
-    return '%s%s%s' % (prefix, next_line, suffix), next_line
+      suffix = "\n"
+    return "%s%s%s" % (prefix, next_line, suffix), next_line
 
   def _render_columns(self):
     """Renders the columns."""
     columns_as_str = map(str, self._columns)
     max_len = max(map(len, columns_as_str))
-    return '/'.join(i.rjust(max_len) for i in columns_as_str)
+    return "/".join(i.rjust(max_len) for i in columns_as_str)
 
 
 class QueueWithProgress(queue.PriorityQueue):
   """Implements progress support in join()."""
+
   def __init__(self, progress, *args, **kwargs):
     queue.PriorityQueue.__init__(self, *args, **kwargs)
     self.progress = progress
@@ -548,12 +556,12 @@
       try:
         unfinished = self.unfinished_tasks - 1
         if unfinished < 0:
-          raise ValueError('task_done() called too many times')
+          raise ValueError("task_done() called too many times")
         self.unfinished_tasks = unfinished
         # This is less efficient, because we want the Progress to be updated.
         self.all_tasks_done.notify_all()
       except Exception as e:
-        logging.exception('task_done threw an exception.\n%s', e)
+        logging.exception("task_done threw an exception.\n%s", e)
 
   def wake_up(self):
     """Wakes up all_tasks_done.
@@ -627,7 +635,7 @@
     """Starts internal watcher thread."""
     assert self._thread is None
     self.ping()
-    self._thread = threading.Thread(name='deadlock-detector', target=self._run)
+    self._thread = threading.Thread(name="deadlock-detector", target=self._run)
     self._thread.daemon = True
     self._thread.start()
     return self
@@ -689,13 +697,13 @@
         continue
 
       # Try to get more informative symbolic thread name.
-      name = 'untitled'
+      name = "untitled"
       for thread in all_threads:
         if thread.ident == thread_id:
           name = thread.name
           break
-      name += ' #%d' % (thread_id,)
-      tracebacks[name] = ''.join(traceback.format_stack(frame))
+      name += " #%d" % (thread_id,)
+      tracebacks[name] = "".join(traceback.format_stack(frame))
 
     # Function to print a message. Makes it easier to change output destination.
     def output(msg):
@@ -703,13 +711,13 @@
 
     # Print tracebacks, sorting them by thread name. That way a thread pool's
     # threads will be printed as one group.
-    output('=============== Potential deadlock detected ===============')
+    output("=============== Potential deadlock detected ===============")
     if timeout is not None:
-      output('No pings in last %d sec.' % (timeout,))
-    output('Dumping stack frames for all threads:')
+      output("No pings in last %d sec." % (timeout,))
+    output("Dumping stack frames for all threads:")
     for name in sorted(tracebacks):
-      output('Traceback for \'%s\':\n%s' % (name, tracebacks[name]))
-    output('===========================================================')
+      output("Traceback for '%s':\n%s" % (name, tracebacks[name]))
+    output("===========================================================")
 
 
 class TaskChannel:
@@ -749,9 +757,10 @@
     # explanation.
     if isinstance(exc_info[1], TaskChannel.Timeout):
       exc_info = (
-          RuntimeError,
-          RuntimeError('Task raised Timeout exception'),
-          exc_info[2])
+        RuntimeError,
+        RuntimeError("Task raised Timeout exception"),
+        exc_info[2],
+      )
     self._queue.put((self._ITEM_EXCEPTION, exc_info))
 
   def __iter__(self):
@@ -776,7 +785,8 @@
     while True:
       try:
         item_type, value = self._queue.get(
-            timeout=timeout if timeout is not None else 30.0)
+          timeout=timeout if timeout is not None else 30.0
+        )
         break
       except queue.Empty:
         if timeout is None:
@@ -792,7 +802,7 @@
       raise value[1]
     if item_type == self._ITEM_DONE:
       raise StopIteration()
-    assert False, 'Impossible queue item type: %r' % item_type
+    assert False, "Impossible queue item type: %r" % item_type
 
   def __next__(self):
     # For python3 compatibility
@@ -800,12 +810,14 @@
 
   def wrap_task(self, task):
     """Decorator that makes a function push results into this channel."""
+
     @functools.wraps(task)
     def wrapped(*args, **kwargs):
       try:
         self.send_result(task(*args, **kwargs))
       except Exception:
         self.send_exception()
+
     return wrapped
 
 
@@ -817,11 +829,12 @@
   try:
     # Multiprocessing
     import multiprocessing
+
     return multiprocessing.cpu_count()
   except:  # pylint: disable=W0702
     try:
       # Mac OS 10.6
-      return int(os.sysconf('SC_NPROCESSORS_ONLN'))  # pylint: disable=E1101
+      return int(os.sysconf("SC_NPROCESSORS_ONLN"))  # pylint: disable=E1101
     except:
       # Some of the windows builders seem to get here.
       return 4
diff --git a/utils/tools.py b/utils/tools.py
index 0951cc7..7a48a16 100644
--- a/utils/tools.py
+++ b/utils/tools.py
@@ -31,6 +31,7 @@
 
 class Profiler:
   """Context manager that records time spend inside its body."""
+
   def __init__(self, name):
     self.name = name
     self.start_time = None
@@ -41,8 +42,9 @@
 
   def __exit__(self, _exc_type, _exec_value, _traceback):
     time_taken = time.time() - self.start_time
-    logging.info('Profiling: Section %s took %3.3f seconds',
-                 self.name, time_taken)
+    logging.info(
+      "Profiling: Section %s took %3.3f seconds", self.name, time_taken
+    )
 
 
 class ProfileCounter:
@@ -61,21 +63,22 @@
 
   @staticmethod
   def summarize_all():
-    print('\nProfiling report:')
-    print('-' * 80)
+    print("\nProfiling report:")
+    print("-" * 80)
     print(
-        '{:<38}{:<10}{:<16}{:<16}'.format(
-            'Name', 'Count', 'Total ms', 'Average ms'))
-    print('-' * 80)
+      "{:<38}{:<10}{:<16}{:<16}".format(
+        "Name", "Count", "Total ms", "Average ms"
+      )
+    )
+    print("-" * 80)
     with ProfileCounter._instances_lock:
       for i in sorted(ProfileCounter._instances, key=lambda x: -x.total_time):
         print(
-            '{:<38}{:<10}{:<16.1f}{:<16.1f}'.format(
-                i.name,
-                i.call_count,
-                i.total_time * 1000,
-                i.average_time * 1000))
-    print('-' * 80)
+          "{:<38}{:<10}{:<16.1f}{:<16.1f}".format(
+            i.name, i.call_count, i.total_time * 1000, i.average_time * 1000
+          )
+        )
+    print("-" * 80)
 
   def __init__(self, name):
     self._lock = threading.Lock()
@@ -108,7 +111,7 @@
       return 0
 
   def __enter__(self):
-    recursion = getattr(self._active, 'recursion', 0)
+    recursion = getattr(self._active, "recursion", 0)
     if not recursion:
       self._active.started = time.time()
     self._active.recursion = recursion + 1
@@ -129,18 +132,21 @@
   The final report is emitted to stdout at the process exit time.
   """
   # No performance impact whatsoever if SWARMING_PROFILE is not set.
-  if os.environ.get('SWARMING_PROFILE') != '1':
+  if os.environ.get("SWARMING_PROFILE") != "1":
     return func
   timer = ProfileCounter(func.__name__)
+
   @functools.wraps(func)
   def wrapper(*args, **kwargs):
     with timer:
       return func(*args, **kwargs)
+
   return wrapper
 
 
 def report_cache_stats_at_exit(func, cache):
   """Registers a hook that reports state of the cache on the process exit."""
+
   # Very dumb. Tries to account for object reuse though.
   def get_size(obj, seen):
     # Use id(...) to avoid triggering __hash__ and comparing by value instead.
@@ -152,14 +158,15 @@
       return size + sum(get_size(x, seen) for x in obj)
     if isinstance(obj, dict):
       return size + sum(
-          get_size(k, seen) + get_size(v, seen) for k, v in obj.items())
+        get_size(k, seen) + get_size(v, seen) for k, v in obj.items()
+      )
     return size
 
   def report_caches_state():
-    print('\nFunction cache report:')
-    print('-' * 80)
-    print('{:<40}{:<16}{:<26}'.format('Name', 'Items', 'Approx size, KB'))
-    print('-' * 80)
+    print("\nFunction cache report:")
+    print("-" * 80)
+    print("{:<40}{:<16}{:<26}".format("Name", "Items", "Approx size, KB"))
+    print("-" * 80)
     with _caches_lock:
       total = 0
       seen_objects = set()
@@ -167,10 +174,11 @@
         size = get_size(cache, seen_objects)
         total += size
         print(
-            '{:<40}{:<16}{:<26}'.format(func.__name__, len(cache), size / 1024))
-    print('-' * 80)
-    print('Total: %.1f MB' % (total / 1024 / 1024,))
-    print('-' * 80)
+          "{:<40}{:<16}{:<26}".format(func.__name__, len(cache), size / 1024)
+        )
+    print("-" * 80)
+    print("Total: %.1f MB" % (total / 1024 / 1024,))
+    print("-" * 80)
 
   with _caches_lock:
     _caches.append((func, cache))
@@ -180,6 +188,7 @@
 
 _CACHED_FUNCS = set()
 
+
 def clear_cache_all():
   for f in _CACHED_FUNCS:
     clear_cache(f)
@@ -201,7 +210,7 @@
   empty = object()
   cache = {}
 
-  if os.environ.get('SWARMING_PROFILE') == '1':
+  if os.environ.get("SWARMING_PROFILE") == "1":
     report_cache_stats_at_exit(func, cache)
 
   @functools.wraps(func)
@@ -219,7 +228,7 @@
 
 def clear_cache(func):
   """Clears all accumulated cached results of the given decorated function."""
-  if not hasattr(func, '__cache__'):
+  if not hasattr(func, "__cache__"):
     logging.debug("This function isn't decorated with @cached properly.")
     return
   func.__cache__.clear()
@@ -227,12 +236,13 @@
 
 class Unbuffered:
   """Disable buffering on a file object."""
+
   def __init__(self, stream):
     self.stream = stream
 
   def write(self, data):
     self.stream.write(data)
-    if '\n' in data:
+    if "\n" in data:
       self.stream.flush()
 
   def __getattr__(self, attr):
@@ -241,11 +251,11 @@
 
 def disable_buffering():
   """Makes this process and child processes stdout unbuffered."""
-  if not os.environ.get('PYTHONUNBUFFERED'):
+  if not os.environ.get("PYTHONUNBUFFERED"):
     # Since sys.stdout is a C++ object, it's impossible to do
     # sys.stdout.write = lambda...
     sys.stdout = Unbuffered(sys.stdout)
-    os.environ['PYTHONUNBUFFERED'] = 'x'
+    os.environ["PYTHONUNBUFFERED"] = "x"
 
 
 def find_executable(cmd, env=None):
@@ -284,13 +294,13 @@
     return os.path.isfile(candidate) and os.access(candidate, os.X_OK)
 
   # anti_sep is like os.path.altsep, but it's always defined
-  anti_sep = '/' if os.path.sep == '\\' else '\\'
+  anti_sep = "/" if os.path.sep == "\\" else "\\"
   cmd = [cmd[0].replace(anti_sep, os.path.sep)] + cmd[1:]
 
   # exts are the file extensions to try. If the command already has an extension
   # or we're not on windows, then we don't try any extensions.
   has_ext = bool(os.path.splitext(cmd[0])[1])
-  exts = ('',) if sys.platform != 'win32' or has_ext else ('.exe', '.bat')
+  exts = ("",) if sys.platform != "win32" or has_ext else (".exe", ".bat")
 
   def _resolve_extension(candidate):
     for ext in exts:
@@ -309,9 +319,9 @@
     return cmd
 
   # We have a non-absolute, non-relative executable, so walk PATH.
-  paths = (os.environ if env is None else env).get('PATH', '').split(os.pathsep)
-  for path in ['.'] + paths:
-    if path == '':
+  paths = (os.environ if env is None else env).get("PATH", "").split(os.pathsep)
+  for path in ["."] + paths:
+    if path == "":
       continue
     resolved = _resolve_extension(os.path.join(os.path.abspath(path), cmd[0]))
     if resolved:
@@ -322,7 +332,7 @@
 
 
 def read_json(filepath):
-  with open(filepath, 'r') as f:
+  with open(filepath, "r") as f:
     return json.load(f)
 
 
@@ -332,14 +342,14 @@
   If dense is True, the json is packed. Otherwise, it is human readable.
   """
   if dense:
-    kwargs = {'sort_keys': True, 'separators': (',', ':')}
+    kwargs = {"sort_keys": True, "separators": (",", ":")}
   else:
-    kwargs = {'sort_keys': True, 'indent': 2}
+    kwargs = {"sort_keys": True, "indent": 2}
 
-  if hasattr(filepath_or_handle, 'write'):
+  if hasattr(filepath_or_handle, "write"):
     json.dump(data, filepath_or_handle, **kwargs)
   else:
-    with open(filepath_or_handle, 'w') as f:
+    with open(filepath_or_handle, "w") as f:
       json.dump(data, f, **kwargs)
 
 
@@ -364,7 +374,7 @@
 
   If environment variable is missing or is set to '0', returns False.
   """
-  return bool(int(os.environ.get(name, '0')))
+  return bool(int(os.environ.get(name, "0")))
 
 
 def is_headless():
@@ -372,7 +382,7 @@
 
   Examines os.environ for presence of SWARMING_HEADLESS var.
   """
-  return get_bool_env_var('SWARMING_HEADLESS')
+  return get_bool_env_var("SWARMING_HEADLESS")
 
 
 def get_cacerts_bundle():
@@ -391,15 +401,14 @@
       return _ca_certs
     # Some rogue process clears /tmp and causes cacert.pem to disappear. Extract
     # to current directory instead. We use our own bundled copy of cacert.pem.
-    _ca_certs = zip_package.extract_resource(utils, 'cacert.pem', temp_dir='.')
+    _ca_certs = zip_package.extract_resource(utils, "cacert.pem", temp_dir=".")
     return _ca_certs
 
 
 def get_os_cacerts_bundle():
-  """Returns paths to CA trust store location for different OS.
-  """
-  if sys.platform == 'linux':
-    return '/etc/ssl/certs/ca-certificates.crt'
+  """Returns paths to CA trust store location for different OS."""
+  if sys.platform == "linux":
+    return "/etc/ssl/certs/ca-certificates.crt"
   return None
 
 
@@ -440,7 +449,7 @@
       # interactive prompt. Make this case work since it's helpful during the
       # python3 transition, as it makes the edit-debug loop much faster.
       root = os.path.dirname(os.getcwd())
-      logging.warning('Falling back to current directory %s', root)
-  sys.path.insert(0, os.path.join(root, 'third_party', 'pyasn1'))
-  sys.path.insert(0, os.path.join(root, 'third_party', 'rsa'))
-  sys.path.insert(0, os.path.join(root, 'third_party'))
+      logging.warning("Falling back to current directory %s", root)
+  sys.path.insert(0, os.path.join(root, "third_party", "pyasn1"))
+  sys.path.insert(0, os.path.join(root, "third_party", "rsa"))
+  sys.path.insert(0, os.path.join(root, "third_party"))
diff --git a/utils/zip_package.py b/utils/zip_package.py
index 308e053..f56eb31 100755
--- a/utils/zip_package.py
+++ b/utils/zip_package.py
@@ -21,12 +21,11 @@
 # Glob patterns for files to exclude from a package by default.
 EXCLUDE_LIST = (
   # Ignore hidden files (including .svn and .git).
-  r'\..*',
-
+  r"\..*",
   # Ignore precompiled python files since they depend on python version and we
   # don't want zip package to be version-depended.
-  r'.*\.pyc$',
-  r'.*\.pyo$',
+  r".*\.pyc$",
+  r".*\.pyo$",
 )
 
 
@@ -52,8 +51,8 @@
     package.zip_into_file('my_zip.zip')
   """
 
-  _FileRef = collections.namedtuple('_FileRef', ['abs_path'])
-  _BufferRef = collections.namedtuple('_BufferRef', ['buffer'])
+  _FileRef = collections.namedtuple("_FileRef", ["abs_path"])
+  _BufferRef = collections.namedtuple("_BufferRef", ["buffer"])
 
   def __init__(self, root):
     """Initializes new empty ZipPackage.
@@ -86,12 +85,13 @@
     # If |archive_path| is not given, ensure that |absolute_path| is under root.
     if not archive_path and not absolute_path.startswith(self.root):
       raise ZipPackageError(
-          'Path %s is not inside root %s' % (absolute_path, self.root))
+        "Path %s is not inside root %s" % (absolute_path, self.root)
+      )
     if not os.path.exists(absolute_path):
-      raise ZipPackageError('No such file: %s' % absolute_path)
+      raise ZipPackageError("No such file: %s" % absolute_path)
     if not os.path.isfile(absolute_path):
-      raise ZipPackageError('Object %s is not a regular file' % absolute_path)
-    archive_path = archive_path or absolute_path[len(self.root):]
+      raise ZipPackageError("Object %s is not a regular file" % absolute_path)
+    archive_path = archive_path or absolute_path[len(self.root) :]
     self._add_entry(archive_path, ZipPackage._FileRef(absolute_path))
 
   def add_python_file(self, absolute_path, archive_path=None):
@@ -100,14 +100,15 @@
     Recognizes *.pyc files and adds corresponding *.py file instead.
     """
     base, ext = os.path.splitext(absolute_path)
-    if ext in ('.pyc', '.pyo'):
-      absolute_path = base + '.py'
-    elif ext != '.py':
-      raise ZipPackageError('Not a python file: %s' % absolute_path)
+    if ext in (".pyc", ".pyo"):
+      absolute_path = base + ".py"
+    elif ext != ".py":
+      raise ZipPackageError("Not a python file: %s" % absolute_path)
     self.add_file(absolute_path, archive_path)
 
-  def add_directory(self, absolute_path, archive_path=None,
-                    exclude=EXCLUDE_LIST):
+  def add_directory(
+    self, absolute_path, archive_path=None, exclude=EXCLUDE_LIST
+  ):
     """Recursively adds all files from given directory to the package.
 
     |archive_path| is a relative path in archive for this directory, by default
@@ -126,24 +127,25 @@
     # If |archive_path| is not given, ensure that |path| is under root.
     if not archive_path and not absolute_path.startswith(self.root):
       raise ZipPackageError(
-          'Path %s is not inside root %s' % (absolute_path, self.root))
+        "Path %s is not inside root %s" % (absolute_path, self.root)
+      )
     if not os.path.exists(absolute_path):
-      raise ZipPackageError('No such directory: %s' % absolute_path)
+      raise ZipPackageError("No such directory: %s" % absolute_path)
     if not os.path.isdir(absolute_path):
-      raise ZipPackageError('Object %s is not a directory' % absolute_path)
+      raise ZipPackageError("Object %s is not a directory" % absolute_path)
 
     # Precompile regular expressions.
     exclude_regexps = [re.compile(r) for r in exclude]
     # Returns True if |name| should be excluded from the package.
     should_exclude = lambda name: any(r.match(name) for r in exclude_regexps)
 
-    archive_path = archive_path or absolute_path[len(self.root):]
+    archive_path = archive_path or absolute_path[len(self.root) :]
     for cur_dir, dirs, files in os.walk(absolute_path):
       # Add all non-excluded files.
       for name in files:
         if not should_exclude(name):
           absolute = os.path.join(cur_dir, name)
-          relative = absolute[len(absolute_path):]
+          relative = absolute[len(absolute_path) :]
           assert absolute.startswith(absolute_path)
           self.add_file(absolute, os.path.join(archive_path, relative))
       # Remove excluded directories from enumeration.
@@ -169,18 +171,18 @@
 
   def zip_into_file(self, path, compress=True):
     """Zips added files into a file on disk."""
-    with open(path, 'wb') as stream:
+    with open(path, "wb") as stream:
       self._zip_into_stream(stream, compress)
 
   def _add_entry(self, archive_path, ref):
     """Adds new zip package entry."""
     # Always use forward slashes in zip.
-    archive_path = archive_path.replace(os.sep, '/')
+    archive_path = archive_path.replace(os.sep, "/")
     # Ensure there are no suspicious components in the path.
-    assert not any(p in ('', '.', '..') for p in archive_path.split('/'))
+    assert not any(p in ("", ".", "..") for p in archive_path.split("/"))
     # Ensure there's no file overwrites.
     if archive_path in self._items:
-      raise ZipPackageError('Duplicated entry: %s' % archive_path)
+      raise ZipPackageError("Duplicated entry: %s" % archive_path)
     self._items[archive_path] = ref
 
   def _zip_into_stream(self, stream, compress):
@@ -192,7 +194,7 @@
       * Entries are sorted by file name in archive.
     """
     compression = zipfile.ZIP_DEFLATED if compress else zipfile.ZIP_STORED
-    zip_file = zipfile.ZipFile(stream, 'w', compression)
+    zip_file = zipfile.ZipFile(stream, "w", compression)
     try:
       for archive_path in sorted(self._items):
         ref = self._items[archive_path]
@@ -201,12 +203,12 @@
         info.create_system = 3
         if isinstance(ref, ZipPackage._FileRef):
           info.external_attr = (os.stat(ref.abs_path)[0] & 0xFFFF) << 16
-          with open(ref.abs_path, 'rb') as f:
+          with open(ref.abs_path, "rb") as f:
             buf = f.read()
         elif isinstance(ref, ZipPackage._BufferRef):
           buf = ref.buffer
         else:
-          assert False, 'Unexpected type %s' % ref
+          assert False, "Unexpected type %s" % ref
         zip_file.writestr(info, buf)
     finally:
       zip_file.close()
@@ -216,7 +218,7 @@
   """Given a module, returns path to a zip package that contains it or None."""
   loader = pkgutil.get_loader(module)
   # Handle zipimporter and its variations.
-  if loader and hasattr(loader, 'archive'):
+  if loader and hasattr(loader, "archive"):
     return loader.archive
 
 
@@ -234,22 +236,22 @@
   Returns path relative to a current directory of when process was started.
   """
   # If running from interactive console __file__ is not defined.
-  main = sys.modules['__main__']
+  main = sys.modules["__main__"]
   path = get_module_zip_archive(main)
   if path:
     return path
 
-  path = getattr(main, '__file__', None)
+  path = getattr(main, "__file__", None)
   if path:
     return path
 
 
 def _write_temp_data(name, data, temp_dir):
   """Writes content-addressed file in `temp_dir` if relevant."""
-  filename = '%s-%s' % (hashlib.sha256(data).hexdigest(), name)
+  filename = "%s-%s" % (hashlib.sha256(data).hexdigest(), name)
   filepath = os.path.join(temp_dir, filename)
   if os.path.isfile(filepath):
-    with open(filepath, 'rb') as f:
+    with open(filepath, "rb") as f:
       if f.read() == data:
         # It already exists.
         return filepath
@@ -257,8 +259,8 @@
     return None
 
   try:
-    fd = os.open(filepath, os.O_WRONLY|os.O_CREAT|os.O_EXCL, 0o600)
-    with os.fdopen(fd, 'wb') as f:
+    fd = os.open(filepath, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
+    with os.fdopen(fd, "wb") as f:
       f.write(data)
     return filepath
   except (IOError, OSError):
@@ -283,26 +285,25 @@
   if not is_zipped_module(package):
     # Package's __file__ attribute is always an absolute path.
     ppath = package.__file__
-    path = os.path.join(os.path.dirname(ppath),
-        resource.replace('/', os.sep))
+    path = os.path.join(os.path.dirname(ppath), resource.replace("/", os.sep))
     if not os.path.exists(path):
-      raise ValueError('No such resource in %s: %s' % (package, resource))
+      raise ValueError("No such resource in %s: %s" % (package, resource))
     return path
 
   # For zipped packages extract the resource into a temp file.
   data = pkgutil.get_data(package.__name__, resource)
   if data is None:
-    raise ValueError('No such resource in zipped %s: %s' % (package, resource))
+    raise ValueError("No such resource in zipped %s: %s" % (package, resource))
 
   if temp_dir:
     filepath = _write_temp_data(os.path.basename(resource), data, temp_dir)
     if filepath:
       return filepath
 
-  fd, filepath = tempfile.mkstemp(prefix='.zip_pkg-',
-                                  suffix='-' + os.path.basename(resource),
-                                  dir=temp_dir)
-  with os.fdopen(fd, 'wb') as stream:
+  fd, filepath = tempfile.mkstemp(
+    prefix=".zip_pkg-", suffix="-" + os.path.basename(resource), dir=temp_dir
+  )
+  with os.fdopen(fd, "wb") as stream:
     stream.write(data)
 
   # Register it for removal when process dies.
@@ -335,9 +336,9 @@
   has other side effects that kicks in, like zlib's library version, compression
   level, order in which the files were specified, etc.
   """
-  assert is_zipped_module(sys.modules['__main__'])
+  assert is_zipped_module(sys.modules["__main__"])
   h = hashlib.sha256()
-  with zipfile.ZipFile(get_main_script_path(), 'r') as z:
+  with zipfile.ZipFile(get_main_script_path(), "r") as z:
     for name in sorted(z.namelist()):
       with z.open(name) as f:
         h.update(str(len(name)).encode())