79 files changed, 20808 insertions, 17789 deletions
diff --git a/.flake8 b/.flake8
index 82453b56..dd7f4d36 100644
--- a/.flake8
+++ b/.flake8
@@ -1,5 +1,8 @@
 [flake8]
 max-line-length = 80
+per-file-ignores =
+    # E501: line too long
+    tests/test_git_superproject.py: E501
 extend-ignore =
    # E203: Whitespace before ':'
    # See https://github.com/PyCQA/pycodestyle/issues/373
diff --git a/color.py b/color.py
index fdd72534..8f29b59f 100644
--- a/color.py
+++ b/color.py
@@ -17,196 +17,200 @@ import sys
 import pager
-COLORS = {None: -1,
+COLORS = {
-          'normal': -1,
+    None: -1,
-          'black': 0,
+    "normal": -1,
-          'red': 1,
+    "black": 0,
-          'green': 2,
+    "red": 1,
-          'yellow': 3,
+    "green": 2,
-          'blue': 4,
+    "yellow": 3,
-          'magenta': 5,
+    "blue": 4,
-          'cyan': 6,
+    "magenta": 5,
-          'white': 7}
+    "cyan": 6,
+    "white": 7,
-ATTRS = {None: -1,
+}
-         'bold': 1,
-         'dim': 2,
+ATTRS = {None: -1, "bold": 1, "dim": 2, "ul": 4, "blink": 5, "reverse": 7}
-         'ul': 4,
-         'blink': 5,
-         'reverse': 7}
 RESET = "\033[m"
 def is_color(s):
-  return s in COLORS
+    return s in COLORS
 def is_attr(s):
-  return s in ATTRS
+    return s in ATTRS
 def _Color(fg=None, bg=None, attr=None):
-  fg = COLORS[fg]
+    fg = COLORS[fg]
-  bg = COLORS[bg]
+    bg = COLORS[bg]
-  attr = ATTRS[attr]
+    attr = ATTRS[attr]
-  if attr >= 0 or fg >= 0 or bg >= 0:
+    if attr >= 0 or fg >= 0 or bg >= 0:
-    need_sep = False
+        need_sep = False
-    code = "\033["
+        code = "\033["
-    if attr >= 0:
+        if attr >= 0:
-      code += chr(ord('0') + attr)
+            code += chr(ord("0") + attr)
-      need_sep = True
+            need_sep = True
-    if fg >= 0:
+        if fg >= 0:
-      if need_sep:
+            if need_sep:
-        code += ';'
+                code += ";"
-      need_sep = True
+            need_sep = True
-      if fg < 8:
+            if fg < 8:
-        code += '3%c' % (ord('0') + fg)
+                code += "3%c" % (ord("0") + fg)
-      else:
+            else:
-        code += '38;5;%d' % fg
+                code += "38;5;%d" % fg
-    if bg >= 0:
+        if bg >= 0:
-      if need_sep:
+            if need_sep:
-        code += ';'
+                code += ";"
-      if bg < 8:
+            if bg < 8:
-        code += '4%c' % (ord('0') + bg)
+                code += "4%c" % (ord("0") + bg)
-      else:
+            else:
-        code += '48;5;%d' % bg
+                code += "48;5;%d" % bg
-    code += 'm'
+        code += "m"
-  else:
+    else:
-    code = ''
+        code = ""
-  return code
+    return code
 DEFAULT = None
 def SetDefaultColoring(state):
-  """Set coloring behavior to |state|.
+    """Set coloring behavior to |state|.
-  This is useful for overriding config options via the command line.
+    This is useful for overriding config options via the command line.
-  """
+    """
-  if state is None:
+    if state is None:
-    # Leave it alone -- return quick!
+        # Leave it alone -- return quick!
-    return
+        return
-  global DEFAULT
+    global DEFAULT
-  state = state.lower()
+    state = state.lower()
-  if state in ('auto',):
+    if state in ("auto",):
-    DEFAULT = state
+        DEFAULT = state
-  elif state in ('always', 'yes', 'true', True):
+    elif state in ("always", "yes", "true", True):
-    DEFAULT = 'always'
+        DEFAULT = "always"
-  elif state in ('never', 'no', 'false', False):
+    elif state in ("never", "no", "false", False):
-    DEFAULT = 'never'
+        DEFAULT = "never"
 class Coloring(object):
-  def __init__(self, config, section_type):
+    def __init__(self, config, section_type):
-    self._section = 'color.%s' % section_type
+        self._section = "color.%s" % section_type
-    self._config = config
+        self._config = config
-    self._out = sys.stdout
+        self._out = sys.stdout
-    on = DEFAULT
+        on = DEFAULT
-    if on is None:
+        if on is None:
-      on = self._config.GetString(self._section)
+            on = self._config.GetString(self._section)
-      if on is None:
+            if on is None:
-        on = self._config.GetString('color.ui')
+                on = self._config.GetString("color.ui")
-    if on == 'auto':
+        if on == "auto":
-      if pager.active or os.isatty(1):
+            if pager.active or os.isatty(1):
-        self._on = True
+                self._on = True
-      else:
+            else:
-        self._on = False
+                self._on = False
-    elif on in ('true', 'always'):
+        elif on in ("true", "always"):
-      self._on = True
+            self._on = True
-    else:
+        else:
-      self._on = False
+            self._on = False
-  def redirect(self, out):
+    def redirect(self, out):
-    self._out = out
+        self._out = out
-  @property
+    @property
-  def is_on(self):
+    def is_on(self):
-    return self._on
+        return self._on
-  def write(self, fmt, *args):
+    def write(self, fmt, *args):
-    self._out.write(fmt % args)
+        self._out.write(fmt % args)
-  def flush(self):
+    def flush(self):
-    self._out.flush()
+        self._out.flush()
-  def nl(self):
+    def nl(self):
-    self._out.write('\n')
+        self._out.write("\n")
-  def printer(self, opt=None, fg=None, bg=None, attr=None):
+    def printer(self, opt=None, fg=None, bg=None, attr=None):
-    s = self
+        s = self
-    c = self.colorer(opt, fg, bg, attr)
+        c = self.colorer(opt, fg, bg, attr)
-    def f(fmt, *args):
+        def f(fmt, *args):
-      s._out.write(c(fmt, *args))
+            s._out.write(c(fmt, *args))
-    return f
-  def nofmt_printer(self, opt=None, fg=None, bg=None, attr=None):
+        return f
-    s = self
-    c = self.nofmt_colorer(opt, fg, bg, attr)
-    def f(fmt):
+    def nofmt_printer(self, opt=None, fg=None, bg=None, attr=None):
-      s._out.write(c(fmt))
+        s = self
-    return f
+        c = self.nofmt_colorer(opt, fg, bg, attr)
-  def colorer(self, opt=None, fg=None, bg=None, attr=None):
+        def f(fmt):
-    if self._on:
+            s._out.write(c(fmt))
-      c = self._parse(opt, fg, bg, attr)
-      def f(fmt, *args):
+        return f
-        output = fmt % args
-        return ''.join([c, output, RESET])
-      return f
-    else:
-      def f(fmt, *args):
+    def colorer(self, opt=None, fg=None, bg=None, attr=None):
-        return fmt % args
+        if self._on:
-      return f
+            c = self._parse(opt, fg, bg, attr)
-  def nofmt_colorer(self, opt=None, fg=None, bg=None, attr=None):
+            def f(fmt, *args):
-    if self._on:
+                output = fmt % args
-      c = self._parse(opt, fg, bg, attr)
+                return "".join([c, output, RESET])
-      def f(fmt):
+            return f
-        return ''.join([c, fmt, RESET])
-      return f
-    else:
-      def f(fmt):
-        return fmt
-      return f
-  def _parse(self, opt, fg, bg, attr):
-    if not opt:
-      return _Color(fg, bg, attr)
-    v = self._config.GetString('%s.%s' % (self._section, opt))
-    if v is None:
-      return _Color(fg, bg, attr)
-    v = v.strip().lower()
-    if v == "reset":
-      return RESET
-    elif v == '':
-      return _Color(fg, bg, attr)
-    have_fg = False
-    for a in v.split(' '):
-      if is_color(a):
-        if have_fg:
-          bg = a
        else:
-          fg = a
-      elif is_attr(a):
-        attr = a
-    return _Color(fg, bg, attr)
+            def f(fmt, *args):
+                return fmt % args
+            return f
+    def nofmt_colorer(self, opt=None, fg=None, bg=None, attr=None):
+        if self._on:
+            c = self._parse(opt, fg, bg, attr)
+            def f(fmt):
+                return "".join([c, fmt, RESET])
+            return f
+        else:
+            def f(fmt):
+                return fmt
+            return f
+    def _parse(self, opt, fg, bg, attr):
+        if not opt:
+            return _Color(fg, bg, attr)
+        v = self._config.GetString("%s.%s" % (self._section, opt))
+        if v is None:
+            return _Color(fg, bg, attr)
+        v = v.strip().lower()
+        if v == "reset":
+            return RESET
+        elif v == "":
+            return _Color(fg, bg, attr)
+        have_fg = False
+        for a in v.split(" "):
+            if is_color(a):
+                if have_fg:
+                    bg = a
+                else:
+                    fg = a
+            elif is_attr(a):
+                attr = a
+        return _Color(fg, bg, attr)
diff --git a/command.py b/command.py
index 68f36f03..939a4630 100644
--- a/command.py
+++ b/command.py
@@ -25,7 +25,7 @@ import progress
 # Are we generating man-pages?
-GENERATE_MANPAGES = os.environ.get('_REPO_GENERATE_MANPAGES_') == ' indeed! '
+GENERATE_MANPAGES = os.environ.get("_REPO_GENERATE_MANPAGES_") == " indeed! "
 # Number of projects to submit to a single worker process at a time.
@@ -43,403 +43,470 @@ DEFAULT_LOCAL_JOBS = min(os.cpu_count(), 8)
 class Command(object):
-  """Base class for any command line action in repo.
+    """Base class for any command line action in repo."""
-  """
+    # Singleton for all commands to track overall repo command execution and
-  # Singleton for all commands to track overall repo command execution and
+    # provide event summary to callers. Only used by sync subcommand currently.
-  # provide event summary to callers.  Only used by sync subcommand currently.
+    #
-  #
+    # NB: This is being replaced by git trace2 events. See git_trace2_event_log.
-  # NB: This is being replaced by git trace2 events.  See git_trace2_event_log.
+    event_log = EventLog()
-  event_log = EventLog()
+    # Whether this command is a "common" one, i.e. whether the user would
-  # Whether this command is a "common" one, i.e. whether the user would commonly
+    # commonly use it or it's a more uncommon command. This is used by the help
-  # use it or it's a more uncommon command.  This is used by the help command to
+    # command to show short-vs-full summaries.
-  # show short-vs-full summaries.
+    COMMON = False
-  COMMON = False
+    # Whether this command supports running in parallel. If greater than 0,
-  # Whether this command supports running in parallel.  If greater than 0,
+    # it is the number of parallel jobs to default to.
-  # it is the number of parallel jobs to default to.
+    PARALLEL_JOBS = None
-  PARALLEL_JOBS = None
+    # Whether this command supports Multi-manifest. If False, then main.py will
-  # Whether this command supports Multi-manifest.  If False, then main.py will
+    # iterate over the manifests and invoke the command once per (sub)manifest.
-  # iterate over the manifests and invoke the command once per (sub)manifest.
+    # This is only checked after calling ValidateOptions, so that partially
-  # This is only checked after calling ValidateOptions, so that partially
+    # migrated subcommands can set it to False.
-  # migrated subcommands can set it to False.
+    MULTI_MANIFEST_SUPPORT = True
-  MULTI_MANIFEST_SUPPORT = True
+    def __init__(
-  def __init__(self, repodir=None, client=None, manifest=None, gitc_manifest=None,
+        self,
-               git_event_log=None, outer_client=None, outer_manifest=None):
+        repodir=None,
-    self.repodir = repodir
+        client=None,
-    self.client = client
+        manifest=None,
-    self.outer_client = outer_client or client
+        gitc_manifest=None,
-    self.manifest = manifest
+        git_event_log=None,
-    self.gitc_manifest = gitc_manifest
+        outer_client=None,
-    self.git_event_log = git_event_log
+        outer_manifest=None,
-    self.outer_manifest = outer_manifest
+    ):
+        self.repodir = repodir
-    # Cache for the OptionParser property.
+        self.client = client
-    self._optparse = None
+        self.outer_client = outer_client or client
+        self.manifest = manifest
-  def WantPager(self, _opt):
+        self.gitc_manifest = gitc_manifest
-    return False
+        self.git_event_log = git_event_log
+        self.outer_manifest = outer_manifest
-  def ReadEnvironmentOptions(self, opts):
-    """ Set options from environment variables. """
+        # Cache for the OptionParser property.
+        self._optparse = None
-    env_options = self._RegisteredEnvironmentOptions()
+    def WantPager(self, _opt):
-    for env_key, opt_key in env_options.items():
+        return False
-      # Get the user-set option value if any
-      opt_value = getattr(opts, opt_key)
+    def ReadEnvironmentOptions(self, opts):
+        """Set options from environment variables."""
-      # If the value is set, it means the user has passed it as a command
-      # line option, and we should use that.  Otherwise we can try to set it
+        env_options = self._RegisteredEnvironmentOptions()
-      # with the value from the corresponding environment variable.
-      if opt_value is not None:
+        for env_key, opt_key in env_options.items():
-        continue
+            # Get the user-set option value if any
+            opt_value = getattr(opts, opt_key)
-      env_value = os.environ.get(env_key)
-      if env_value is not None:
+            # If the value is set, it means the user has passed it as a command
-        setattr(opts, opt_key, env_value)
+            # line option, and we should use that. Otherwise we can try to set
+            # it with the value from the corresponding environment variable.
-    return opts
+            if opt_value is not None:
+                continue
-  @property
-  def OptionParser(self):
+            env_value = os.environ.get(env_key)
-    if self._optparse is None:
+            if env_value is not None:
-      try:
+                setattr(opts, opt_key, env_value)
-        me = 'repo %s' % self.NAME
-        usage = self.helpUsage.strip().replace('%prog', me)
+        return opts
-      except AttributeError:
-        usage = 'repo %s' % self.NAME
+    @property
-      epilog = 'Run `repo help %s` to view the detailed manual.' % self.NAME
+    def OptionParser(self):
-      self._optparse = optparse.OptionParser(usage=usage, epilog=epilog)
+        if self._optparse is None:
-      self._CommonOptions(self._optparse)
+            try:
-      self._Options(self._optparse)
+                me = "repo %s" % self.NAME
-    return self._optparse
+                usage = self.helpUsage.strip().replace("%prog", me)
+            except AttributeError:
-  def _CommonOptions(self, p, opt_v=True):
+                usage = "repo %s" % self.NAME
-    """Initialize the option parser with common options.
+            epilog = (
+                "Run `repo help %s` to view the detailed manual." % self.NAME
-    These will show up for *all* subcommands, so use sparingly.
+            )
-    NB: Keep in sync with repo:InitParser().
+            self._optparse = optparse.OptionParser(usage=usage, epilog=epilog)
-    """
+            self._CommonOptions(self._optparse)
-    g = p.add_option_group('Logging options')
+            self._Options(self._optparse)
-    opts = ['-v'] if opt_v else []
+        return self._optparse
-    g.add_option(*opts, '--verbose',
-                 dest='output_mode', action='store_true',
+    def _CommonOptions(self, p, opt_v=True):
-                 help='show all output')
+        """Initialize the option parser with common options.
-    g.add_option('-q', '--quiet',
-                 dest='output_mode', action='store_false',
+        These will show up for *all* subcommands, so use sparingly.
-                 help='only show errors')
+        NB: Keep in sync with repo:InitParser().
+        """
-    if self.PARALLEL_JOBS is not None:
+        g = p.add_option_group("Logging options")
-      default = 'based on number of CPU cores'
+        opts = ["-v"] if opt_v else []
-      if not GENERATE_MANPAGES:
+        g.add_option(
-        # Only include active cpu count if we aren't generating man pages.
+            *opts,
-        default = f'%default; {default}'
+            "--verbose",
-      p.add_option(
+            dest="output_mode",
-          '-j', '--jobs',
+            action="store_true",
-          type=int, default=self.PARALLEL_JOBS,
+            help="show all output",
-          help=f'number of jobs to run in parallel (default: {default})')
+        )
+        g.add_option(
-    m = p.add_option_group('Multi-manifest options')
+            "-q",
-    m.add_option('--outer-manifest', action='store_true', default=None,
+            "--quiet",
-                 help='operate starting at the outermost manifest')
+            dest="output_mode",
-    m.add_option('--no-outer-manifest', dest='outer_manifest',
+            action="store_false",
-                 action='store_false', help='do not operate on outer manifests')
+            help="only show errors",
-    m.add_option('--this-manifest-only', action='store_true', default=None,
+        )
-                 help='only operate on this (sub)manifest')
-    m.add_option('--no-this-manifest-only', '--all-manifests',
+        if self.PARALLEL_JOBS is not None:
-                 dest='this_manifest_only', action='store_false',
+            default = "based on number of CPU cores"
-                 help='operate on this manifest and its submanifests')
+            if not GENERATE_MANPAGES:
+                # Only include active cpu count if we aren't generating man
-  def _Options(self, p):
+                # pages.
-    """Initialize the option parser with subcommand-specific options."""
+                default = f"%default; {default}"
+            p.add_option(
-  def _RegisteredEnvironmentOptions(self):
+                "-j",
-    """Get options that can be set from environment variables.
+                "--jobs",
+                type=int,
-    Return a dictionary mapping environment variable name
+                default=self.PARALLEL_JOBS,
-    to option key name that it can override.
+                help=f"number of jobs to run in parallel (default: {default})",
+            )
-    Example: {'REPO_MY_OPTION': 'my_option'}
+        m = p.add_option_group("Multi-manifest options")
-    Will allow the option with key value 'my_option' to be set
+        m.add_option(
-    from the value in the environment variable named 'REPO_MY_OPTION'.
+            "--outer-manifest",
+            action="store_true",
-    Note: This does not work properly for options that are explicitly
+            default=None,
-    set to None by the user, or options that are defined with a
+            help="operate starting at the outermost manifest",
-    default value other than None.
+        )
+        m.add_option(
-    """
+            "--no-outer-manifest",
-    return {}
+            dest="outer_manifest",
+            action="store_false",
-  def Usage(self):
+            help="do not operate on outer manifests",
-    """Display usage and terminate.
+        )
-    """
+        m.add_option(
-    self.OptionParser.print_usage()
+            "--this-manifest-only",
-    sys.exit(1)
+            action="store_true",
+            default=None,
-  def CommonValidateOptions(self, opt, args):
+            help="only operate on this (sub)manifest",
-    """Validate common options."""
+        )
-    opt.quiet = opt.output_mode is False
+        m.add_option(
-    opt.verbose = opt.output_mode is True
+            "--no-this-manifest-only",
-    if opt.outer_manifest is None:
+            "--all-manifests",
-      # By default, treat multi-manifest instances as a single manifest from
+            dest="this_manifest_only",
-      # the user's perspective.
+            action="store_false",
-      opt.outer_manifest = True
+            help="operate on this manifest and its submanifests",
+        )
-  def ValidateOptions(self, opt, args):
-    """Validate the user options & arguments before executing.
+    def _Options(self, p):
+        """Initialize the option parser with subcommand-specific options."""
-    This is meant to help break the code up into logical steps.  Some tips:
-    * Use self.OptionParser.error to display CLI related errors.
+    def _RegisteredEnvironmentOptions(self):
-    * Adjust opt member defaults as makes sense.
+        """Get options that can be set from environment variables.
-    * Adjust the args list, but do so inplace so the caller sees updates.
-    * Try to avoid updating self state.  Leave that to Execute.
+        Return a dictionary mapping environment variable name
-    """
+        to option key name that it can override.
-  def Execute(self, opt, args):
+        Example: {'REPO_MY_OPTION': 'my_option'}
-    """Perform the action, after option parsing is complete.
-    """
+        Will allow the option with key value 'my_option' to be set
-    raise NotImplementedError
+        from the value in the environment variable named 'REPO_MY_OPTION'.
-  @staticmethod
+        Note: This does not work properly for options that are explicitly
-  def ExecuteInParallel(jobs, func, inputs, callback, output=None, ordered=False):
+        set to None by the user, or options that are defined with a
-    """Helper for managing parallel execution boiler plate.
+        default value other than None.
-    For subcommands that can easily split their work up.
+        """
+        return {}
-    Args:
-      jobs: How many parallel processes to use.
+    def Usage(self):
-      func: The function to apply to each of the |inputs|.  Usually a
+        """Display usage and terminate."""
-          functools.partial for wrapping additional arguments.  It will be run
+        self.OptionParser.print_usage()
-          in a separate process, so it must be pickalable, so nested functions
+        sys.exit(1)
-          won't work.  Methods on the subcommand Command class should work.
-      inputs: The list of items to process.  Must be a list.
+    def CommonValidateOptions(self, opt, args):
-      callback: The function to pass the results to for processing.  It will be
+        """Validate common options."""
-          executed in the main thread and process the results of |func| as they
+        opt.quiet = opt.output_mode is False
-          become available.  Thus it may be a local nested function.  Its return
+        opt.verbose = opt.output_mode is True
-          value is passed back directly.  It takes three arguments:
+        if opt.outer_manifest is None:
-          - The processing pool (or None with one job).
+            # By default, treat multi-manifest instances as a single manifest
-          - The |output| argument.
+            # from the user's perspective.
-          - An iterator for the results.
+            opt.outer_manifest = True
-      output: An output manager.  May be progress.Progess or color.Coloring.
-      ordered: Whether the jobs should be processed in order.
+    def ValidateOptions(self, opt, args):
+        """Validate the user options & arguments before executing.
-    Returns:
-      The |callback| function's results are returned.
+        This is meant to help break the code up into logical steps. Some tips:
-    """
+        * Use self.OptionParser.error to display CLI related errors.
-    try:
+        * Adjust opt member defaults as makes sense.
-      # NB: Multiprocessing is heavy, so don't spin it up for one job.
+        * Adjust the args list, but do so inplace so the caller sees updates.
-      if len(inputs) == 1 or jobs == 1:
+        * Try to avoid updating self state. Leave that to Execute.
-        return callback(None, output, (func(x) for x in inputs))
+        """
-      else:
-        with multiprocessing.Pool(jobs) as pool:
+    def Execute(self, opt, args):
-          submit = pool.imap if ordered else pool.imap_unordered
+        """Perform the action, after option parsing is complete."""
-          return callback(pool, output, submit(func, inputs, chunksize=WORKER_BATCH_SIZE))
+        raise NotImplementedError
-    finally:
-      if isinstance(output, progress.Progress):
+    @staticmethod
-        output.end()
+    def ExecuteInParallel(
+        jobs, func, inputs, callback, output=None, ordered=False
-  def _ResetPathToProjectMap(self, projects):
+    ):
-    self._by_path = dict((p.worktree, p) for p in projects)
+        """Helper for managing parallel execution boiler plate.
-  def _UpdatePathToProjectMap(self, project):
+        For subcommands that can easily split their work up.
-    self._by_path[project.worktree] = project
+        Args:
-  def _GetProjectByPath(self, manifest, path):
+            jobs: How many parallel processes to use.
-    project = None
+            func: The function to apply to each of the |inputs|. Usually a
-    if os.path.exists(path):
+                functools.partial for wrapping additional arguments. It will be
-      oldpath = None
+                run in a separate process, so it must be pickalable, so nested
-      while (path and
+                functions won't work. Methods on the subcommand Command class
-             path != oldpath and
+                should work.
-             path != manifest.topdir):
+            inputs: The list of items to process. Must be a list.
+            callback: The function to pass the results to for processing. It
+                will be executed in the main thread and process the results of
+                |func| as they become available. Thus it may be a local nested
+                function. Its return value is passed back directly. It takes
+                three arguments:
+                - The processing pool (or None with one job).
+                - The |output| argument.
+                - An iterator for the results.
+            output: An output manager. May be progress.Progess or
+                color.Coloring.
+            ordered: Whether the jobs should be processed in order.
+        Returns:
+            The |callback| function's results are returned.
+        """
        try:
-          project = self._by_path[path]
+            # NB: Multiprocessing is heavy, so don't spin it up for one job.
-          break
+            if len(inputs) == 1 or jobs == 1:
-        except KeyError:
+                return callback(None, output, (func(x) for x in inputs))
-          oldpath = path
+            else:
-          path = os.path.dirname(path)
+                with multiprocessing.Pool(jobs) as pool:
-      if not project and path == manifest.topdir:
+                    submit = pool.imap if ordered else pool.imap_unordered
-        try:
+                    return callback(
-          project = self._by_path[path]
+                        pool,
-        except KeyError:
+                        output,
-          pass
+                        submit(func, inputs, chunksize=WORKER_BATCH_SIZE),
-    else:
+                    )
-      try:
+        finally:
-        project = self._by_path[path]
+            if isinstance(output, progress.Progress):
-      except KeyError:
+                output.end()
-        pass
-    return project
+    def _ResetPathToProjectMap(self, projects):
+        self._by_path = dict((p.worktree, p) for p in projects)
-  def GetProjects(self, args, manifest=None, groups='', missing_ok=False,
-                  submodules_ok=False, all_manifests=False):
+    def _UpdatePathToProjectMap(self, project):
-    """A list of projects that match the arguments.
+        self._by_path[project.worktree] = project
-    Args:
+    def _GetProjectByPath(self, manifest, path):
-      args: a list of (case-insensitive) strings, projects to search for.
+        project = None
-      manifest: an XmlManifest, the manifest to use, or None for default.
+        if os.path.exists(path):
-      groups: a string, the manifest groups in use.
+            oldpath = None
-      missing_ok: a boolean, whether to allow missing projects.
+            while path and path != oldpath and path != manifest.topdir:
-      submodules_ok: a boolean, whether to allow submodules.
+                try:
-      all_manifests: a boolean, if True then all manifests and submanifests are
+                    project = self._by_path[path]
-                     used.  If False, then only the local (sub)manifest is used.
+                    break
+                except KeyError:
-    Returns:
+                    oldpath = path
-      A list of matching Project instances.
+                    path = os.path.dirname(path)
-    """
+            if not project and path == manifest.topdir:
-    if all_manifests:
+                try:
-      if not manifest:
+                    project = self._by_path[path]
-        manifest = self.manifest.outer_client
+                except KeyError:
-      all_projects_list = manifest.all_projects
+                    pass
-    else:
+        else:
-      if not manifest:
+            try:
-        manifest = self.manifest
+                project = self._by_path[path]
-      all_projects_list = manifest.projects
+            except KeyError:
-    result = []
+                pass
+        return project
-    if not groups:
-      groups = manifest.GetGroupsStr()
+    def GetProjects(
-    groups = [x for x in re.split(r'[,\s]+', groups) if x]
+        self,
+        args,
-    if not args:
+        manifest=None,
-      derived_projects = {}
+        groups="",
-      for project in all_projects_list:
+        missing_ok=False,
-        if submodules_ok or project.sync_s:
+        submodules_ok=False,
-          derived_projects.update((p.name, p)
+        all_manifests=False,
-                                  for p in project.GetDerivedSubprojects())
+    ):
-      all_projects_list.extend(derived_projects.values())
+        """A list of projects that match the arguments.
-      for project in all_projects_list:
-        if (missing_ok or project.Exists) and project.MatchesGroups(groups):
+        Args:
-          result.append(project)
+            args: a list of (case-insensitive) strings, projects to search for.
-    else:
+            manifest: an XmlManifest, the manifest to use, or None for default.
-      self._ResetPathToProjectMap(all_projects_list)
+            groups: a string, the manifest groups in use.
+            missing_ok: a boolean, whether to allow missing projects.
-      for arg in args:
+            submodules_ok: a boolean, whether to allow submodules.
-        # We have to filter by manifest groups in case the requested project is
+            all_manifests: a boolean, if True then all manifests and
-        # checked out multiple times or differently based on them.
+                submanifests are used. If False, then only the local
-        projects = [project
+                (sub)manifest is used.
+        Returns:
+            A list of matching Project instances.
+        """
+        if all_manifests:
+            if not manifest:
+                manifest = self.manifest.outer_client
+            all_projects_list = manifest.all_projects
+        else:
+            if not manifest:
+                manifest = self.manifest
+            all_projects_list = manifest.projects
+        result = []
+        if not groups:
+            groups = manifest.GetGroupsStr()
+        groups = [x for x in re.split(r"[,\s]+", groups) if x]
+        if not args:
+            derived_projects = {}
+            for project in all_projects_list:
+                if submodules_ok or project.sync_s:
+                    derived_projects.update(
+                        (p.name, p) for p in project.GetDerivedSubprojects()
+                    )
+            all_projects_list.extend(derived_projects.values())
+            for project in all_projects_list:
+                if (missing_ok or project.Exists) and project.MatchesGroups(
+                    groups
+                ):
+                    result.append(project)
+        else:
+            self._ResetPathToProjectMap(all_projects_list)
+            for arg in args:
+                # We have to filter by manifest groups in case the requested
+                # project is checked out multiple times or differently based on
+                # them.
+                projects = [
+                    project
                    for project in manifest.GetProjectsWithName(
-                        arg, all_manifests=all_manifests)
+                        arg, all_manifests=all_manifests
-                    if project.MatchesGroups(groups)]
+                    )
+                    if project.MatchesGroups(groups)
-        if not projects:
+                ]
-          path = os.path.abspath(arg).replace('\\', '/')
-          tree = manifest
+                if not projects:
-          if all_manifests:
+                    path = os.path.abspath(arg).replace("\\", "/")
-            # Look for the deepest matching submanifest.
+                    tree = manifest
-            for tree in reversed(list(manifest.all_manifests)):
+                    if all_manifests:
-              if path.startswith(tree.topdir):
+                        # Look for the deepest matching submanifest.
-                break
+                        for tree in reversed(list(manifest.all_manifests)):
-          project = self._GetProjectByPath(tree, path)
+                            if path.startswith(tree.topdir):
+                                break
-          # If it's not a derived project, update path->project mapping and
+                    project = self._GetProjectByPath(tree, path)
-          # search again, as arg might actually point to a derived subproject.
-          if (project and not project.Derived and (submodules_ok or
+                    # If it's not a derived project, update path->project
-                                                   project.sync_s)):
+                    # mapping and search again, as arg might actually point to
-            search_again = False
+                    # a derived subproject.
-            for subproject in project.GetDerivedSubprojects():
+                    if (
-              self._UpdatePathToProjectMap(subproject)
+                        project
-              search_again = True
+                        and not project.Derived
-            if search_again:
+                        and (submodules_ok or project.sync_s)
-              project = self._GetProjectByPath(manifest, path) or project
+                    ):
+                        search_again = False
-          if project:
+                        for subproject in project.GetDerivedSubprojects():
-            projects = [project]
+                            self._UpdatePathToProjectMap(subproject)
+                            search_again = True
-        if not projects:
+                        if search_again:
-          raise NoSuchProjectError(arg)
+                            project = (
+                                self._GetProjectByPath(manifest, path)
-        for project in projects:
+                                or project
-          if not missing_ok and not project.Exists:
+                            )
-            raise NoSuchProjectError('%s (%s)' % (
-                arg, project.RelPath(local=not all_manifests)))
+                    if project:
-          if not project.MatchesGroups(groups):
+                        projects = [project]
-            raise InvalidProjectGroupsError(arg)
+                if not projects:
-        result.extend(projects)
+                    raise NoSuchProjectError(arg)
-    def _getpath(x):
+                for project in projects:
-      return x.relpath
+                    if not missing_ok and not project.Exists:
-    result.sort(key=_getpath)
+                        raise NoSuchProjectError(
-    return result
+                            "%s (%s)"
+                            % (arg, project.RelPath(local=not all_manifests))
-  def FindProjects(self, args, inverse=False, all_manifests=False):
+                        )
-    """Find projects from command line arguments.
+                    if not project.MatchesGroups(groups):
+                        raise InvalidProjectGroupsError(arg)
-    Args:
-      args: a list of (case-insensitive) strings, projects to search for.
+                result.extend(projects)
-      inverse: a boolean, if True, then projects not matching any |args| are
-               returned.
+        def _getpath(x):
-      all_manifests: a boolean, if True then all manifests and submanifests are
+            return x.relpath
-                     used.  If False, then only the local (sub)manifest is used.
-    """
+        result.sort(key=_getpath)
-    result = []
+        return result
-    patterns = [re.compile(r'%s' % a, re.IGNORECASE) for a in args]
-    for project in self.GetProjects('', all_manifests=all_manifests):
+    def FindProjects(self, args, inverse=False, all_manifests=False):
-      paths = [project.name, project.RelPath(local=not all_manifests)]
+        """Find projects from command line arguments.
-      for pattern in patterns:
-        match = any(pattern.search(x) for x in paths)
+        Args:
-        if not inverse and match:
+            args: a list of (case-insensitive) strings, projects to search for.
-          result.append(project)
+            inverse: a boolean, if True, then projects not matching any |args|
-          break
+                are returned.
-        if inverse and match:
+            all_manifests: a boolean, if True then all manifests and
-          break
+                submanifests are used. If False, then only the local
-      else:
+                (sub)manifest is used.
-        if inverse:
+        """
-          result.append(project)
+        result = []
-    result.sort(key=lambda project: (project.manifest.path_prefix,
+        patterns = [re.compile(r"%s" % a, re.IGNORECASE) for a in args]
-                                     project.relpath))
+        for project in self.GetProjects("", all_manifests=all_manifests):
-    return result
+            paths = [project.name, project.RelPath(local=not all_manifests)]
+            for pattern in patterns:
-  def ManifestList(self, opt):
+                match = any(pattern.search(x) for x in paths)
-    """Yields all of the manifests to traverse.
+                if not inverse and match:
+                    result.append(project)
-    Args:
+                    break
-      opt: The command options.
+                if inverse and match:
-    """
+                    break
-    top = self.outer_manifest
+            else:
-    if not opt.outer_manifest or opt.this_manifest_only:
+                if inverse:
-      top = self.manifest
+                    result.append(project)
-    yield top
+        result.sort(
-    if not opt.this_manifest_only:
+            key=lambda project: (project.manifest.path_prefix, project.relpath)
-      for child in top.all_children:
+        )
-        yield child
+        return result
+    def ManifestList(self, opt):
+        """Yields all of the manifests to traverse.
+        Args:
+            opt: The command options.
+        """
+        top = self.outer_manifest
+        if not opt.outer_manifest or opt.this_manifest_only:
+            top = self.manifest
+        yield top
+        if not opt.this_manifest_only:
+            for child in top.all_children:
+                yield child
 class InteractiveCommand(Command):
-  """Command which requires user interaction on the tty and
+    """Command which requires user interaction on the tty and must not run
-     must not run within a pager, even if the user asks to.
+    within a pager, even if the user asks to.
-  """
+    """
-  def WantPager(self, _opt):
+    def WantPager(self, _opt):
-    return False
+        return False
 class PagedCommand(Command):
-  """Command which defaults to output in a pager, as its
+    """Command which defaults to output in a pager, as its display tends to be
-     display tends to be larger than one screen full.
+    larger than one screen full.
-  """
+    """
-  def WantPager(self, _opt):
+    def WantPager(self, _opt):
-    return True
+        return True
 class MirrorSafeCommand(object):
-  """Command permits itself to run within a mirror,
+    """Command permits itself to run within a mirror, and does not require a
-     and does not require a working directory.
+    working directory.
-  """
+    """
 class GitcAvailableCommand(object):
-  """Command that requires GITC to be available, but does
+    """Command that requires GITC to be available, but does not require the
-     not require the local client to be a GITC client.
+    local client to be a GITC client.
-  """
+    """
 class GitcClientCommand(object):
-  """Command that requires the local client to be a GITC
+    """Command that requires the local client to be a GITC client."""
-     client.
-  """
diff --git a/editor.py b/editor.py
index b84a42d4..96835aba 100644
--- a/editor.py
+++ b/editor.py
@@ -23,93 +23,99 @@ import platform_utils
 class Editor(object):
-  """Manages the user's preferred text editor."""
+    """Manages the user's preferred text editor."""
-  _editor = None
+    _editor = None
-  globalConfig = None
+    globalConfig = None
-  @classmethod
+    @classmethod
-  def _GetEditor(cls):
+    def _GetEditor(cls):
-    if cls._editor is None:
+        if cls._editor is None:
-      cls._editor = cls._SelectEditor()
+            cls._editor = cls._SelectEditor()
-    return cls._editor
+        return cls._editor
-  @classmethod
+    @classmethod
-  def _SelectEditor(cls):
+    def _SelectEditor(cls):
-    e = os.getenv('GIT_EDITOR')
+        e = os.getenv("GIT_EDITOR")
-    if e:
+        if e:
-      return e
+            return e
-    if cls.globalConfig:
+        if cls.globalConfig:
-      e = cls.globalConfig.GetString('core.editor')
+            e = cls.globalConfig.GetString("core.editor")
-      if e:
+            if e:
-        return e
+                return e
-    e = os.getenv('VISUAL')
+        e = os.getenv("VISUAL")
-    if e:
+        if e:
-      return e
+            return e
-    e = os.getenv('EDITOR')
+        e = os.getenv("EDITOR")
-    if e:
+        if e:
-      return e
+            return e
-    if os.getenv('TERM') == 'dumb':
+        if os.getenv("TERM") == "dumb":
-      print(
+            print(
-          """No editor specified in GIT_EDITOR, core.editor, VISUAL or EDITOR.
+                """No editor specified in GIT_EDITOR, core.editor, VISUAL or EDITOR.
 Tried to fall back to vi but terminal is dumb.  Please configure at
-least one of these before using this command.""", file=sys.stderr)
+least one of these before using this command.""",  # noqa: E501
-      sys.exit(1)
+                file=sys.stderr,
+            )
-    return 'vi'
+            sys.exit(1)
-  @classmethod
+        return "vi"
-  def EditString(cls, data):
-    """Opens an editor to edit the given content.
+    @classmethod
+    def EditString(cls, data):
-    Args:
+        """Opens an editor to edit the given content.
-      data: The text to edit.
+        Args:
-    Returns:
+            data: The text to edit.
-      New value of edited text.
+        Returns:
-    Raises:
+            New value of edited text.
-      EditorError: The editor failed to run.
-    """
+        Raises:
-    editor = cls._GetEditor()
+            EditorError: The editor failed to run.
-    if editor == ':':
+        """
-      return data
+        editor = cls._GetEditor()
+        if editor == ":":
-    fd, path = tempfile.mkstemp()
+            return data
-    try:
-      os.write(fd, data.encode('utf-8'))
+        fd, path = tempfile.mkstemp()
-      os.close(fd)
+        try:
-      fd = None
+            os.write(fd, data.encode("utf-8"))
+            os.close(fd)
-      if platform_utils.isWindows():
+            fd = None
-        # Split on spaces, respecting quoted strings
-        import shlex
+            if platform_utils.isWindows():
-        args = shlex.split(editor)
+                # Split on spaces, respecting quoted strings
-        shell = False
+                import shlex
-      elif re.compile("^.*[$ \t'].*$").match(editor):
-        args = [editor + ' "$@"', 'sh']
+                args = shlex.split(editor)
-        shell = True
+                shell = False
-      else:
+            elif re.compile("^.*[$ \t'].*$").match(editor):
-        args = [editor]
+                args = [editor + ' "$@"', "sh"]
-        shell = False
+                shell = True
-      args.append(path)
+            else:
+                args = [editor]
-      try:
+                shell = False
-        rc = subprocess.Popen(args, shell=shell).wait()
+            args.append(path)
-      except OSError as e:
-        raise EditorError('editor failed, %s: %s %s'
+            try:
-                          % (str(e), editor, path))
+                rc = subprocess.Popen(args, shell=shell).wait()
-      if rc != 0:
+            except OSError as e:
-        raise EditorError('editor failed with exit status %d: %s %s'
+                raise EditorError(
-                          % (rc, editor, path))
+                    "editor failed, %s: %s %s" % (str(e), editor, path)
+                )
-      with open(path, mode='rb') as fd2:
+            if rc != 0:
-        return fd2.read().decode('utf-8')
+                raise EditorError(
-    finally:
+                    "editor failed with exit status %d: %s %s"
-      if fd:
+                    % (rc, editor, path)
-        os.close(fd)
+                )
-      platform_utils.remove(path)
+            with open(path, mode="rb") as fd2:
+                return fd2.read().decode("utf-8")
+        finally:
+            if fd:
+                os.close(fd)
+            platform_utils.remove(path)
diff --git a/error.py b/error.py
index cbefcb7e..3cf34d54 100644
--- a/error.py
+++ b/error.py
@@ -14,122 +14,112 @@
 class ManifestParseError(Exception):
-  """Failed to parse the manifest file.
+    """Failed to parse the manifest file."""
-  """
 class ManifestInvalidRevisionError(ManifestParseError):
-  """The revision value in a project is incorrect.
+    """The revision value in a project is incorrect."""
-  """
 class ManifestInvalidPathError(ManifestParseError):
-  """A path used in <copyfile> or <linkfile> is incorrect.
+    """A path used in <copyfile> or <linkfile> is incorrect."""
-  """
 class NoManifestException(Exception):
-  """The required manifest does not exist.
+    """The required manifest does not exist."""
-  """
-  def __init__(self, path, reason):
+    def __init__(self, path, reason):
-    super().__init__(path, reason)
+        super().__init__(path, reason)
-    self.path = path
+        self.path = path
-    self.reason = reason
+        self.reason = reason
-  def __str__(self):
+    def __str__(self):
-    return self.reason
+        return self.reason
 class EditorError(Exception):
-  """Unspecified error from the user's text editor.
+    """Unspecified error from the user's text editor."""
-  """
-  def __init__(self, reason):
+    def __init__(self, reason):
-    super().__init__(reason)
+        super().__init__(reason)
-    self.reason = reason
+        self.reason = reason
-  def __str__(self):
+    def __str__(self):
-    return self.reason
+        return self.reason
 class GitError(Exception):
-  """Unspecified internal error from git.
+    """Unspecified internal error from git."""
-  """
-  def __init__(self, command):
+    def __init__(self, command):
-    super().__init__(command)
+        super().__init__(command)
-    self.command = command
+        self.command = command
-  def __str__(self):
+    def __str__(self):
-    return self.command
+        return self.command
 class UploadError(Exception):
-  """A bundle upload to Gerrit did not succeed.
+    """A bundle upload to Gerrit did not succeed."""
-  """
-  def __init__(self, reason):
+    def __init__(self, reason):
-    super().__init__(reason)
+        super().__init__(reason)
-    self.reason = reason
+        self.reason = reason
-  def __str__(self):
+    def __str__(self):
-    return self.reason
+        return self.reason
 class DownloadError(Exception):
-  """Cannot download a repository.
+    """Cannot download a repository."""
-  """
-  def __init__(self, reason):
+    def __init__(self, reason):
-    super().__init__(reason)
+        super().__init__(reason)
-    self.reason = reason
+        self.reason = reason
-  def __str__(self):
+    def __str__(self):
-    return self.reason
+        return self.reason
 class NoSuchProjectError(Exception):
-  """A specified project does not exist in the work tree.
+    """A specified project does not exist in the work tree."""
-  """
-  def __init__(self, name=None):
+    def __init__(self, name=None):
-    super().__init__(name)
+        super().__init__(name)
-    self.name = name
+        self.name = name
-  def __str__(self):
+    def __str__(self):
-    if self.name is None:
+        if self.name is None:
-      return 'in current directory'
+            return "in current directory"
-    return self.name
+        return self.name
 class InvalidProjectGroupsError(Exception):
-  """A specified project is not suitable for the specified groups
+    """A specified project is not suitable for the specified groups"""
-  """
-  def __init__(self, name=None):
+    def __init__(self, name=None):
-    super().__init__(name)
+        super().__init__(name)
-    self.name = name
+        self.name = name
-  def __str__(self):
+    def __str__(self):
-    if self.name is None:
+        if self.name is None:
-      return 'in current directory'
+            return "in current directory"
-    return self.name
+        return self.name
 class RepoChangedException(Exception):
-  """Thrown if 'repo sync' results in repo updating its internal
+    """Thrown if 'repo sync' results in repo updating its internal
-     repo or manifest repositories.  In this special case we must
+    repo or manifest repositories.  In this special case we must
-     use exec to re-execute repo with the new code and manifest.
+    use exec to re-execute repo with the new code and manifest.
-  """
+    """
-  def __init__(self, extra_args=None):
+    def __init__(self, extra_args=None):
-    super().__init__(extra_args)
+        super().__init__(extra_args)
-    self.extra_args = extra_args or []
+        self.extra_args = extra_args or []
 class HookError(Exception):
-  """Thrown if a 'repo-hook' could not be run.
+    """Thrown if a 'repo-hook' could not be run.
-  The common case is that the file wasn't present when we tried to run it.
+    The common case is that the file wasn't present when we tried to run it.
-  """
+    """
diff --git a/event_log.py b/event_log.py
index c77c5648..b1f8bdf9 100644
--- a/event_log.py
+++ b/event_log.py
@@ -15,161 +15,169 @@
 import json
 import multiprocessing
-TASK_COMMAND = 'command'
+TASK_COMMAND = "command"
-TASK_SYNC_NETWORK = 'sync-network'
+TASK_SYNC_NETWORK = "sync-network"
-TASK_SYNC_LOCAL = 'sync-local'
+TASK_SYNC_LOCAL = "sync-local"
 class EventLog(object):
-  """Event log that records events that occurred during a repo invocation.
+    """Event log that records events that occurred during a repo invocation.
-  Events are written to the log as a consecutive JSON entries, one per line.
+    Events are written to the log as a consecutive JSON entries, one per line.
-  Each entry contains the following keys:
+    Each entry contains the following keys:
-  - id: A ('RepoOp', ID) tuple, suitable for storing in a datastore.
+    - id: A ('RepoOp', ID) tuple, suitable for storing in a datastore.
-        The ID is only unique for the invocation of the repo command.
+          The ID is only unique for the invocation of the repo command.
-  - name: Name of the object being operated upon.
+    - name: Name of the object being operated upon.
-  - task_name: The task that was performed.
+    - task_name: The task that was performed.
-  - start: Timestamp of when the operation started.
+    - start: Timestamp of when the operation started.
-  - finish: Timestamp of when the operation finished.
+    - finish: Timestamp of when the operation finished.
-  - success: Boolean indicating if the operation was successful.
+    - success: Boolean indicating if the operation was successful.
-  - try_count: A counter indicating the try count of this task.
+    - try_count: A counter indicating the try count of this task.
-  Optionally:
+    Optionally:
-  - parent: A ('RepoOp', ID) tuple indicating the parent event for nested
+    - parent: A ('RepoOp', ID) tuple indicating the parent event for nested
-            events.
+        events.
-  Valid task_names include:
+    Valid task_names include:
-  - command: The invocation of a subcommand.
+    - command: The invocation of a subcommand.
-  - sync-network: The network component of a sync command.
+    - sync-network: The network component of a sync command.
-  - sync-local: The local component of a sync command.
+    - sync-local: The local component of a sync command.
-  Specific tasks may include additional informational properties.
+    Specific tasks may include additional informational properties.
-  """
-  def __init__(self):
-    """Initializes the event log."""
-    self._log = []
-    self._parent = None
-  def Add(self, name, task_name, start, finish=None, success=None,
-          try_count=1, kind='RepoOp'):
-    """Add an event to the log.
-    Args:
-      name: Name of the object being operated upon.
-      task_name: A sub-task that was performed for name.
-      start: Timestamp of when the operation started.
-      finish: Timestamp of when the operation finished.
-      success: Boolean indicating if the operation was successful.
-      try_count: A counter indicating the try count of this task.
-      kind: The kind of the object for the unique identifier.
-    Returns:
-      A dictionary of the event added to the log.
    """
-    event = {
-        'id': (kind, _NextEventId()),
-        'name': name,
-        'task_name': task_name,
-        'start_time': start,
-        'try': try_count,
-    }
-    if self._parent:
-      event['parent'] = self._parent['id']
-    if success is not None or finish is not None:
-        self.FinishEvent(event, finish, success)
-    self._log.append(event)
-    return event
-  def AddSync(self, project, task_name, start, finish, success):
-    """Add a event to the log for a sync command.
-    Args:
-      project: Project being synced.
-      task_name: A sub-task that was performed for name.
-                 One of (TASK_SYNC_NETWORK, TASK_SYNC_LOCAL)
-      start: Timestamp of when the operation started.
-      finish: Timestamp of when the operation finished.
-      success: Boolean indicating if the operation was successful.
-    Returns:
+    def __init__(self):
-      A dictionary of the event added to the log.
+        """Initializes the event log."""
-    """
+        self._log = []
-    event = self.Add(project.relpath, task_name, start, finish, success)
+        self._parent = None
-    if event is not None:
-      event['project'] = project.name
+    def Add(
-      if project.revisionExpr:
+        self,
-        event['revision'] = project.revisionExpr
+        name,
-      if project.remote.url:
+        task_name,
-        event['project_url'] = project.remote.url
+        start,
-      if project.remote.fetchUrl:
+        finish=None,
-        event['remote_url'] = project.remote.fetchUrl
+        success=None,
-      try:
+        try_count=1,
-        event['git_hash'] = project.GetCommitRevisionId()
+        kind="RepoOp",
-      except Exception:
+    ):
-        pass
+        """Add an event to the log.
-    return event
+        Args:
-  def GetStatusString(self, success):
+            name: Name of the object being operated upon.
-    """Converst a boolean success to a status string.
+            task_name: A sub-task that was performed for name.
+            start: Timestamp of when the operation started.
-    Args:
+            finish: Timestamp of when the operation finished.
-      success: Boolean indicating if the operation was successful.
+            success: Boolean indicating if the operation was successful.
+            try_count: A counter indicating the try count of this task.
-    Returns:
+            kind: The kind of the object for the unique identifier.
-      status string.
-    """
+        Returns:
-    return 'pass' if success else 'fail'
+            A dictionary of the event added to the log.
+        """
-  def FinishEvent(self, event, finish, success):
+        event = {
-    """Finishes an incomplete event.
+            "id": (kind, _NextEventId()),
+            "name": name,
-    Args:
+            "task_name": task_name,
-      event: An event that has been added to the log.
+            "start_time": start,
-      finish: Timestamp of when the operation finished.
+            "try": try_count,
-      success: Boolean indicating if the operation was successful.
+        }
-    Returns:
+        if self._parent:
-      A dictionary of the event added to the log.
+            event["parent"] = self._parent["id"]
-    """
-    event['status'] = self.GetStatusString(success)
+        if success is not None or finish is not None:
-    event['finish_time'] = finish
+            self.FinishEvent(event, finish, success)
-    return event
+        self._log.append(event)
-  def SetParent(self, event):
+        return event
-    """Set a parent event for all new entities.
+    def AddSync(self, project, task_name, start, finish, success):
-    Args:
+        """Add a event to the log for a sync command.
-      event: The event to use as a parent.
-    """
+        Args:
-    self._parent = event
+            project: Project being synced.
+            task_name: A sub-task that was performed for name.
-  def Write(self, filename):
+                One of (TASK_SYNC_NETWORK, TASK_SYNC_LOCAL)
-    """Writes the log out to a file.
+            start: Timestamp of when the operation started.
+            finish: Timestamp of when the operation finished.
-    Args:
+            success: Boolean indicating if the operation was successful.
-      filename: The file to write the log to.
-    """
+        Returns:
-    with open(filename, 'w+') as f:
+            A dictionary of the event added to the log.
-      for e in self._log:
+        """
-        json.dump(e, f, sort_keys=True)
+        event = self.Add(project.relpath, task_name, start, finish, success)
-        f.write('\n')
+        if event is not None:
+            event["project"] = project.name
+            if project.revisionExpr:
+                event["revision"] = project.revisionExpr
+            if project.remote.url:
+                event["project_url"] = project.remote.url
+            if project.remote.fetchUrl:
+                event["remote_url"] = project.remote.fetchUrl
+            try:
+                event["git_hash"] = project.GetCommitRevisionId()
+            except Exception:
+                pass
+        return event
+    def GetStatusString(self, success):
+        """Converst a boolean success to a status string.
+        Args:
+            success: Boolean indicating if the operation was successful.
+        Returns:
+            status string.
+        """
+        return "pass" if success else "fail"
+    def FinishEvent(self, event, finish, success):
+        """Finishes an incomplete event.
+        Args:
+            event: An event that has been added to the log.
+            finish: Timestamp of when the operation finished.
+            success: Boolean indicating if the operation was successful.
+        Returns:
+            A dictionary of the event added to the log.
+        """
+        event["status"] = self.GetStatusString(success)
+        event["finish_time"] = finish
+        return event
+    def SetParent(self, event):
+        """Set a parent event for all new entities.
+        Args:
+            event: The event to use as a parent.
+        """
+        self._parent = event
+    def Write(self, filename):
+        """Writes the log out to a file.
+        Args:
+            filename: The file to write the log to.
+        """
+        with open(filename, "w+") as f:
+            for e in self._log:
+                json.dump(e, f, sort_keys=True)
+                f.write("\n")
 # An integer id that is unique across this invocation of the program.
-_EVENT_ID = multiprocessing.Value('i', 1)
+_EVENT_ID = multiprocessing.Value("i", 1)
 def _NextEventId():
-  """Helper function for grabbing the next unique id.
+    """Helper function for grabbing the next unique id.
-  Returns:
+    Returns:
-    A unique, to this invocation of the program, integer id.
+        A unique, to this invocation of the program, integer id.
-  """
+    """
-  with _EVENT_ID.get_lock():
+    with _EVENT_ID.get_lock():
-    val = _EVENT_ID.value
+        val = _EVENT_ID.value
-    _EVENT_ID.value += 1
+        _EVENT_ID.value += 1
-  return val
+    return val
diff --git a/fetch.py b/fetch.py
index c954a9c2..31f8152f 100644
--- a/fetch.py
+++ b/fetch.py
@@ -21,25 +21,29 @@ from urllib.request import urlopen
 def fetch_file(url, verbose=False):
-  """Fetch a file from the specified source using the appropriate protocol.
+    """Fetch a file from the specified source using the appropriate protocol.
-  Returns:
+    Returns:
-    The contents of the file as bytes.
+        The contents of the file as bytes.
-  """
+    """
-  scheme = urlparse(url).scheme
+    scheme = urlparse(url).scheme
-  if scheme == 'gs':
+    if scheme == "gs":
-    cmd = ['gsutil', 'cat', url]
+        cmd = ["gsutil", "cat", url]
-    try:
+        try:
-      result = subprocess.run(
+            result = subprocess.run(
-          cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+                cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True
-          check=True)
+            )
-      if result.stderr and verbose:
+            if result.stderr and verbose:
-        print('warning: non-fatal error running "gsutil": %s' % result.stderr,
+                print(
-              file=sys.stderr)
+                    'warning: non-fatal error running "gsutil": %s'
-      return result.stdout
+                    % result.stderr,
-    except subprocess.CalledProcessError as e:
+                    file=sys.stderr,
-      print('fatal: error running "gsutil": %s' % e.stderr,
+                )
-            file=sys.stderr)
+            return result.stdout
-    sys.exit(1)
+        except subprocess.CalledProcessError as e:
-  with urlopen(url) as f:
+            print(
-    return f.read()
+                'fatal: error running "gsutil": %s' % e.stderr, file=sys.stderr
+            )
+        sys.exit(1)
+    with urlopen(url) as f:
+        return f.read()
diff --git a/git_command.py b/git_command.py
index d4d4bed4..c7245ade 100644
--- a/git_command.py
+++ b/git_command.py
@@ -24,7 +24,7 @@ import platform_utils
 from repo_trace import REPO_TRACE, IsTrace, Trace
 from wrapper import Wrapper
-GIT = 'git'
+GIT = "git"
 # NB: These do not need to be kept in sync with the repo launcher script.
 # These may be much newer as it allows the repo launcher to roll between
 # different repo releases while source versions might require a newer git.
@@ -36,126 +36,138 @@ GIT = 'git'
 # git-1.7 is in (EOL) Ubuntu Precise.  git-1.9 is in Ubuntu Trusty.
 MIN_GIT_VERSION_SOFT = (1, 9, 1)
 MIN_GIT_VERSION_HARD = (1, 7, 2)
-GIT_DIR = 'GIT_DIR'
+GIT_DIR = "GIT_DIR"
 LAST_GITDIR = None
 LAST_CWD = None
 class _GitCall(object):
-  @functools.lru_cache(maxsize=None)
+    @functools.lru_cache(maxsize=None)
-  def version_tuple(self):
+    def version_tuple(self):
-    ret = Wrapper().ParseGitVersion()
+        ret = Wrapper().ParseGitVersion()
-    if ret is None:
+        if ret is None:
-      print('fatal: unable to detect git version', file=sys.stderr)
+            print("fatal: unable to detect git version", file=sys.stderr)
-      sys.exit(1)
+            sys.exit(1)
-    return ret
+        return ret
-  def __getattr__(self, name):
+    def __getattr__(self, name):
-    name = name.replace('_', '-')
+        name = name.replace("_", "-")
-    def fun(*cmdv):
+        def fun(*cmdv):
-      command = [name]
+            command = [name]
-      command.extend(cmdv)
+            command.extend(cmdv)
-      return GitCommand(None, command).Wait() == 0
+            return GitCommand(None, command).Wait() == 0
-    return fun
+        return fun
 git = _GitCall()
 def RepoSourceVersion():
-  """Return the version of the repo.git tree."""
+    """Return the version of the repo.git tree."""
-  ver = getattr(RepoSourceVersion, 'version', None)
+    ver = getattr(RepoSourceVersion, "version", None)
-  # We avoid GitCommand so we don't run into circular deps -- GitCommand needs
+    # We avoid GitCommand so we don't run into circular deps -- GitCommand needs
-  # to initialize version info we provide.
+    # to initialize version info we provide.
-  if ver is None:
+    if ver is None:
-    env = GitCommand._GetBasicEnv()
+        env = GitCommand._GetBasicEnv()
+        proj = os.path.dirname(os.path.abspath(__file__))
+        env[GIT_DIR] = os.path.join(proj, ".git")
+        result = subprocess.run(
+            [GIT, "describe", HEAD],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+            encoding="utf-8",
+            env=env,
+            check=False,
+        )
+        if result.returncode == 0:
+            ver = result.stdout.strip()
+            if ver.startswith("v"):
+                ver = ver[1:]
+        else:
+            ver = "unknown"
+        setattr(RepoSourceVersion, "version", ver)
+    return ver
-    proj = os.path.dirname(os.path.abspath(__file__))
-    env[GIT_DIR] = os.path.join(proj, '.git')
-    result = subprocess.run([GIT, 'describe', HEAD], stdout=subprocess.PIPE,
-                            stderr=subprocess.DEVNULL, encoding='utf-8',
-                            env=env, check=False)
-    if result.returncode == 0:
-      ver = result.stdout.strip()
-      if ver.startswith('v'):
-        ver = ver[1:]
-    else:
-      ver = 'unknown'
-    setattr(RepoSourceVersion, 'version', ver)
-  return ver
+class UserAgent(object):
+    """Mange User-Agent settings when talking to external services
+    We follow the style as documented here:
+    https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/User-Agent
+    """
-class UserAgent(object):
+    _os = None
-  """Mange User-Agent settings when talking to external services
+    _repo_ua = None
+    _git_ua = None
-  We follow the style as documented here:
-  https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/User-Agent
+    @property
-  """
+    def os(self):
+        """The operating system name."""
-  _os = None
+        if self._os is None:
-  _repo_ua = None
+            os_name = sys.platform
-  _git_ua = None
+            if os_name.lower().startswith("linux"):
+                os_name = "Linux"
-  @property
+            elif os_name == "win32":
-  def os(self):
+                os_name = "Win32"
-    """The operating system name."""
+            elif os_name == "cygwin":
-    if self._os is None:
+                os_name = "Cygwin"
-      os_name = sys.platform
+            elif os_name == "darwin":
-      if os_name.lower().startswith('linux'):
+                os_name = "Darwin"
-        os_name = 'Linux'
+            self._os = os_name
-      elif os_name == 'win32':
-        os_name = 'Win32'
+        return self._os
-      elif os_name == 'cygwin':
-        os_name = 'Cygwin'
+    @property
-      elif os_name == 'darwin':
+    def repo(self):
-        os_name = 'Darwin'
+        """The UA when connecting directly from repo."""
-      self._os = os_name
+        if self._repo_ua is None:
+            py_version = sys.version_info
-    return self._os
+            self._repo_ua = "git-repo/%s (%s) git/%s Python/%d.%d.%d" % (
+                RepoSourceVersion(),
-  @property
+                self.os,
-  def repo(self):
+                git.version_tuple().full,
-    """The UA when connecting directly from repo."""
+                py_version.major,
-    if self._repo_ua is None:
+                py_version.minor,
-      py_version = sys.version_info
+                py_version.micro,
-      self._repo_ua = 'git-repo/%s (%s) git/%s Python/%d.%d.%d' % (
+            )
-          RepoSourceVersion(),
-          self.os,
+        return self._repo_ua
-          git.version_tuple().full,
-          py_version.major, py_version.minor, py_version.micro)
+    @property
+    def git(self):
-    return self._repo_ua
+        """The UA when running git."""
+        if self._git_ua is None:
-  @property
+            self._git_ua = "git/%s (%s) git-repo/%s" % (
-  def git(self):
+                git.version_tuple().full,
-    """The UA when running git."""
+                self.os,
-    if self._git_ua is None:
+                RepoSourceVersion(),
-      self._git_ua = 'git/%s (%s) git-repo/%s' % (
+            )
-          git.version_tuple().full,
-          self.os,
+        return self._git_ua
-          RepoSourceVersion())
-    return self._git_ua
 user_agent = UserAgent()
-def git_require(min_version, fail=False, msg=''):
+def git_require(min_version, fail=False, msg=""):
-  git_version = git.version_tuple()
+    git_version = git.version_tuple()
-  if min_version <= git_version:
+    if min_version <= git_version:
-    return True
+        return True
-  if fail:
+    if fail:
-    need = '.'.join(map(str, min_version))
+        need = ".".join(map(str, min_version))
-    if msg:
+        if msg:
-      msg = ' for ' + msg
+            msg = " for " + msg
-    print('fatal: git %s or later required%s' % (need, msg), file=sys.stderr)
+        print(
-    sys.exit(1)
+            "fatal: git %s or later required%s" % (need, msg), file=sys.stderr
-  return False
+        )
+        sys.exit(1)
+    return False
 def _build_env(
@@ -164,175 +176,194 @@ def _build_env(
    disable_editor: Optional[bool] = False,
    ssh_proxy: Optional[Any] = None,
    gitdir: Optional[str] = None,
-    objdir: Optional[str] = None
+    objdir: Optional[str] = None,
 ):
-  """Constucts an env dict for command execution."""
+    """Constucts an env dict for command execution."""
-  assert _kwargs_only == (), '_build_env only accepts keyword arguments.'
-  env = GitCommand._GetBasicEnv()
-  if disable_editor:
-    env['GIT_EDITOR'] = ':'
-  if ssh_proxy:
-    env['REPO_SSH_SOCK'] = ssh_proxy.sock()
-    env['GIT_SSH'] = ssh_proxy.proxy
-    env['GIT_SSH_VARIANT'] = 'ssh'
-  if 'http_proxy' in env and 'darwin' == sys.platform:
-    s = "'http.proxy=%s'" % (env['http_proxy'],)
-    p = env.get('GIT_CONFIG_PARAMETERS')
-    if p is not None:
-      s = p + ' ' + s
-    env['GIT_CONFIG_PARAMETERS'] = s
-  if 'GIT_ALLOW_PROTOCOL' not in env:
-    env['GIT_ALLOW_PROTOCOL'] = (
-        'file:git:http:https:ssh:persistent-http:persistent-https:sso:rpc')
-  env['GIT_HTTP_USER_AGENT'] = user_agent.git
-  if objdir:
-    # Set to the place we want to save the objects.
-    env['GIT_OBJECT_DIRECTORY'] = objdir
-    alt_objects = os.path.join(gitdir, 'objects') if gitdir else None
-    if alt_objects and os.path.realpath(alt_objects) != os.path.realpath(objdir):
-      # Allow git to search the original place in case of local or unique refs
-      # that git will attempt to resolve even if we aren't fetching them.
-      env['GIT_ALTERNATE_OBJECT_DIRECTORIES'] = alt_objects
-  if bare and gitdir is not None:
-      env[GIT_DIR] = gitdir
-  return env
+    assert _kwargs_only == (), "_build_env only accepts keyword arguments."
+    env = GitCommand._GetBasicEnv()
+    if disable_editor:
+        env["GIT_EDITOR"] = ":"
+    if ssh_proxy:
+        env["REPO_SSH_SOCK"] = ssh_proxy.sock()
+        env["GIT_SSH"] = ssh_proxy.proxy
+        env["GIT_SSH_VARIANT"] = "ssh"
+    if "http_proxy" in env and "darwin" == sys.platform:
+        s = "'http.proxy=%s'" % (env["http_proxy"],)
+        p = env.get("GIT_CONFIG_PARAMETERS")
+        if p is not None:
+            s = p + " " + s
+        env["GIT_CONFIG_PARAMETERS"] = s
+    if "GIT_ALLOW_PROTOCOL" not in env:
+        env[
+            "GIT_ALLOW_PROTOCOL"
+        ] = "file:git:http:https:ssh:persistent-http:persistent-https:sso:rpc"
+    env["GIT_HTTP_USER_AGENT"] = user_agent.git
+    if objdir:
+        # Set to the place we want to save the objects.
+        env["GIT_OBJECT_DIRECTORY"] = objdir
+        alt_objects = os.path.join(gitdir, "objects") if gitdir else None
+        if alt_objects and os.path.realpath(alt_objects) != os.path.realpath(
+            objdir
+        ):
+            # Allow git to search the original place in case of local or unique
+            # refs that git will attempt to resolve even if we aren't fetching
+            # them.
+            env["GIT_ALTERNATE_OBJECT_DIRECTORIES"] = alt_objects
+    if bare and gitdir is not None:
+        env[GIT_DIR] = gitdir
-class GitCommand(object):
-  """Wrapper around a single git invocation."""
-  def __init__(self,
-               project,
-               cmdv,
-               bare=False,
-               input=None,
-               capture_stdout=False,
-               capture_stderr=False,
-               merge_output=False,
-               disable_editor=False,
-               ssh_proxy=None,
-               cwd=None,
-               gitdir=None,
-               objdir=None):
-    if project:
-      if not cwd:
-        cwd = project.worktree
-      if not gitdir:
-        gitdir = project.gitdir
-    # Git on Windows wants its paths only using / for reliability.
-    if platform_utils.isWindows():
-      if objdir:
-        objdir = objdir.replace('\\', '/')
-      if gitdir:
-        gitdir = gitdir.replace('\\', '/')
-    env = _build_env(
-        disable_editor=disable_editor,
-        ssh_proxy=ssh_proxy,
-        objdir=objdir,
-        gitdir=gitdir,
-        bare=bare,
-    )
-    command = [GIT]
-    if bare:
-      cwd = None
-    command.append(cmdv[0])
-    # Need to use the --progress flag for fetch/clone so output will be
-    # displayed as by default git only does progress output if stderr is a TTY.
-    if sys.stderr.isatty() and cmdv[0] in ('fetch', 'clone'):
-      if '--progress' not in cmdv and '--quiet' not in cmdv:
-        command.append('--progress')
-    command.extend(cmdv[1:])
-    stdin = subprocess.PIPE if input else None
-    stdout = subprocess.PIPE if capture_stdout else None
-    stderr = (subprocess.STDOUT if merge_output else
-              (subprocess.PIPE if capture_stderr else None))
-    dbg = ''
-    if IsTrace():
-      global LAST_CWD
-      global LAST_GITDIR
-      if cwd and LAST_CWD != cwd:
-        if LAST_GITDIR or LAST_CWD:
-          dbg += '\n'
-        dbg += ': cd %s\n' % cwd
-        LAST_CWD = cwd
-      if GIT_DIR in env and LAST_GITDIR != env[GIT_DIR]:
-        if LAST_GITDIR or LAST_CWD:
-          dbg += '\n'
-        dbg += ': export GIT_DIR=%s\n' % env[GIT_DIR]
-        LAST_GITDIR = env[GIT_DIR]
-      if 'GIT_OBJECT_DIRECTORY' in env:
-        dbg += ': export GIT_OBJECT_DIRECTORY=%s\n' % env['GIT_OBJECT_DIRECTORY']
-      if 'GIT_ALTERNATE_OBJECT_DIRECTORIES' in env:
-        dbg += ': export GIT_ALTERNATE_OBJECT_DIRECTORIES=%s\n' % (
-            env['GIT_ALTERNATE_OBJECT_DIRECTORIES'])
-      dbg += ': '
-      dbg += ' '.join(command)
-      if stdin == subprocess.PIPE:
-        dbg += ' 0<|'
-      if stdout == subprocess.PIPE:
-        dbg += ' 1>|'
-      if stderr == subprocess.PIPE:
-        dbg += ' 2>|'
-      elif stderr == subprocess.STDOUT:
-        dbg += ' 2>&1'
-    with Trace('git command %s %s with debug: %s', LAST_GITDIR, command, dbg):
-      try:
-        p = subprocess.Popen(command,
-                             cwd=cwd,
-                             env=env,
-                             encoding='utf-8',
-                             errors='backslashreplace',
-                             stdin=stdin,
-                             stdout=stdout,
-                             stderr=stderr)
-      except Exception as e:
-        raise GitError('%s: %s' % (command[1], e))
-      if ssh_proxy:
-        ssh_proxy.add_client(p)
-      self.process = p
-      try:
-        self.stdout, self.stderr = p.communicate(input=input)
-      finally:
-        if ssh_proxy:
-          ssh_proxy.remove_client(p)
-      self.rc = p.wait()
-  @staticmethod
-  def _GetBasicEnv():
-    """Return a basic env for running git under.
-    This is guaranteed to be side-effect free.
-    """
-    env = os.environ.copy()
-    for key in (REPO_TRACE,
-                GIT_DIR,
-                'GIT_ALTERNATE_OBJECT_DIRECTORIES',
-                'GIT_OBJECT_DIRECTORY',
-                'GIT_WORK_TREE',
-                'GIT_GRAFT_FILE',
-                'GIT_INDEX_FILE'):
-      env.pop(key, None)
    return env
-  def Wait(self):
-    return self.rc
+class GitCommand(object):
+    """Wrapper around a single git invocation."""
+    def __init__(
+        self,
+        project,
+        cmdv,
+        bare=False,
+        input=None,
+        capture_stdout=False,
+        capture_stderr=False,
+        merge_output=False,
+        disable_editor=False,
+        ssh_proxy=None,
+        cwd=None,
+        gitdir=None,
+        objdir=None,
+    ):
+        if project:
+            if not cwd:
+                cwd = project.worktree
+            if not gitdir:
+                gitdir = project.gitdir
+        # Git on Windows wants its paths only using / for reliability.
+        if platform_utils.isWindows():
+            if objdir:
+                objdir = objdir.replace("\\", "/")
+            if gitdir:
+                gitdir = gitdir.replace("\\", "/")
+        env = _build_env(
+            disable_editor=disable_editor,
+            ssh_proxy=ssh_proxy,
+            objdir=objdir,
+            gitdir=gitdir,
+            bare=bare,
+        )
+        command = [GIT]
+        if bare:
+            cwd = None
+        command.append(cmdv[0])
+        # Need to use the --progress flag for fetch/clone so output will be
+        # displayed as by default git only does progress output if stderr is a
+        # TTY.
+        if sys.stderr.isatty() and cmdv[0] in ("fetch", "clone"):
+            if "--progress" not in cmdv and "--quiet" not in cmdv:
+                command.append("--progress")
+        command.extend(cmdv[1:])
+        stdin = subprocess.PIPE if input else None
+        stdout = subprocess.PIPE if capture_stdout else None
+        stderr = (
+            subprocess.STDOUT
+            if merge_output
+            else (subprocess.PIPE if capture_stderr else None)
+        )
+        dbg = ""
+        if IsTrace():
+            global LAST_CWD
+            global LAST_GITDIR
+            if cwd and LAST_CWD != cwd:
+                if LAST_GITDIR or LAST_CWD:
+                    dbg += "\n"
+                dbg += ": cd %s\n" % cwd
+                LAST_CWD = cwd
+            if GIT_DIR in env and LAST_GITDIR != env[GIT_DIR]:
+                if LAST_GITDIR or LAST_CWD:
+                    dbg += "\n"
+                dbg += ": export GIT_DIR=%s\n" % env[GIT_DIR]
+                LAST_GITDIR = env[GIT_DIR]
+            if "GIT_OBJECT_DIRECTORY" in env:
+                dbg += (
+                    ": export GIT_OBJECT_DIRECTORY=%s\n"
+                    % env["GIT_OBJECT_DIRECTORY"]
+                )
+            if "GIT_ALTERNATE_OBJECT_DIRECTORIES" in env:
+                dbg += ": export GIT_ALTERNATE_OBJECT_DIRECTORIES=%s\n" % (
+                    env["GIT_ALTERNATE_OBJECT_DIRECTORIES"]
+                )
+            dbg += ": "
+            dbg += " ".join(command)
+            if stdin == subprocess.PIPE:
+                dbg += " 0<|"
+            if stdout == subprocess.PIPE:
+                dbg += " 1>|"
+            if stderr == subprocess.PIPE:
+                dbg += " 2>|"
+            elif stderr == subprocess.STDOUT:
+                dbg += " 2>&1"
+        with Trace(
+            "git command %s %s with debug: %s", LAST_GITDIR, command, dbg
+        ):
+            try:
+                p = subprocess.Popen(
+                    command,
+                    cwd=cwd,
+                    env=env,
+                    encoding="utf-8",
+                    errors="backslashreplace",
+                    stdin=stdin,
+                    stdout=stdout,
+                    stderr=stderr,
+                )
+            except Exception as e:
+                raise GitError("%s: %s" % (command[1], e))
+            if ssh_proxy:
+                ssh_proxy.add_client(p)
+            self.process = p
+            try:
+                self.stdout, self.stderr = p.communicate(input=input)
+            finally:
+                if ssh_proxy:
+                    ssh_proxy.remove_client(p)
+            self.rc = p.wait()
+    @staticmethod
+    def _GetBasicEnv():
+        """Return a basic env for running git under.
+        This is guaranteed to be side-effect free.
+        """
+        env = os.environ.copy()
+        for key in (
+            REPO_TRACE,
+            GIT_DIR,
+            "GIT_ALTERNATE_OBJECT_DIRECTORIES",
+            "GIT_OBJECT_DIRECTORY",
+            "GIT_WORK_TREE",
+            "GIT_GRAFT_FILE",
+            "GIT_INDEX_FILE",
+        ):
+            env.pop(key, None)
+        return env
+    def Wait(self):
+        return self.rc
diff --git a/git_config.py b/git_config.py
index 9ad979ad..05b3c1ee 100644
--- a/git_config.py
+++ b/git_config.py
@@ -34,23 +34,23 @@ from git_refs import R_CHANGES, R_HEADS, R_TAGS
 # Prefix that is prepended to all the keys of SyncAnalysisState's data
 # that is saved in the config.
-SYNC_STATE_PREFIX = 'repo.syncstate.'
+SYNC_STATE_PREFIX = "repo.syncstate."
-ID_RE = re.compile(r'^[0-9a-f]{40}$')
+ID_RE = re.compile(r"^[0-9a-f]{40}$")
 REVIEW_CACHE = dict()
 def IsChange(rev):
-  return rev.startswith(R_CHANGES)
+    return rev.startswith(R_CHANGES)
 def IsId(rev):
-  return ID_RE.match(rev)
+    return ID_RE.match(rev)
 def IsTag(rev):
-  return rev.startswith(R_TAGS)
+    return rev.startswith(R_TAGS)
 def IsImmutable(rev):
@@ -58,765 +58,785 @@ def IsImmutable(rev):
 def _key(name):
-  parts = name.split('.')
+    parts = name.split(".")
-  if len(parts) < 2:
+    if len(parts) < 2:
-    return name.lower()
+        return name.lower()
-  parts[0] = parts[0].lower()
+    parts[0] = parts[0].lower()
-  parts[-1] = parts[-1].lower()
+    parts[-1] = parts[-1].lower()
-  return '.'.join(parts)
+    return ".".join(parts)
 class GitConfig(object):
-  _ForUser = None
+    _ForUser = None
-  _ForSystem = None
+    _ForSystem = None
-  _SYSTEM_CONFIG = '/etc/gitconfig'
+    _SYSTEM_CONFIG = "/etc/gitconfig"
-  @classmethod
+    @classmethod
-  def ForSystem(cls):
+    def ForSystem(cls):
-    if cls._ForSystem is None:
+        if cls._ForSystem is None:
-      cls._ForSystem = cls(configfile=cls._SYSTEM_CONFIG)
+            cls._ForSystem = cls(configfile=cls._SYSTEM_CONFIG)
-    return cls._ForSystem
+        return cls._ForSystem
-  @classmethod
+    @classmethod
-  def ForUser(cls):
+    def ForUser(cls):
-    if cls._ForUser is None:
+        if cls._ForUser is None:
-      cls._ForUser = cls(configfile=cls._getUserConfig())
+            cls._ForUser = cls(configfile=cls._getUserConfig())
-    return cls._ForUser
+        return cls._ForUser
-  @staticmethod
+    @staticmethod
-  def _getUserConfig():
+    def _getUserConfig():
-    return os.path.expanduser('~/.gitconfig')
+        return os.path.expanduser("~/.gitconfig")
-  @classmethod
+    @classmethod
-  def ForRepository(cls, gitdir, defaults=None):
+    def ForRepository(cls, gitdir, defaults=None):
-    return cls(configfile=os.path.join(gitdir, 'config'),
+        return cls(configfile=os.path.join(gitdir, "config"), defaults=defaults)
-               defaults=defaults)
+    def __init__(self, configfile, defaults=None, jsonFile=None):
-  def __init__(self, configfile, defaults=None, jsonFile=None):
+        self.file = configfile
-    self.file = configfile
+        self.defaults = defaults
-    self.defaults = defaults
+        self._cache_dict = None
-    self._cache_dict = None
+        self._section_dict = None
-    self._section_dict = None
+        self._remotes = {}
-    self._remotes = {}
+        self._branches = {}
-    self._branches = {}
+        self._json = jsonFile
-    self._json = jsonFile
+        if self._json is None:
-    if self._json is None:
+            self._json = os.path.join(
-      self._json = os.path.join(
+                os.path.dirname(self.file),
-          os.path.dirname(self.file),
+                ".repo_" + os.path.basename(self.file) + ".json",
-          '.repo_' + os.path.basename(self.file) + '.json')
+            )
-  def ClearCache(self):
+    def ClearCache(self):
-    """Clear the in-memory cache of config."""
+        """Clear the in-memory cache of config."""
-    self._cache_dict = None
+        self._cache_dict = None
-  def Has(self, name, include_defaults=True):
+    def Has(self, name, include_defaults=True):
-    """Return true if this configuration file has the key.
+        """Return true if this configuration file has the key."""
-    """
+        if _key(name) in self._cache:
-    if _key(name) in self._cache:
+            return True
-      return True
+        if include_defaults and self.defaults:
-    if include_defaults and self.defaults:
+            return self.defaults.Has(name, include_defaults=True)
-      return self.defaults.Has(name, include_defaults=True)
+        return False
-    return False
+    def GetInt(self, name: str) -> Union[int, None]:
-  def GetInt(self, name: str) -> Union[int, None]:
+        """Returns an integer from the configuration file.
-    """Returns an integer from the configuration file.
+        This follows the git config syntax.
-    This follows the git config syntax.
+        Args:
-    Args:
+            name: The key to lookup.
-      name: The key to lookup.
+        Returns:
-    Returns:
+            None if the value was not defined, or is not an int.
-      None if the value was not defined, or is not an int.
+            Otherwise, the number itself.
-      Otherwise, the number itself.
+        """
-    """
+        v = self.GetString(name)
-    v = self.GetString(name)
+        if v is None:
-    if v is None:
+            return None
-      return None
+        v = v.strip()
-    v = v.strip()
+        mult = 1
-    mult = 1
+        if v.endswith("k"):
-    if v.endswith('k'):
+            v = v[:-1]
-      v = v[:-1]
+            mult = 1024
-      mult = 1024
+        elif v.endswith("m"):
-    elif v.endswith('m'):
+            v = v[:-1]
-      v = v[:-1]
+            mult = 1024 * 1024
-      mult = 1024 * 1024
+        elif v.endswith("g"):
-    elif v.endswith('g'):
+            v = v[:-1]
-      v = v[:-1]
+            mult = 1024 * 1024 * 1024
-      mult = 1024 * 1024 * 1024
+        base = 10
-    base = 10
+        if v.startswith("0x"):
-    if v.startswith('0x'):
+            base = 16
-      base = 16
-    try:
-      return int(v, base=base) * mult
-    except ValueError:
-      print(
-          f"warning: expected {name} to represent an integer, got {v} instead",
-          file=sys.stderr)
-      return None
-  def DumpConfigDict(self):
-    """Returns the current configuration dict.
-    Configuration data is information only (e.g. logging) and
-    should not be considered a stable data-source.
-    Returns:
-      dict of {<key>, <value>} for git configuration cache.
-      <value> are strings converted by GetString.
-    """
-    config_dict = {}
-    for key in self._cache:
-      config_dict[key] = self.GetString(key)
-    return config_dict
-  def GetBoolean(self, name: str) -> Union[str, None]:
-    """Returns a boolean from the configuration file.
-       None : The value was not defined, or is not a boolean.
-       True : The value was set to true or yes.
-       False: The value was set to false or no.
-    """
-    v = self.GetString(name)
-    if v is None:
-      return None
-    v = v.lower()
-    if v in ('true', 'yes'):
-      return True
-    if v in ('false', 'no'):
-      return False
-    print(f"warning: expected {name} to represent a boolean, got {v} instead",
-          file=sys.stderr)
-    return None
-  def SetBoolean(self, name, value):
+        try:
-    """Set the truthy value for a key."""
+            return int(v, base=base) * mult
-    if value is not None:
+        except ValueError:
-      value = 'true' if value else 'false'
+            print(
-    self.SetString(name, value)
+                f"warning: expected {name} to represent an integer, got {v} "
+                "instead",
+                file=sys.stderr,
+            )
+            return None
+    def DumpConfigDict(self):
+        """Returns the current configuration dict.
+        Configuration data is information only (e.g. logging) and
+        should not be considered a stable data-source.
+        Returns:
+            dict of {<key>, <value>} for git configuration cache.
+            <value> are strings converted by GetString.
+        """
+        config_dict = {}
+        for key in self._cache:
+            config_dict[key] = self.GetString(key)
+        return config_dict
+    def GetBoolean(self, name: str) -> Union[str, None]:
+        """Returns a boolean from the configuration file.
+        Returns:
+            None: The value was not defined, or is not a boolean.
+            True: The value was set to true or yes.
+            False: The value was set to false or no.
+        """
+        v = self.GetString(name)
+        if v is None:
+            return None
+        v = v.lower()
+        if v in ("true", "yes"):
+            return True
+        if v in ("false", "no"):
+            return False
+        print(
+            f"warning: expected {name} to represent a boolean, got {v} instead",
+            file=sys.stderr,
+        )
+        return None
-  def GetString(self, name: str, all_keys: bool = False) -> Union[str, None]:
+    def SetBoolean(self, name, value):
-    """Get the first value for a key, or None if it is not defined.
+        """Set the truthy value for a key."""
+        if value is not None:
+            value = "true" if value else "false"
+        self.SetString(name, value)
-       This configuration file is used first, if the key is not
+    def GetString(self, name: str, all_keys: bool = False) -> Union[str, None]:
-       defined or all_keys = True then the defaults are also searched.
+        """Get the first value for a key, or None if it is not defined.
-    """
-    try:
-      v = self._cache[_key(name)]
-    except KeyError:
-      if self.defaults:
-        return self.defaults.GetString(name, all_keys=all_keys)
-      v = []
-    if not all_keys:
-      if v:
-        return v[0]
-      return None
-    r = []
-    r.extend(v)
-    if self.defaults:
-      r.extend(self.defaults.GetString(name, all_keys=True))
-    return r
-  def SetString(self, name, value):
-    """Set the value(s) for a key.
-       Only this configuration file is modified.
-       The supplied value should be either a string, or a list of strings (to
-       store multiple values), or None (to delete the key).
-    """
-    key = _key(name)
-    try:
+        This configuration file is used first, if the key is not
-      old = self._cache[key]
+        defined or all_keys = True then the defaults are also searched.
-    except KeyError:
+        """
-      old = []
+        try:
+            v = self._cache[_key(name)]
+        except KeyError:
+            if self.defaults:
+                return self.defaults.GetString(name, all_keys=all_keys)
+            v = []
+        if not all_keys:
+            if v:
+                return v[0]
+            return None
+        r = []
+        r.extend(v)
+        if self.defaults:
+            r.extend(self.defaults.GetString(name, all_keys=True))
+        return r
+    def SetString(self, name, value):
+        """Set the value(s) for a key.
+        Only this configuration file is modified.
+        The supplied value should be either a string, or a list of strings (to
+        store multiple values), or None (to delete the key).
+        """
+        key = _key(name)
-    if value is None:
+        try:
-      if old:
+            old = self._cache[key]
-        del self._cache[key]
+        except KeyError:
-        self._do('--unset-all', name)
+            old = []
+        if value is None:
+            if old:
+                del self._cache[key]
+                self._do("--unset-all", name)
+        elif isinstance(value, list):
+            if len(value) == 0:
+                self.SetString(name, None)
+            elif len(value) == 1:
+                self.SetString(name, value[0])
+            elif old != value:
+                self._cache[key] = list(value)
+                self._do("--replace-all", name, value[0])
+                for i in range(1, len(value)):
+                    self._do("--add", name, value[i])
+        elif len(old) != 1 or old[0] != value:
+            self._cache[key] = [value]
+            self._do("--replace-all", name, value)
+    def GetRemote(self, name):
+        """Get the remote.$name.* configuration values as an object."""
+        try:
+            r = self._remotes[name]
+        except KeyError:
+            r = Remote(self, name)
+            self._remotes[r.name] = r
+        return r
+    def GetBranch(self, name):
+        """Get the branch.$name.* configuration values as an object."""
+        try:
+            b = self._branches[name]
+        except KeyError:
+            b = Branch(self, name)
+            self._branches[b.name] = b
+        return b
+    def GetSyncAnalysisStateData(self):
+        """Returns data to be logged for the analysis of sync performance."""
+        return {
+            k: v
+            for k, v in self.DumpConfigDict().items()
+            if k.startswith(SYNC_STATE_PREFIX)
+        }
+    def UpdateSyncAnalysisState(self, options, superproject_logging_data):
+        """Update Config's SYNC_STATE_PREFIX* data with the latest sync data.
+        Args:
+            options: Options passed to sync returned from optparse. See
+                _Options().
+            superproject_logging_data: A dictionary of superproject data that is
+                to be logged.
+        Returns:
+            SyncAnalysisState object.
+        """
+        return SyncAnalysisState(self, options, superproject_logging_data)
+    def GetSubSections(self, section):
+        """List all subsection names matching $section.*.*"""
+        return self._sections.get(section, set())
+    def HasSection(self, section, subsection=""):
+        """Does at least one key in section.subsection exist?"""
+        try:
+            return subsection in self._sections[section]
+        except KeyError:
+            return False
+    def UrlInsteadOf(self, url):
+        """Resolve any url.*.insteadof references."""
+        for new_url in self.GetSubSections("url"):
+            for old_url in self.GetString("url.%s.insteadof" % new_url, True):
+                if old_url is not None and url.startswith(old_url):
+                    return new_url + url[len(old_url) :]
+        return url
+    @property
+    def _sections(self):
+        d = self._section_dict
+        if d is None:
+            d = {}
+            for name in self._cache.keys():
+                p = name.split(".")
+                if 2 == len(p):
+                    section = p[0]
+                    subsect = ""
+                else:
+                    section = p[0]
+                    subsect = ".".join(p[1:-1])
+                if section not in d:
+                    d[section] = set()
+                d[section].add(subsect)
+                self._section_dict = d
+        return d
+    @property
+    def _cache(self):
+        if self._cache_dict is None:
+            self._cache_dict = self._Read()
+        return self._cache_dict
+    def _Read(self):
+        d = self._ReadJson()
+        if d is None:
+            d = self._ReadGit()
+            self._SaveJson(d)
+        return d
+    def _ReadJson(self):
+        try:
+            if os.path.getmtime(self._json) <= os.path.getmtime(self.file):
+                platform_utils.remove(self._json)
+                return None
+        except OSError:
+            return None
+        try:
+            with Trace(": parsing %s", self.file):
+                with open(self._json) as fd:
+                    return json.load(fd)
+        except (IOError, ValueError):
+            platform_utils.remove(self._json, missing_ok=True)
+            return None
+    def _SaveJson(self, cache):
+        try:
+            with open(self._json, "w") as fd:
+                json.dump(cache, fd, indent=2)
+        except (IOError, TypeError):
+            platform_utils.remove(self._json, missing_ok=True)
+    def _ReadGit(self):
+        """
+        Read configuration data from git.
+        This internal method populates the GitConfig cache.
+        """
+        c = {}
+        if not os.path.exists(self.file):
+            return c
+        d = self._do("--null", "--list")
+        for line in d.rstrip("\0").split("\0"):
+            if "\n" in line:
+                key, val = line.split("\n", 1)
+            else:
+                key = line
+                val = None
+            if key in c:
+                c[key].append(val)
+            else:
+                c[key] = [val]
+        return c
+    def _do(self, *args):
+        if self.file == self._SYSTEM_CONFIG:
+            command = ["config", "--system", "--includes"]
+        else:
+            command = ["config", "--file", self.file, "--includes"]
+        command.extend(args)
-    elif isinstance(value, list):
+        p = GitCommand(None, command, capture_stdout=True, capture_stderr=True)
-      if len(value) == 0:
+        if p.Wait() == 0:
-        self.SetString(name, None)
+            return p.stdout
+        else:
+            raise GitError("git config %s: %s" % (str(args), p.stderr))
-      elif len(value) == 1:
-        self.SetString(name, value[0])
-      elif old != value:
+class RepoConfig(GitConfig):
-        self._cache[key] = list(value)
+    """User settings for repo itself."""
-        self._do('--replace-all', name, value[0])
-        for i in range(1, len(value)):
-          self._do('--add', name, value[i])
-    elif len(old) != 1 or old[0] != value:
+    @staticmethod
-      self._cache[key] = [value]
+    def _getUserConfig():
-      self._do('--replace-all', name, value)
+        repo_config_dir = os.getenv("REPO_CONFIG_DIR", os.path.expanduser("~"))
+        return os.path.join(repo_config_dir, ".repoconfig/config")
-  def GetRemote(self, name):
-    """Get the remote.$name.* configuration values as an object.
-    """
-    try:
-      r = self._remotes[name]
-    except KeyError:
-      r = Remote(self, name)
-      self._remotes[r.name] = r
-    return r
-  def GetBranch(self, name):
-    """Get the branch.$name.* configuration values as an object.
-    """
-    try:
-      b = self._branches[name]
-    except KeyError:
-      b = Branch(self, name)
-      self._branches[b.name] = b
-    return b
-  def GetSyncAnalysisStateData(self):
-    """Returns data to be logged for the analysis of sync performance."""
-    return {k: v for k, v in self.DumpConfigDict().items() if k.startswith(SYNC_STATE_PREFIX)}
-  def UpdateSyncAnalysisState(self, options, superproject_logging_data):
-    """Update Config's SYNC_STATE_PREFIX* data with the latest sync data.
-    Args:
-      options: Options passed to sync returned from optparse. See _Options().
-      superproject_logging_data: A dictionary of superproject data that is to be logged.
-    Returns:
-      SyncAnalysisState object.
-    """
-    return SyncAnalysisState(self, options, superproject_logging_data)
-  def GetSubSections(self, section):
+class RefSpec(object):
-    """List all subsection names matching $section.*.*
+    """A Git refspec line, split into its components:
-    """
-    return self._sections.get(section, set())
-  def HasSection(self, section, subsection=''):
+    forced:  True if the line starts with '+'
-    """Does at least one key in section.subsection exist?
+    src:     Left side of the line
+    dst:     Right side of the line
    """
-    try:
-      return subsection in self._sections[section]
-    except KeyError:
-      return False
-  def UrlInsteadOf(self, url):
+    @classmethod
-    """Resolve any url.*.insteadof references.
+    def FromString(cls, rs):
-    """
+        lhs, rhs = rs.split(":", 2)
-    for new_url in self.GetSubSections('url'):
+        if lhs.startswith("+"):
-      for old_url in self.GetString('url.%s.insteadof' % new_url, True):
+            lhs = lhs[1:]
-        if old_url is not None and url.startswith(old_url):
+            forced = True
-          return new_url + url[len(old_url):]
-    return url
-  @property
-  def _sections(self):
-    d = self._section_dict
-    if d is None:
-      d = {}
-      for name in self._cache.keys():
-        p = name.split('.')
-        if 2 == len(p):
-          section = p[0]
-          subsect = ''
        else:
-          section = p[0]
+            forced = False
-          subsect = '.'.join(p[1:-1])
+        return cls(forced, lhs, rhs)
-        if section not in d:
-          d[section] = set()
+    def __init__(self, forced, lhs, rhs):
-        d[section].add(subsect)
+        self.forced = forced
-        self._section_dict = d
+        self.src = lhs
-    return d
+        self.dst = rhs
-  @property
+    def SourceMatches(self, rev):
-  def _cache(self):
+        if self.src:
-    if self._cache_dict is None:
+            if rev == self.src:
-      self._cache_dict = self._Read()
+                return True
-    return self._cache_dict
+            if self.src.endswith("/*") and rev.startswith(self.src[:-1]):
+                return True
-  def _Read(self):
+        return False
-    d = self._ReadJson()
-    if d is None:
+    def DestMatches(self, ref):
-      d = self._ReadGit()
+        if self.dst:
-      self._SaveJson(d)
+            if ref == self.dst:
-    return d
+                return True
+            if self.dst.endswith("/*") and ref.startswith(self.dst[:-1]):
-  def _ReadJson(self):
+                return True
-    try:
+        return False
-      if os.path.getmtime(self._json) <= os.path.getmtime(self.file):
-        platform_utils.remove(self._json)
+    def MapSource(self, rev):
-        return None
+        if self.src.endswith("/*"):
-    except OSError:
+            return self.dst[:-1] + rev[len(self.src) - 1 :]
-      return None
+        return self.dst
-    try:
-      with Trace(': parsing %s', self.file):
+    def __str__(self):
-        with open(self._json) as fd:
+        s = ""
-          return json.load(fd)
+        if self.forced:
-    except (IOError, ValueError):
+            s += "+"
-      platform_utils.remove(self._json, missing_ok=True)
+        if self.src:
-      return None
+            s += self.src
+        if self.dst:
-  def _SaveJson(self, cache):
+            s += ":"
-    try:
+            s += self.dst
-      with open(self._json, 'w') as fd:
+        return s
-        json.dump(cache, fd, indent=2)
-    except (IOError, TypeError):
-      platform_utils.remove(self._json, missing_ok=True)
+URI_ALL = re.compile(r"^([a-z][a-z+-]*)://([^@/]*@?[^/]*)/")
-  def _ReadGit(self):
-    """
-    Read configuration data from git.
-    This internal method populates the GitConfig cache.
-    """
-    c = {}
-    if not os.path.exists(self.file):
-      return c
-    d = self._do('--null', '--list')
-    for line in d.rstrip('\0').split('\0'):
-      if '\n' in line:
-        key, val = line.split('\n', 1)
-      else:
-        key = line
-        val = None
-      if key in c:
-        c[key].append(val)
-      else:
-        c[key] = [val]
-    return c
-  def _do(self, *args):
-    if self.file == self._SYSTEM_CONFIG:
-      command = ['config', '--system', '--includes']
-    else:
-      command = ['config', '--file', self.file, '--includes']
-    command.extend(args)
-    p = GitCommand(None,
-                   command,
-                   capture_stdout=True,
-                   capture_stderr=True)
-    if p.Wait() == 0:
-      return p.stdout
-    else:
-      raise GitError('git config %s: %s' % (str(args), p.stderr))
-class RepoConfig(GitConfig):
-  """User settings for repo itself."""
-  @staticmethod
-  def _getUserConfig():
-    repo_config_dir = os.getenv('REPO_CONFIG_DIR', os.path.expanduser('~'))
-    return os.path.join(repo_config_dir, '.repoconfig/config')
-class RefSpec(object):
-  """A Git refspec line, split into its components:
-      forced:  True if the line starts with '+'
-      src:     Left side of the line
-      dst:     Right side of the line
-  """
-  @classmethod
-  def FromString(cls, rs):
-    lhs, rhs = rs.split(':', 2)
-    if lhs.startswith('+'):
-      lhs = lhs[1:]
-      forced = True
-    else:
-      forced = False
-    return cls(forced, lhs, rhs)
-  def __init__(self, forced, lhs, rhs):
-    self.forced = forced
-    self.src = lhs
-    self.dst = rhs
-  def SourceMatches(self, rev):
-    if self.src:
-      if rev == self.src:
-        return True
-      if self.src.endswith('/*') and rev.startswith(self.src[:-1]):
-        return True
-    return False
-  def DestMatches(self, ref):
-    if self.dst:
-      if ref == self.dst:
-        return True
-      if self.dst.endswith('/*') and ref.startswith(self.dst[:-1]):
-        return True
-    return False
-  def MapSource(self, rev):
-    if self.src.endswith('/*'):
-      return self.dst[:-1] + rev[len(self.src) - 1:]
-    return self.dst
-  def __str__(self):
-    s = ''
-    if self.forced:
-      s += '+'
-    if self.src:
-      s += self.src
-    if self.dst:
-      s += ':'
-      s += self.dst
-    return s
-URI_ALL = re.compile(r'^([a-z][a-z+-]*)://([^@/]*@?[^/]*)/')
 def GetSchemeFromUrl(url):
-  m = URI_ALL.match(url)
+    m = URI_ALL.match(url)
-  if m:
+    if m:
-    return m.group(1)
+        return m.group(1)
-  return None
+    return None
 @contextlib.contextmanager
 def GetUrlCookieFile(url, quiet):
-  if url.startswith('persistent-'):
+    if url.startswith("persistent-"):
-    try:
+        try:
-      p = subprocess.Popen(
+            p = subprocess.Popen(
-          ['git-remote-persistent-https', '-print_config', url],
+                ["git-remote-persistent-https", "-print_config", url],
-          stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+                stdin=subprocess.PIPE,
-          stderr=subprocess.PIPE)
+                stdout=subprocess.PIPE,
-      try:
+                stderr=subprocess.PIPE,
-        cookieprefix = 'http.cookiefile='
+            )
-        proxyprefix = 'http.proxy='
+            try:
-        cookiefile = None
+                cookieprefix = "http.cookiefile="
-        proxy = None
+                proxyprefix = "http.proxy="
-        for line in p.stdout:
+                cookiefile = None
-          line = line.strip().decode('utf-8')
+                proxy = None
-          if line.startswith(cookieprefix):
+                for line in p.stdout:
-            cookiefile = os.path.expanduser(line[len(cookieprefix):])
+                    line = line.strip().decode("utf-8")
-          if line.startswith(proxyprefix):
+                    if line.startswith(cookieprefix):
-            proxy = line[len(proxyprefix):]
+                        cookiefile = os.path.expanduser(
-        # Leave subprocess open, as cookie file may be transient.
+                            line[len(cookieprefix) :]
-        if cookiefile or proxy:
+                        )
-          yield cookiefile, proxy
+                    if line.startswith(proxyprefix):
-          return
+                        proxy = line[len(proxyprefix) :]
-      finally:
+                # Leave subprocess open, as cookie file may be transient.
-        p.stdin.close()
+                if cookiefile or proxy:
-        if p.wait():
+                    yield cookiefile, proxy
-          err_msg = p.stderr.read().decode('utf-8')
+                    return
-          if ' -print_config' in err_msg:
+            finally:
-            pass  # Persistent proxy doesn't support -print_config.
+                p.stdin.close()
-          elif not quiet:
+                if p.wait():
-            print(err_msg, file=sys.stderr)
+                    err_msg = p.stderr.read().decode("utf-8")
-    except OSError as e:
+                    if " -print_config" in err_msg:
-      if e.errno == errno.ENOENT:
+                        pass  # Persistent proxy doesn't support -print_config.
-        pass  # No persistent proxy.
+                    elif not quiet:
-      raise
+                        print(err_msg, file=sys.stderr)
-  cookiefile = GitConfig.ForUser().GetString('http.cookiefile')
+        except OSError as e:
-  if cookiefile:
+            if e.errno == errno.ENOENT:
-    cookiefile = os.path.expanduser(cookiefile)
+                pass  # No persistent proxy.
-  yield cookiefile, None
+            raise
+    cookiefile = GitConfig.ForUser().GetString("http.cookiefile")
+    if cookiefile:
+        cookiefile = os.path.expanduser(cookiefile)
+    yield cookiefile, None
 class Remote(object):
-  """Configuration options related to a remote.
+    """Configuration options related to a remote."""
-  """
+    def __init__(self, config, name):
-  def __init__(self, config, name):
+        self._config = config
-    self._config = config
+        self.name = name
-    self.name = name
+        self.url = self._Get("url")
-    self.url = self._Get('url')
+        self.pushUrl = self._Get("pushurl")
-    self.pushUrl = self._Get('pushurl')
+        self.review = self._Get("review")
-    self.review = self._Get('review')
+        self.projectname = self._Get("projectname")
-    self.projectname = self._Get('projectname')
+        self.fetch = list(
-    self.fetch = list(map(RefSpec.FromString,
+            map(RefSpec.FromString, self._Get("fetch", all_keys=True))
-                          self._Get('fetch', all_keys=True)))
+        )
-    self._review_url = None
+        self._review_url = None
-  def _InsteadOf(self):
+    def _InsteadOf(self):
-    globCfg = GitConfig.ForUser()
+        globCfg = GitConfig.ForUser()
-    urlList = globCfg.GetSubSections('url')
+        urlList = globCfg.GetSubSections("url")
-    longest = ""
+        longest = ""
-    longestUrl = ""
+        longestUrl = ""
-    for url in urlList:
+        for url in urlList:
-      key = "url." + url + ".insteadOf"
+            key = "url." + url + ".insteadOf"
-      insteadOfList = globCfg.GetString(key, all_keys=True)
+            insteadOfList = globCfg.GetString(key, all_keys=True)
-      for insteadOf in insteadOfList:
+            for insteadOf in insteadOfList:
-        if (self.url.startswith(insteadOf)
+                if self.url.startswith(insteadOf) and len(insteadOf) > len(
-                and len(insteadOf) > len(longest)):
+                    longest
-          longest = insteadOf
+                ):
-          longestUrl = url
+                    longest = insteadOf
+                    longestUrl = url
-    if len(longest) == 0:
-      return self.url
+        if len(longest) == 0:
+            return self.url
-    return self.url.replace(longest, longestUrl, 1)
+        return self.url.replace(longest, longestUrl, 1)
-  def PreConnectFetch(self, ssh_proxy):
-    """Run any setup for this remote before we connect to it.
+    def PreConnectFetch(self, ssh_proxy):
+        """Run any setup for this remote before we connect to it.
-    In practice, if the remote is using SSH, we'll attempt to create a new
-    SSH master session to it for reuse across projects.
+        In practice, if the remote is using SSH, we'll attempt to create a new
+        SSH master session to it for reuse across projects.
-    Args:
-      ssh_proxy: The SSH settings for managing master sessions.
+        Args:
+            ssh_proxy: The SSH settings for managing master sessions.
-    Returns:
-      Whether the preconnect phase for this remote was successful.
+        Returns:
-    """
+            Whether the preconnect phase for this remote was successful.
-    if not ssh_proxy:
+        """
-      return True
+        if not ssh_proxy:
+            return True
-    connectionUrl = self._InsteadOf()
-    return ssh_proxy.preconnect(connectionUrl)
+        connectionUrl = self._InsteadOf()
+        return ssh_proxy.preconnect(connectionUrl)
-  def ReviewUrl(self, userEmail, validate_certs):
-    if self._review_url is None:
+    def ReviewUrl(self, userEmail, validate_certs):
-      if self.review is None:
+        if self._review_url is None:
-        return None
+            if self.review is None:
+                return None
-      u = self.review
-      if u.startswith('persistent-'):
+            u = self.review
-        u = u[len('persistent-'):]
+            if u.startswith("persistent-"):
-      if u.split(':')[0] not in ('http', 'https', 'sso', 'ssh'):
+                u = u[len("persistent-") :]
-        u = 'http://%s' % u
+            if u.split(":")[0] not in ("http", "https", "sso", "ssh"):
-      if u.endswith('/Gerrit'):
+                u = "http://%s" % u
-        u = u[:len(u) - len('/Gerrit')]
+            if u.endswith("/Gerrit"):
-      if u.endswith('/ssh_info'):
+                u = u[: len(u) - len("/Gerrit")]
-        u = u[:len(u) - len('/ssh_info')]
+            if u.endswith("/ssh_info"):
-      if not u.endswith('/'):
+                u = u[: len(u) - len("/ssh_info")]
-        u += '/'
+            if not u.endswith("/"):
-      http_url = u
+                u += "/"
+            http_url = u
-      if u in REVIEW_CACHE:
-        self._review_url = REVIEW_CACHE[u]
+            if u in REVIEW_CACHE:
-      elif 'REPO_HOST_PORT_INFO' in os.environ:
+                self._review_url = REVIEW_CACHE[u]
-        host, port = os.environ['REPO_HOST_PORT_INFO'].split()
+            elif "REPO_HOST_PORT_INFO" in os.environ:
-        self._review_url = self._SshReviewUrl(userEmail, host, port)
+                host, port = os.environ["REPO_HOST_PORT_INFO"].split()
-        REVIEW_CACHE[u] = self._review_url
+                self._review_url = self._SshReviewUrl(userEmail, host, port)
-      elif u.startswith('sso:') or u.startswith('ssh:'):
+                REVIEW_CACHE[u] = self._review_url
-        self._review_url = u  # Assume it's right
+            elif u.startswith("sso:") or u.startswith("ssh:"):
-        REVIEW_CACHE[u] = self._review_url
+                self._review_url = u  # Assume it's right
-      elif 'REPO_IGNORE_SSH_INFO' in os.environ:
+                REVIEW_CACHE[u] = self._review_url
-        self._review_url = http_url
+            elif "REPO_IGNORE_SSH_INFO" in os.environ:
-        REVIEW_CACHE[u] = self._review_url
+                self._review_url = http_url
-      else:
+                REVIEW_CACHE[u] = self._review_url
-        try:
+            else:
-          info_url = u + 'ssh_info'
+                try:
-          if not validate_certs:
+                    info_url = u + "ssh_info"
-              context = ssl._create_unverified_context()
+                    if not validate_certs:
-              info = urllib.request.urlopen(info_url, context=context).read()
+                        context = ssl._create_unverified_context()
-          else:
+                        info = urllib.request.urlopen(
-              info = urllib.request.urlopen(info_url).read()
+                            info_url, context=context
-          if info == b'NOT_AVAILABLE' or b'<' in info:
+                        ).read()
-            # If `info` contains '<', we assume the server gave us some sort
+                    else:
-            # of HTML response back, like maybe a login page.
+                        info = urllib.request.urlopen(info_url).read()
-            #
+                    if info == b"NOT_AVAILABLE" or b"<" in info:
-            # Assume HTTP if SSH is not enabled or ssh_info doesn't look right.
+                        # If `info` contains '<', we assume the server gave us
-            self._review_url = http_url
+                        # some sort of HTML response back, like maybe a login
-          else:
+                        # page.
-            info = info.decode('utf-8')
+                        #
-            host, port = info.split()
+                        # Assume HTTP if SSH is not enabled or ssh_info doesn't
-            self._review_url = self._SshReviewUrl(userEmail, host, port)
+                        # look right.
-        except urllib.error.HTTPError as e:
+                        self._review_url = http_url
-          raise UploadError('%s: %s' % (self.review, str(e)))
+                    else:
-        except urllib.error.URLError as e:
+                        info = info.decode("utf-8")
-          raise UploadError('%s: %s' % (self.review, str(e)))
+                        host, port = info.split()
-        except HTTPException as e:
+                        self._review_url = self._SshReviewUrl(
-          raise UploadError('%s: %s' % (self.review, e.__class__.__name__))
+                            userEmail, host, port
+                        )
-        REVIEW_CACHE[u] = self._review_url
+                except urllib.error.HTTPError as e:
-    return self._review_url + self.projectname
+                    raise UploadError("%s: %s" % (self.review, str(e)))
+                except urllib.error.URLError as e:
-  def _SshReviewUrl(self, userEmail, host, port):
+                    raise UploadError("%s: %s" % (self.review, str(e)))
-    username = self._config.GetString('review.%s.username' % self.review)
+                except HTTPException as e:
-    if username is None:
+                    raise UploadError(
-      username = userEmail.split('@')[0]
+                        "%s: %s" % (self.review, e.__class__.__name__)
-    return 'ssh://%s@%s:%s/' % (username, host, port)
+                    )
-  def ToLocal(self, rev):
+                REVIEW_CACHE[u] = self._review_url
-    """Convert a remote revision string to something we have locally.
+        return self._review_url + self.projectname
-    """
-    if self.name == '.' or IsId(rev):
+    def _SshReviewUrl(self, userEmail, host, port):
-      return rev
+        username = self._config.GetString("review.%s.username" % self.review)
+        if username is None:
+            username = userEmail.split("@")[0]
+        return "ssh://%s@%s:%s/" % (username, host, port)
+    def ToLocal(self, rev):
+        """Convert a remote revision string to something we have locally."""
+        if self.name == "." or IsId(rev):
+            return rev
+        if not rev.startswith("refs/"):
+            rev = R_HEADS + rev
+        for spec in self.fetch:
+            if spec.SourceMatches(rev):
+                return spec.MapSource(rev)
+        if not rev.startswith(R_HEADS):
+            return rev
+        raise GitError(
+            "%s: remote %s does not have %s"
+            % (self.projectname, self.name, rev)
+        )
+    def WritesTo(self, ref):
+        """True if the remote stores to the tracking ref."""
+        for spec in self.fetch:
+            if spec.DestMatches(ref):
+                return True
+        return False
+    def ResetFetch(self, mirror=False):
+        """Set the fetch refspec to its default value."""
+        if mirror:
+            dst = "refs/heads/*"
+        else:
+            dst = "refs/remotes/%s/*" % self.name
+        self.fetch = [RefSpec(True, "refs/heads/*", dst)]
+    def Save(self):
+        """Save this remote to the configuration."""
+        self._Set("url", self.url)
+        if self.pushUrl is not None:
+            self._Set("pushurl", self.pushUrl + "/" + self.projectname)
+        else:
+            self._Set("pushurl", self.pushUrl)
+        self._Set("review", self.review)
+        self._Set("projectname", self.projectname)
+        self._Set("fetch", list(map(str, self.fetch)))
-    if not rev.startswith('refs/'):
+    def _Set(self, key, value):
-      rev = R_HEADS + rev
+        key = "remote.%s.%s" % (self.name, key)
+        return self._config.SetString(key, value)
-    for spec in self.fetch:
+    def _Get(self, key, all_keys=False):
-      if spec.SourceMatches(rev):
+        key = "remote.%s.%s" % (self.name, key)
-        return spec.MapSource(rev)
+        return self._config.GetString(key, all_keys=all_keys)
-    if not rev.startswith(R_HEADS):
-      return rev
-    raise GitError('%s: remote %s does not have %s' %
+class Branch(object):
-                   (self.projectname, self.name, rev))
+    """Configuration options related to a single branch."""
-  def WritesTo(self, ref):
+    def __init__(self, config, name):
-    """True if the remote stores to the tracking ref.
+        self._config = config
-    """
+        self.name = name
-    for spec in self.fetch:
+        self.merge = self._Get("merge")
-      if spec.DestMatches(ref):
-        return True
-    return False
-  def ResetFetch(self, mirror=False):
+        r = self._Get("remote")
-    """Set the fetch refspec to its default value.
+        if r:
-    """
+            self.remote = self._config.GetRemote(r)
-    if mirror:
+        else:
-      dst = 'refs/heads/*'
+            self.remote = None
-    else:
-      dst = 'refs/remotes/%s/*' % self.name
-    self.fetch = [RefSpec(True, 'refs/heads/*', dst)]
-  def Save(self):
-    """Save this remote to the configuration.
-    """
-    self._Set('url', self.url)
-    if self.pushUrl is not None:
-      self._Set('pushurl', self.pushUrl + '/' + self.projectname)
-    else:
-      self._Set('pushurl', self.pushUrl)
-    self._Set('review', self.review)
-    self._Set('projectname', self.projectname)
-    self._Set('fetch', list(map(str, self.fetch)))
-  def _Set(self, key, value):
+    @property
-    key = 'remote.%s.%s' % (self.name, key)
+    def LocalMerge(self):
-    return self._config.SetString(key, value)
+        """Convert the merge spec to a local name."""
+        if self.remote and self.merge:
+            return self.remote.ToLocal(self.merge)
+        return None
-  def _Get(self, key, all_keys=False):
+    def Save(self):
-    key = 'remote.%s.%s' % (self.name, key)
+        """Save this branch back into the configuration."""
-    return self._config.GetString(key, all_keys=all_keys)
+        if self._config.HasSection("branch", self.name):
+            if self.remote:
+                self._Set("remote", self.remote.name)
+            else:
+                self._Set("remote", None)
+            self._Set("merge", self.merge)
+        else:
+            with open(self._config.file, "a") as fd:
+                fd.write('[branch "%s"]\n' % self.name)
+                if self.remote:
+                    fd.write("\tremote = %s\n" % self.remote.name)
+                if self.merge:
+                    fd.write("\tmerge = %s\n" % self.merge)
-class Branch(object):
+    def _Set(self, key, value):
-  """Configuration options related to a single branch.
+        key = "branch.%s.%s" % (self.name, key)
-  """
+        return self._config.SetString(key, value)
-  def __init__(self, config, name):
-    self._config = config
-    self.name = name
-    self.merge = self._Get('merge')
-    r = self._Get('remote')
-    if r:
-      self.remote = self._config.GetRemote(r)
-    else:
-      self.remote = None
-  @property
-  def LocalMerge(self):
-    """Convert the merge spec to a local name.
-    """
-    if self.remote and self.merge:
-      return self.remote.ToLocal(self.merge)
-    return None
-  def Save(self):
+    def _Get(self, key, all_keys=False):
-    """Save this branch back into the configuration.
+        key = "branch.%s.%s" % (self.name, key)
-    """
+        return self._config.GetString(key, all_keys=all_keys)
-    if self._config.HasSection('branch', self.name):
-      if self.remote:
-        self._Set('remote', self.remote.name)
-      else:
-        self._Set('remote', None)
-      self._Set('merge', self.merge)
-    else:
-      with open(self._config.file, 'a') as fd:
-        fd.write('[branch "%s"]\n' % self.name)
-        if self.remote:
-          fd.write('\tremote = %s\n' % self.remote.name)
-        if self.merge:
-          fd.write('\tmerge = %s\n' % self.merge)
-  def _Set(self, key, value):
-    key = 'branch.%s.%s' % (self.name, key)
-    return self._config.SetString(key, value)
-  def _Get(self, key, all_keys=False):
-    key = 'branch.%s.%s' % (self.name, key)
-    return self._config.GetString(key, all_keys=all_keys)
 class SyncAnalysisState:
-  """Configuration options related to logging of sync state for analysis.
+    """Configuration options related to logging of sync state for analysis.
-  This object is versioned.
-  """
-  def __init__(self, config, options, superproject_logging_data):
-    """Initializes SyncAnalysisState.
-    Saves the following data into the |config| object.
-    - sys.argv, options, superproject's logging data.
-    - repo.*, branch.* and remote.* parameters from config object.
-    - Current time as synctime.
-    - Version number of the object.
-    All the keys saved by this object are prepended with SYNC_STATE_PREFIX.
+    This object is versioned.
-    Args:
-      config: GitConfig object to store all options.
-      options: Options passed to sync returned from optparse. See _Options().
-      superproject_logging_data: A dictionary of superproject data that is to be logged.
-    """
-    self._config = config
-    now = datetime.datetime.utcnow()
-    self._Set('main.synctime', now.isoformat() + 'Z')
-    self._Set('main.version', '1')
-    self._Set('sys.argv', sys.argv)
-    for key, value in superproject_logging_data.items():
-      self._Set(f'superproject.{key}', value)
-    for key, value in options.__dict__.items():
-      self._Set(f'options.{key}', value)
-    config_items = config.DumpConfigDict().items()
-    EXTRACT_NAMESPACES = {'repo', 'branch', 'remote'}
-    self._SetDictionary({k: v for k, v in config_items
-                         if not k.startswith(SYNC_STATE_PREFIX) and
-                         k.split('.', 1)[0] in EXTRACT_NAMESPACES})
-  def _SetDictionary(self, data):
-    """Save all key/value pairs of |data| dictionary.
-    Args:
-      data: A dictionary whose key/value are to be saved.
    """
-    for key, value in data.items():
-      self._Set(key, value)
-  def _Set(self, key, value):
+    def __init__(self, config, options, superproject_logging_data):
-    """Set the |value| for a |key| in the |_config| member.
+        """Initializes SyncAnalysisState.
-    |key| is prepended with the value of SYNC_STATE_PREFIX constant.
+        Saves the following data into the |config| object.
+        - sys.argv, options, superproject's logging data.
-    Args:
+        - repo.*, branch.* and remote.* parameters from config object.
-      key: Name of the key.
+        - Current time as synctime.
-      value: |value| could be of any type. If it is 'bool', it will be saved
+        - Version number of the object.
-             as a Boolean and for all other types, it will be saved as a String.
-    """
+        All the keys saved by this object are prepended with SYNC_STATE_PREFIX.
-    if value is None:
-      return
+        Args:
-    sync_key = f'{SYNC_STATE_PREFIX}{key}'
+            config: GitConfig object to store all options.
-    sync_key = sync_key.replace('_', '')
+            options: Options passed to sync returned from optparse. See
-    if isinstance(value, str):
+                _Options().
-      self._config.SetString(sync_key, value)
+            superproject_logging_data: A dictionary of superproject data that is
-    elif isinstance(value, bool):
+                to be logged.
-      self._config.SetBoolean(sync_key, value)
+        """
-    else:
+        self._config = config
-      self._config.SetString(sync_key, str(value))
+        now = datetime.datetime.utcnow()
+        self._Set("main.synctime", now.isoformat() + "Z")
+        self._Set("main.version", "1")
+        self._Set("sys.argv", sys.argv)
+        for key, value in superproject_logging_data.items():
+            self._Set(f"superproject.{key}", value)
+        for key, value in options.__dict__.items():
+            self._Set(f"options.{key}", value)
+        config_items = config.DumpConfigDict().items()
+        EXTRACT_NAMESPACES = {"repo", "branch", "remote"}
+        self._SetDictionary(
+            {
+                k: v
+                for k, v in config_items
+                if not k.startswith(SYNC_STATE_PREFIX)
+                and k.split(".", 1)[0] in EXTRACT_NAMESPACES
+            }
+        )
+    def _SetDictionary(self, data):
+        """Save all key/value pairs of |data| dictionary.
+        Args:
+            data: A dictionary whose key/value are to be saved.
+        """
+        for key, value in data.items():
+            self._Set(key, value)
+    def _Set(self, key, value):
+        """Set the |value| for a |key| in the |_config| member.
+        |key| is prepended with the value of SYNC_STATE_PREFIX constant.
+        Args:
+            key: Name of the key.
+            value: |value| could be of any type. If it is 'bool', it will be
+                saved as a Boolean and for all other types, it will be saved as
+                a String.
+        """
+        if value is None:
+            return
+        sync_key = f"{SYNC_STATE_PREFIX}{key}"
+        sync_key = sync_key.replace("_", "")
+        if isinstance(value, str):
+            self._config.SetString(sync_key, value)
+        elif isinstance(value, bool):
+            self._config.SetBoolean(sync_key, value)
+        else:
+            self._config.SetString(sync_key, str(value))
diff --git a/git_refs.py b/git_refs.py
index 300d2b30..aca1f90d 100644
--- a/git_refs.py
+++ b/git_refs.py
@@ -16,149 +16,150 @@ import os
 from repo_trace import Trace
 import platform_utils
-HEAD = 'HEAD'
+HEAD = "HEAD"
-R_CHANGES = 'refs/changes/'
+R_CHANGES = "refs/changes/"
-R_HEADS = 'refs/heads/'
+R_HEADS = "refs/heads/"
-R_TAGS = 'refs/tags/'
+R_TAGS = "refs/tags/"
-R_PUB = 'refs/published/'
+R_PUB = "refs/published/"
-R_WORKTREE = 'refs/worktree/'
+R_WORKTREE = "refs/worktree/"
-R_WORKTREE_M = R_WORKTREE + 'm/'
+R_WORKTREE_M = R_WORKTREE + "m/"
-R_M = 'refs/remotes/m/'
+R_M = "refs/remotes/m/"
 class GitRefs(object):
-  def __init__(self, gitdir):
+    def __init__(self, gitdir):
-    self._gitdir = gitdir
+        self._gitdir = gitdir
-    self._phyref = None
+        self._phyref = None
-    self._symref = None
+        self._symref = None
-    self._mtime = {}
+        self._mtime = {}
-  @property
+    @property
-  def all(self):
+    def all(self):
-    self._EnsureLoaded()
+        self._EnsureLoaded()
-    return self._phyref
+        return self._phyref
-  def get(self, name):
+    def get(self, name):
-    try:
-      return self.all[name]
-    except KeyError:
-      return ''
-  def deleted(self, name):
-    if self._phyref is not None:
-      if name in self._phyref:
-        del self._phyref[name]
-      if name in self._symref:
-        del self._symref[name]
-      if name in self._mtime:
-        del self._mtime[name]
-  def symref(self, name):
-    try:
-      self._EnsureLoaded()
-      return self._symref[name]
-    except KeyError:
-      return ''
-  def _EnsureLoaded(self):
-    if self._phyref is None or self._NeedUpdate():
-      self._LoadAll()
-  def _NeedUpdate(self):
-    with Trace(': scan refs %s', self._gitdir):
-      for name, mtime in self._mtime.items():
        try:
-          if mtime != os.path.getmtime(os.path.join(self._gitdir, name)):
+            return self.all[name]
-            return True
+        except KeyError:
+            return ""
+    def deleted(self, name):
+        if self._phyref is not None:
+            if name in self._phyref:
+                del self._phyref[name]
+            if name in self._symref:
+                del self._symref[name]
+            if name in self._mtime:
+                del self._mtime[name]
+    def symref(self, name):
+        try:
+            self._EnsureLoaded()
+            return self._symref[name]
+        except KeyError:
+            return ""
+    def _EnsureLoaded(self):
+        if self._phyref is None or self._NeedUpdate():
+            self._LoadAll()
+    def _NeedUpdate(self):
+        with Trace(": scan refs %s", self._gitdir):
+            for name, mtime in self._mtime.items():
+                try:
+                    if mtime != os.path.getmtime(
+                        os.path.join(self._gitdir, name)
+                    ):
+                        return True
+                except OSError:
+                    return True
+            return False
+    def _LoadAll(self):
+        with Trace(": load refs %s", self._gitdir):
+            self._phyref = {}
+            self._symref = {}
+            self._mtime = {}
+            self._ReadPackedRefs()
+            self._ReadLoose("refs/")
+            self._ReadLoose1(os.path.join(self._gitdir, HEAD), HEAD)
+            scan = self._symref
+            attempts = 0
+            while scan and attempts < 5:
+                scan_next = {}
+                for name, dest in scan.items():
+                    if dest in self._phyref:
+                        self._phyref[name] = self._phyref[dest]
+                    else:
+                        scan_next[name] = dest
+                scan = scan_next
+                attempts += 1
+    def _ReadPackedRefs(self):
+        path = os.path.join(self._gitdir, "packed-refs")
+        try:
+            fd = open(path, "r")
+            mtime = os.path.getmtime(path)
+        except IOError:
+            return
        except OSError:
-          return True
+            return
-      return False
+        try:
+            for line in fd:
-  def _LoadAll(self):
+                line = str(line)
-    with Trace(': load refs %s', self._gitdir):
+                if line[0] == "#":
+                    continue
-      self._phyref = {}
+                if line[0] == "^":
-      self._symref = {}
+                    continue
-      self._mtime = {}
+                line = line[:-1]
-      self._ReadPackedRefs()
+                p = line.split(" ")
-      self._ReadLoose('refs/')
+                ref_id = p[0]
-      self._ReadLoose1(os.path.join(self._gitdir, HEAD), HEAD)
+                name = p[1]
-      scan = self._symref
+                self._phyref[name] = ref_id
-      attempts = 0
+        finally:
-      while scan and attempts < 5:
+            fd.close()
-        scan_next = {}
+        self._mtime["packed-refs"] = mtime
-        for name, dest in scan.items():
-          if dest in self._phyref:
+    def _ReadLoose(self, prefix):
-            self._phyref[name] = self._phyref[dest]
+        base = os.path.join(self._gitdir, prefix)
-          else:
+        for name in platform_utils.listdir(base):
-            scan_next[name] = dest
+            p = os.path.join(base, name)
-        scan = scan_next
+            # We don't implement the full ref validation algorithm, just the
-        attempts += 1
+            # simple rules that would show up in local filesystems.
+            # https://git-scm.com/docs/git-check-ref-format
-  def _ReadPackedRefs(self):
+            if name.startswith(".") or name.endswith(".lock"):
-    path = os.path.join(self._gitdir, 'packed-refs')
+                pass
-    try:
+            elif platform_utils.isdir(p):
-      fd = open(path, 'r')
+                self._mtime[prefix] = os.path.getmtime(base)
-      mtime = os.path.getmtime(path)
+                self._ReadLoose(prefix + name + "/")
-    except IOError:
+            else:
-      return
+                self._ReadLoose1(p, prefix + name)
-    except OSError:
-      return
+    def _ReadLoose1(self, path, name):
-    try:
+        try:
-      for line in fd:
+            with open(path) as fd:
-        line = str(line)
+                mtime = os.path.getmtime(path)
-        if line[0] == '#':
+                ref_id = fd.readline()
-          continue
+        except (OSError, UnicodeError):
-        if line[0] == '^':
+            return
-          continue
+        try:
-        line = line[:-1]
+            ref_id = ref_id.decode()
-        p = line.split(' ')
+        except AttributeError:
-        ref_id = p[0]
+            pass
-        name = p[1]
+        if not ref_id:
+            return
-        self._phyref[name] = ref_id
+        ref_id = ref_id[:-1]
-    finally:
-      fd.close()
+        if ref_id.startswith("ref: "):
-    self._mtime['packed-refs'] = mtime
+            self._symref[name] = ref_id[5:]
+        else:
-  def _ReadLoose(self, prefix):
+            self._phyref[name] = ref_id
-    base = os.path.join(self._gitdir, prefix)
+        self._mtime[name] = mtime
-    for name in platform_utils.listdir(base):
-      p = os.path.join(base, name)
-      # We don't implement the full ref validation algorithm, just the simple
-      # rules that would show up in local filesystems.
-      # https://git-scm.com/docs/git-check-ref-format
-      if name.startswith('.') or name.endswith('.lock'):
-        pass
-      elif platform_utils.isdir(p):
-        self._mtime[prefix] = os.path.getmtime(base)
-        self._ReadLoose(prefix + name + '/')
-      else:
-        self._ReadLoose1(p, prefix + name)
-  def _ReadLoose1(self, path, name):
-    try:
-      with open(path) as fd:
-        mtime = os.path.getmtime(path)
-        ref_id = fd.readline()
-    except (OSError, UnicodeError):
-      return
-    try:
-      ref_id = ref_id.decode()
-    except AttributeError:
-      pass
-    if not ref_id:
-      return
-    ref_id = ref_id[:-1]
-    if ref_id.startswith('ref: '):
-      self._symref[name] = ref_id[5:]
-    else:
-      self._phyref[name] = ref_id
-    self._mtime[name] = mtime
diff --git a/git_superproject.py b/git_superproject.py
index 69a4d1fe..f1b4f231 100644
--- a/git_superproject.py
+++ b/git_superproject.py
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
-"""Provide functionality to get all projects and their commit ids from Superproject.
+"""Provide functionality to get projects and their commit ids from Superproject.
 For more information on superproject, check out:
 https://en.wikibooks.org/wiki/Git/Submodules_and_Superprojects
@@ -33,434 +33,524 @@ from git_command import git_require, GitCommand
 from git_config import RepoConfig
 from git_refs import GitRefs
-_SUPERPROJECT_GIT_NAME = 'superproject.git'
+_SUPERPROJECT_GIT_NAME = "superproject.git"
-_SUPERPROJECT_MANIFEST_NAME = 'superproject_override.xml'
+_SUPERPROJECT_MANIFEST_NAME = "superproject_override.xml"
 class SyncResult(NamedTuple):
-  """Return the status of sync and whether caller should exit."""
+    """Return the status of sync and whether caller should exit."""
-  # Whether the superproject sync was successful.
+    # Whether the superproject sync was successful.
-  success: bool
+    success: bool
-  # Whether the caller should exit.
+    # Whether the caller should exit.
-  fatal: bool
+    fatal: bool
 class CommitIdsResult(NamedTuple):
-  """Return the commit ids and whether caller should exit."""
+    """Return the commit ids and whether caller should exit."""
-  # A dictionary with the projects/commit ids on success, otherwise None.
+    # A dictionary with the projects/commit ids on success, otherwise None.
-  commit_ids: dict
+    commit_ids: dict
-  # Whether the caller should exit.
+    # Whether the caller should exit.
-  fatal: bool
+    fatal: bool
 class UpdateProjectsResult(NamedTuple):
-  """Return the overriding manifest file and whether caller should exit."""
+    """Return the overriding manifest file and whether caller should exit."""
-  # Path name of the overriding manifest file if successful, otherwise None.
+    # Path name of the overriding manifest file if successful, otherwise None.
-  manifest_path: str
+    manifest_path: str
-  # Whether the caller should exit.
+    # Whether the caller should exit.
-  fatal: bool
+    fatal: bool
 class Superproject(object):
-  """Get commit ids from superproject.
+    """Get commit ids from superproject.
-  Initializes a local copy of a superproject for the manifest. This allows
+    Initializes a local copy of a superproject for the manifest. This allows
-  lookup of commit ids for all projects. It contains _project_commit_ids which
+    lookup of commit ids for all projects. It contains _project_commit_ids which
-  is a dictionary with project/commit id entries.
+    is a dictionary with project/commit id entries.
-  """
-  def __init__(self, manifest, name, remote, revision,
-               superproject_dir='exp-superproject'):
-    """Initializes superproject.
-    Args:
-      manifest: A Manifest object that is to be written to a file.
-      name: The unique name of the superproject
-      remote: The RemoteSpec for the remote.
-      revision: The name of the git branch to track.
-      superproject_dir: Relative path under |manifest.subdir| to checkout
-          superproject.
-    """
-    self._project_commit_ids = None
-    self._manifest = manifest
-    self.name = name
-    self.remote = remote
-    self.revision = self._branch = revision
-    self._repodir = manifest.repodir
-    self._superproject_dir = superproject_dir
-    self._superproject_path = manifest.SubmanifestInfoDir(manifest.path_prefix,
-                                                          superproject_dir)
-    self._manifest_path = os.path.join(self._superproject_path,
-                                       _SUPERPROJECT_MANIFEST_NAME)
-    git_name = hashlib.md5(remote.name.encode('utf8')).hexdigest() + '-'
-    self._remote_url = remote.url
-    self._work_git_name = git_name + _SUPERPROJECT_GIT_NAME
-    self._work_git = os.path.join(self._superproject_path, self._work_git_name)
-    # The following are command arguemnts, rather than superproject attributes,
-    # and were included here originally.  They should eventually become
-    # arguments that are passed down from the public methods, instead of being
-    # treated as attributes.
-    self._git_event_log = None
-    self._quiet = False
-    self._print_messages = False
-  def SetQuiet(self, value):
-    """Set the _quiet attribute."""
-    self._quiet = value
-  def SetPrintMessages(self, value):
-    """Set the _print_messages attribute."""
-    self._print_messages = value
-  @property
-  def project_commit_ids(self):
-    """Returns a dictionary of projects and their commit ids."""
-    return self._project_commit_ids
-  @property
-  def manifest_path(self):
-    """Returns the manifest path if the path exists or None."""
-    return self._manifest_path if os.path.exists(self._manifest_path) else None
-  def _LogMessage(self, fmt, *inputs):
-    """Logs message to stderr and _git_event_log."""
-    message = f'{self._LogMessagePrefix()} {fmt.format(*inputs)}'
-    if self._print_messages:
-      print(message, file=sys.stderr)
-    self._git_event_log.ErrorEvent(message, fmt)
-  def _LogMessagePrefix(self):
-    """Returns the prefix string to be logged in each log message"""
-    return f'repo superproject branch: {self._branch} url: {self._remote_url}'
-  def _LogError(self, fmt, *inputs):
-    """Logs error message to stderr and _git_event_log."""
-    self._LogMessage(f'error: {fmt}', *inputs)
-  def _LogWarning(self, fmt, *inputs):
-    """Logs warning message to stderr and _git_event_log."""
-    self._LogMessage(f'warning: {fmt}', *inputs)
-  def _Init(self):
-    """Sets up a local Git repository to get a copy of a superproject.
-    Returns:
-      True if initialization is successful, or False.
-    """
-    if not os.path.exists(self._superproject_path):
-      os.mkdir(self._superproject_path)
-    if not self._quiet and not os.path.exists(self._work_git):
-      print('%s: Performing initial setup for superproject; this might take '
-            'several minutes.' % self._work_git)
-    cmd = ['init', '--bare', self._work_git_name]
-    p = GitCommand(None,
-                   cmd,
-                   cwd=self._superproject_path,
-                   capture_stdout=True,
-                   capture_stderr=True)
-    retval = p.Wait()
-    if retval:
-      self._LogWarning('git init call failed, command: git {}, '
-                       'return code: {}, stderr: {}', cmd, retval, p.stderr)
-      return False
-    return True
-  def _Fetch(self):
-    """Fetches a local copy of a superproject for the manifest based on |_remote_url|.
-    Returns:
-      True if fetch is successful, or False.
-    """
-    if not os.path.exists(self._work_git):
-      self._LogWarning('git fetch missing directory: {}', self._work_git)
-      return False
-    if not git_require((2, 28, 0)):
-      self._LogWarning('superproject requires a git version 2.28 or later')
-      return False
-    cmd = ['fetch', self._remote_url, '--depth', '1', '--force', '--no-tags',
-           '--filter', 'blob:none']
-    # Check if there is a local ref that we can pass to --negotiation-tip.
-    # If this is the first fetch, it does not exist yet.
-    # We use --negotiation-tip to speed up the fetch. Superproject branches do
-    # not share commits. So this lets git know it only needs to send commits
-    # reachable from the specified local refs.
-    rev_commit = GitRefs(self._work_git).get(f'refs/heads/{self.revision}')
-    if rev_commit:
-      cmd.extend(['--negotiation-tip', rev_commit])
-    if self._branch:
-      cmd += [self._branch + ':' + self._branch]
-    p = GitCommand(None,
-                   cmd,
-                   cwd=self._work_git,
-                   capture_stdout=True,
-                   capture_stderr=True)
-    retval = p.Wait()
-    if retval:
-      self._LogWarning('git fetch call failed, command: git {}, '
-                       'return code: {}, stderr: {}', cmd, retval, p.stderr)
-      return False
-    return True
-  def _LsTree(self):
-    """Gets the commit ids for all projects.
-    Works only in git repositories.
-    Returns:
-      data: data returned from 'git ls-tree ...' instead of None.
-    """
-    if not os.path.exists(self._work_git):
-      self._LogWarning('git ls-tree missing directory: {}', self._work_git)
-      return None
-    data = None
-    branch = 'HEAD' if not self._branch else self._branch
-    cmd = ['ls-tree', '-z', '-r', branch]
-    p = GitCommand(None,
-                   cmd,
-                   cwd=self._work_git,
-                   capture_stdout=True,
-                   capture_stderr=True)
-    retval = p.Wait()
-    if retval == 0:
-      data = p.stdout
-    else:
-      self._LogWarning('git ls-tree call failed, command: git {}, '
-                       'return code: {}, stderr: {}', cmd, retval, p.stderr)
-    return data
-  def Sync(self, git_event_log):
-    """Gets a local copy of a superproject for the manifest.
-    Args:
-      git_event_log: an EventLog, for git tracing.
-    Returns:
-      SyncResult
-    """
-    self._git_event_log = git_event_log
-    if not self._manifest.superproject:
-      self._LogWarning('superproject tag is not defined in manifest: {}',
-                       self._manifest.manifestFile)
-      return SyncResult(False, False)
-    _PrintBetaNotice()
-    should_exit = True
-    if not self._remote_url:
-      self._LogWarning('superproject URL is not defined in manifest: {}',
-                       self._manifest.manifestFile)
-      return SyncResult(False, should_exit)
-    if not self._Init():
-      return SyncResult(False, should_exit)
-    if not self._Fetch():
-      return SyncResult(False, should_exit)
-    if not self._quiet:
-      print('%s: Initial setup for superproject completed.' % self._work_git)
-    return SyncResult(True, False)
-  def _GetAllProjectsCommitIds(self):
-    """Get commit ids for all projects from superproject and save them in _project_commit_ids.
-    Returns:
-      CommitIdsResult
-    """
-    sync_result = self.Sync(self._git_event_log)
-    if not sync_result.success:
-      return CommitIdsResult(None, sync_result.fatal)
-    data = self._LsTree()
-    if not data:
-      self._LogWarning('git ls-tree failed to return data for manifest: {}',
-                       self._manifest.manifestFile)
-      return CommitIdsResult(None, True)
-    # Parse lines like the following to select lines starting with '160000' and
-    # build a dictionary with project path (last element) and its commit id (3rd element).
-    #
-    # 160000 commit 2c2724cb36cd5a9cec6c852c681efc3b7c6b86ea\tart\x00
-    # 120000 blob acc2cbdf438f9d2141f0ae424cec1d8fc4b5d97f\tbootstrap.bash\x00
-    commit_ids = {}
-    for line in data.split('\x00'):
-      ls_data = line.split(None, 3)
-      if not ls_data:
-        break
-      if ls_data[0] == '160000':
-        commit_ids[ls_data[3]] = ls_data[2]
-    self._project_commit_ids = commit_ids
-    return CommitIdsResult(commit_ids, False)
-  def _WriteManifestFile(self):
-    """Writes manifest to a file.
-    Returns:
-      manifest_path: Path name of the file into which manifest is written instead of None.
-    """
-    if not os.path.exists(self._superproject_path):
-      self._LogWarning('missing superproject directory: {}', self._superproject_path)
-      return None
-    manifest_str = self._manifest.ToXml(groups=self._manifest.GetGroupsStr(),
-                                        omit_local=True).toxml()
-    manifest_path = self._manifest_path
-    try:
-      with open(manifest_path, 'w', encoding='utf-8') as fp:
-        fp.write(manifest_str)
-    except IOError as e:
-      self._LogError('cannot write manifest to : {} {}',
-                     manifest_path, e)
-      return None
-    return manifest_path
-  def _SkipUpdatingProjectRevisionId(self, project):
-    """Checks if a project's revision id needs to be updated or not.
-    Revision id for projects from local manifest will not be updated.
-    Args:
-      project: project whose revision id is being updated.
-    Returns:
-      True if a project's revision id should not be updated, or False,
    """
-    path = project.relpath
-    if not path:
-      return True
-    # Skip the project with revisionId.
-    if project.revisionId:
-      return True
-    # Skip the project if it comes from the local manifest.
-    return project.manifest.IsFromLocalManifest(project)
-  def UpdateProjectsRevisionId(self, projects, git_event_log):
-    """Update revisionId of every project in projects with the commit id.
-    Args:
-      projects: a list of projects whose revisionId needs to be updated.
-      git_event_log: an EventLog, for git tracing.
-    Returns:
+    def __init__(
-      UpdateProjectsResult
+        self,
-    """
+        manifest,
-    self._git_event_log = git_event_log
+        name,
-    commit_ids_result = self._GetAllProjectsCommitIds()
+        remote,
-    commit_ids = commit_ids_result.commit_ids
+        revision,
-    if not commit_ids:
+        superproject_dir="exp-superproject",
-      return UpdateProjectsResult(None, commit_ids_result.fatal)
+    ):
+        """Initializes superproject.
-    projects_missing_commit_ids = []
-    for project in projects:
+        Args:
-      if self._SkipUpdatingProjectRevisionId(project):
+            manifest: A Manifest object that is to be written to a file.
-        continue
+            name: The unique name of the superproject
-      path = project.relpath
+            remote: The RemoteSpec for the remote.
-      commit_id = commit_ids.get(path)
+            revision: The name of the git branch to track.
-      if not commit_id:
+            superproject_dir: Relative path under |manifest.subdir| to checkout
-        projects_missing_commit_ids.append(path)
+                superproject.
+        """
-    # If superproject doesn't have a commit id for a project, then report an
+        self._project_commit_ids = None
-    # error event and continue as if do not use superproject is specified.
+        self._manifest = manifest
-    if projects_missing_commit_ids:
+        self.name = name
-      self._LogWarning('please file a bug using {} to report missing '
+        self.remote = remote
-                       'commit_ids for: {}', self._manifest.contactinfo.bugurl,
+        self.revision = self._branch = revision
-                       projects_missing_commit_ids)
+        self._repodir = manifest.repodir
-      return UpdateProjectsResult(None, False)
+        self._superproject_dir = superproject_dir
+        self._superproject_path = manifest.SubmanifestInfoDir(
-    for project in projects:
+            manifest.path_prefix, superproject_dir
-      if not self._SkipUpdatingProjectRevisionId(project):
+        )
-        project.SetRevisionId(commit_ids.get(project.relpath))
+        self._manifest_path = os.path.join(
+            self._superproject_path, _SUPERPROJECT_MANIFEST_NAME
-    manifest_path = self._WriteManifestFile()
+        )
-    return UpdateProjectsResult(manifest_path, False)
+        git_name = hashlib.md5(remote.name.encode("utf8")).hexdigest() + "-"
+        self._remote_url = remote.url
+        self._work_git_name = git_name + _SUPERPROJECT_GIT_NAME
+        self._work_git = os.path.join(
+            self._superproject_path, self._work_git_name
+        )
+        # The following are command arguemnts, rather than superproject
+        # attributes, and were included here originally.  They should eventually
+        # become arguments that are passed down from the public methods, instead
+        # of being treated as attributes.
+        self._git_event_log = None
+        self._quiet = False
+        self._print_messages = False
+    def SetQuiet(self, value):
+        """Set the _quiet attribute."""
+        self._quiet = value
+    def SetPrintMessages(self, value):
+        """Set the _print_messages attribute."""
+        self._print_messages = value
+    @property
+    def project_commit_ids(self):
+        """Returns a dictionary of projects and their commit ids."""
+        return self._project_commit_ids
+    @property
+    def manifest_path(self):
+        """Returns the manifest path if the path exists or None."""
+        return (
+            self._manifest_path if os.path.exists(self._manifest_path) else None
+        )
+    def _LogMessage(self, fmt, *inputs):
+        """Logs message to stderr and _git_event_log."""
+        message = f"{self._LogMessagePrefix()} {fmt.format(*inputs)}"
+        if self._print_messages:
+            print(message, file=sys.stderr)
+        self._git_event_log.ErrorEvent(message, fmt)
+    def _LogMessagePrefix(self):
+        """Returns the prefix string to be logged in each log message"""
+        return (
+            f"repo superproject branch: {self._branch} url: {self._remote_url}"
+        )
+    def _LogError(self, fmt, *inputs):
+        """Logs error message to stderr and _git_event_log."""
+        self._LogMessage(f"error: {fmt}", *inputs)
+    def _LogWarning(self, fmt, *inputs):
+        """Logs warning message to stderr and _git_event_log."""
+        self._LogMessage(f"warning: {fmt}", *inputs)
+    def _Init(self):
+        """Sets up a local Git repository to get a copy of a superproject.
+        Returns:
+            True if initialization is successful, or False.
+        """
+        if not os.path.exists(self._superproject_path):
+            os.mkdir(self._superproject_path)
+        if not self._quiet and not os.path.exists(self._work_git):
+            print(
+                "%s: Performing initial setup for superproject; this might "
+                "take several minutes." % self._work_git
+            )
+        cmd = ["init", "--bare", self._work_git_name]
+        p = GitCommand(
+            None,
+            cmd,
+            cwd=self._superproject_path,
+            capture_stdout=True,
+            capture_stderr=True,
+        )
+        retval = p.Wait()
+        if retval:
+            self._LogWarning(
+                "git init call failed, command: git {}, "
+                "return code: {}, stderr: {}",
+                cmd,
+                retval,
+                p.stderr,
+            )
+            return False
+        return True
+    def _Fetch(self):
+        """Fetches a superproject for the manifest based on |_remote_url|.
+        This runs git fetch which stores a local copy the superproject.
+        Returns:
+            True if fetch is successful, or False.
+        """
+        if not os.path.exists(self._work_git):
+            self._LogWarning("git fetch missing directory: {}", self._work_git)
+            return False
+        if not git_require((2, 28, 0)):
+            self._LogWarning(
+                "superproject requires a git version 2.28 or later"
+            )
+            return False
+        cmd = [
+            "fetch",
+            self._remote_url,
+            "--depth",
+            "1",
+            "--force",
+            "--no-tags",
+            "--filter",
+            "blob:none",
+        ]
+        # Check if there is a local ref that we can pass to --negotiation-tip.
+        # If this is the first fetch, it does not exist yet.
+        # We use --negotiation-tip to speed up the fetch. Superproject branches
+        # do not share commits. So this lets git know it only needs to send
+        # commits reachable from the specified local refs.
+        rev_commit = GitRefs(self._work_git).get(f"refs/heads/{self.revision}")
+        if rev_commit:
+            cmd.extend(["--negotiation-tip", rev_commit])
+        if self._branch:
+            cmd += [self._branch + ":" + self._branch]
+        p = GitCommand(
+            None,
+            cmd,
+            cwd=self._work_git,
+            capture_stdout=True,
+            capture_stderr=True,
+        )
+        retval = p.Wait()
+        if retval:
+            self._LogWarning(
+                "git fetch call failed, command: git {}, "
+                "return code: {}, stderr: {}",
+                cmd,
+                retval,
+                p.stderr,
+            )
+            return False
+        return True
+    def _LsTree(self):
+        """Gets the commit ids for all projects.
+        Works only in git repositories.
+        Returns:
+            data: data returned from 'git ls-tree ...' instead of None.
+        """
+        if not os.path.exists(self._work_git):
+            self._LogWarning(
+                "git ls-tree missing directory: {}", self._work_git
+            )
+            return None
+        data = None
+        branch = "HEAD" if not self._branch else self._branch
+        cmd = ["ls-tree", "-z", "-r", branch]
+        p = GitCommand(
+            None,
+            cmd,
+            cwd=self._work_git,
+            capture_stdout=True,
+            capture_stderr=True,
+        )
+        retval = p.Wait()
+        if retval == 0:
+            data = p.stdout
+        else:
+            self._LogWarning(
+                "git ls-tree call failed, command: git {}, "
+                "return code: {}, stderr: {}",
+                cmd,
+                retval,
+                p.stderr,
+            )
+        return data
+    def Sync(self, git_event_log):
+        """Gets a local copy of a superproject for the manifest.
+        Args:
+            git_event_log: an EventLog, for git tracing.
+        Returns:
+            SyncResult
+        """
+        self._git_event_log = git_event_log
+        if not self._manifest.superproject:
+            self._LogWarning(
+                "superproject tag is not defined in manifest: {}",
+                self._manifest.manifestFile,
+            )
+            return SyncResult(False, False)
+        _PrintBetaNotice()
+        should_exit = True
+        if not self._remote_url:
+            self._LogWarning(
+                "superproject URL is not defined in manifest: {}",
+                self._manifest.manifestFile,
+            )
+            return SyncResult(False, should_exit)
+        if not self._Init():
+            return SyncResult(False, should_exit)
+        if not self._Fetch():
+            return SyncResult(False, should_exit)
+        if not self._quiet:
+            print(
+                "%s: Initial setup for superproject completed." % self._work_git
+            )
+        return SyncResult(True, False)
+    def _GetAllProjectsCommitIds(self):
+        """Get commit ids for all projects from superproject and save them.
+        Commit ids are saved in _project_commit_ids.
+        Returns:
+            CommitIdsResult
+        """
+        sync_result = self.Sync(self._git_event_log)
+        if not sync_result.success:
+            return CommitIdsResult(None, sync_result.fatal)
+        data = self._LsTree()
+        if not data:
+            self._LogWarning(
+                "git ls-tree failed to return data for manifest: {}",
+                self._manifest.manifestFile,
+            )
+            return CommitIdsResult(None, True)
+        # Parse lines like the following to select lines starting with '160000'
+        # and build a dictionary with project path (last element) and its commit
+        # id (3rd element).
+        #
+        # 160000 commit 2c2724cb36cd5a9cec6c852c681efc3b7c6b86ea\tart\x00
+        # 120000 blob acc2cbdf438f9d2141f0ae424cec1d8fc4b5d97f\tbootstrap.bash\x00  # noqa: E501
+        commit_ids = {}
+        for line in data.split("\x00"):
+            ls_data = line.split(None, 3)
+            if not ls_data:
+                break
+            if ls_data[0] == "160000":
+                commit_ids[ls_data[3]] = ls_data[2]
+        self._project_commit_ids = commit_ids
+        return CommitIdsResult(commit_ids, False)
+    def _WriteManifestFile(self):
+        """Writes manifest to a file.
+        Returns:
+            manifest_path: Path name of the file into which manifest is written
+                instead of None.
+        """
+        if not os.path.exists(self._superproject_path):
+            self._LogWarning(
+                "missing superproject directory: {}", self._superproject_path
+            )
+            return None
+        manifest_str = self._manifest.ToXml(
+            groups=self._manifest.GetGroupsStr(), omit_local=True
+        ).toxml()
+        manifest_path = self._manifest_path
+        try:
+            with open(manifest_path, "w", encoding="utf-8") as fp:
+                fp.write(manifest_str)
+        except IOError as e:
+            self._LogError("cannot write manifest to : {} {}", manifest_path, e)
+            return None
+        return manifest_path
+    def _SkipUpdatingProjectRevisionId(self, project):
+        """Checks if a project's revision id needs to be updated or not.
+        Revision id for projects from local manifest will not be updated.
+        Args:
+            project: project whose revision id is being updated.
+        Returns:
+            True if a project's revision id should not be updated, or False,
+        """
+        path = project.relpath
+        if not path:
+            return True
+        # Skip the project with revisionId.
+        if project.revisionId:
+            return True
+        # Skip the project if it comes from the local manifest.
+        return project.manifest.IsFromLocalManifest(project)
+    def UpdateProjectsRevisionId(self, projects, git_event_log):
+        """Update revisionId of every project in projects with the commit id.
+        Args:
+            projects: a list of projects whose revisionId needs to be updated.
+            git_event_log: an EventLog, for git tracing.
+        Returns:
+            UpdateProjectsResult
+        """
+        self._git_event_log = git_event_log
+        commit_ids_result = self._GetAllProjectsCommitIds()
+        commit_ids = commit_ids_result.commit_ids
+        if not commit_ids:
+            return UpdateProjectsResult(None, commit_ids_result.fatal)
+        projects_missing_commit_ids = []
+        for project in projects:
+            if self._SkipUpdatingProjectRevisionId(project):
+                continue
+            path = project.relpath
+            commit_id = commit_ids.get(path)
+            if not commit_id:
+                projects_missing_commit_ids.append(path)
+        # If superproject doesn't have a commit id for a project, then report an
+        # error event and continue as if do not use superproject is specified.
+        if projects_missing_commit_ids:
+            self._LogWarning(
+                "please file a bug using {} to report missing "
+                "commit_ids for: {}",
+                self._manifest.contactinfo.bugurl,
+                projects_missing_commit_ids,
+            )
+            return UpdateProjectsResult(None, False)
+        for project in projects:
+            if not self._SkipUpdatingProjectRevisionId(project):
+                project.SetRevisionId(commit_ids.get(project.relpath))
+        manifest_path = self._WriteManifestFile()
+        return UpdateProjectsResult(manifest_path, False)
 @functools.lru_cache(maxsize=10)
 def _PrintBetaNotice():
-  """Print the notice of beta status."""
+    """Print the notice of beta status."""
-  print('NOTICE: --use-superproject is in beta; report any issues to the '
+    print(
-        'address described in `repo version`', file=sys.stderr)
+        "NOTICE: --use-superproject is in beta; report any issues to the "
+        "address described in `repo version`",
+        file=sys.stderr,
+    )
 @functools.lru_cache(maxsize=None)
 def _UseSuperprojectFromConfiguration():
-  """Returns the user choice of whether to use superproject."""
+    """Returns the user choice of whether to use superproject."""
-  user_cfg = RepoConfig.ForUser()
+    user_cfg = RepoConfig.ForUser()
-  time_now = int(time.time())
+    time_now = int(time.time())
-  user_value = user_cfg.GetBoolean('repo.superprojectChoice')
+    user_value = user_cfg.GetBoolean("repo.superprojectChoice")
-  if user_value is not None:
+    if user_value is not None:
-    user_expiration = user_cfg.GetInt('repo.superprojectChoiceExpire')
+        user_expiration = user_cfg.GetInt("repo.superprojectChoiceExpire")
-    if user_expiration is None or user_expiration <= 0 or user_expiration >= time_now:
+        if (
-      # TODO(b/190688390) - Remove prompt when we are comfortable with the new
+            user_expiration is None
-      # default value.
+            or user_expiration <= 0
-      if user_value:
+            or user_expiration >= time_now
-        print(('You are currently enrolled in Git submodules experiment '
+        ):
-               '(go/android-submodules-quickstart).  Use --no-use-superproject '
+            # TODO(b/190688390) - Remove prompt when we are comfortable with the
-               'to override.\n'), file=sys.stderr)
+            # new default value.
-      else:
+            if user_value:
-        print(('You are not currently enrolled in Git submodules experiment '
+                print(
-               '(go/android-submodules-quickstart).  Use --use-superproject '
+                    (
-               'to override.\n'), file=sys.stderr)
+                        "You are currently enrolled in Git submodules "
-      return user_value
+                        "experiment (go/android-submodules-quickstart).  Use "
+                        "--no-use-superproject to override.\n"
-  # We don't have an unexpired choice, ask for one.
+                    ),
-  system_cfg = RepoConfig.ForSystem()
+                    file=sys.stderr,
-  system_value = system_cfg.GetBoolean('repo.superprojectChoice')
+                )
-  if system_value:
+            else:
-    # The system configuration is proposing that we should enable the
+                print(
-    # use of superproject. Treat the user as enrolled for two weeks.
+                    (
-    #
+                        "You are not currently enrolled in Git submodules "
-    # TODO(b/190688390) - Remove prompt when we are comfortable with the new
+                        "experiment (go/android-submodules-quickstart).  Use "
-    # default value.
+                        "--use-superproject to override.\n"
-    userchoice = True
+                    ),
-    time_choiceexpire = time_now + (86400 * 14)
+                    file=sys.stderr,
-    user_cfg.SetString('repo.superprojectChoiceExpire', str(time_choiceexpire))
+                )
-    user_cfg.SetBoolean('repo.superprojectChoice', userchoice)
+            return user_value
-    print('You are automatically enrolled in Git submodules experiment '
-          '(go/android-submodules-quickstart) for another two weeks.\n',
+    # We don't have an unexpired choice, ask for one.
-          file=sys.stderr)
+    system_cfg = RepoConfig.ForSystem()
-    return True
+    system_value = system_cfg.GetBoolean("repo.superprojectChoice")
+    if system_value:
-  # For all other cases, we would not use superproject by default.
+        # The system configuration is proposing that we should enable the
-  return False
+        # use of superproject. Treat the user as enrolled for two weeks.
+        #
+        # TODO(b/190688390) - Remove prompt when we are comfortable with the new
+        # default value.
+        userchoice = True
+        time_choiceexpire = time_now + (86400 * 14)
+        user_cfg.SetString(
+            "repo.superprojectChoiceExpire", str(time_choiceexpire)
+        )
+        user_cfg.SetBoolean("repo.superprojectChoice", userchoice)
+        print(
+            "You are automatically enrolled in Git submodules experiment "
+            "(go/android-submodules-quickstart) for another two weeks.\n",
+            file=sys.stderr,
+        )
+        return True
+    # For all other cases, we would not use superproject by default.
+    return False
 def PrintMessages(use_superproject, manifest):
-  """Returns a boolean if error/warning messages are to be printed.
+    """Returns a boolean if error/warning messages are to be printed.
-  Args:
+    Args:
-    use_superproject: option value from optparse.
+        use_superproject: option value from optparse.
-    manifest: manifest to use.
+        manifest: manifest to use.
-  """
+    """
-  return use_superproject is not None or bool(manifest.superproject)
+    return use_superproject is not None or bool(manifest.superproject)
 def UseSuperproject(use_superproject, manifest):
-  """Returns a boolean if use-superproject option is enabled.
+    """Returns a boolean if use-superproject option is enabled.
-  Args:
+    Args:
-    use_superproject: option value from optparse.
+        use_superproject: option value from optparse.
-    manifest: manifest to use.
+        manifest: manifest to use.
-  Returns:
+    Returns:
-    Whether the superproject should be used.
+        Whether the superproject should be used.
-  """
+    """
-  if not manifest.superproject:
+    if not manifest.superproject:
-    # This (sub) manifest does not have a superproject definition.
+        # This (sub) manifest does not have a superproject definition.
-    return False
+        return False
-  elif use_superproject is not None:
+    elif use_superproject is not None:
-    return use_superproject
+        return use_superproject
-  else:
-    client_value = manifest.manifestProject.use_superproject
-    if client_value is not None:
-      return client_value
-    elif manifest.superproject:
-      return _UseSuperprojectFromConfiguration()
    else:
-      return False
+        client_value = manifest.manifestProject.use_superproject
+        if client_value is not None:
+            return client_value
+        elif manifest.superproject:
+            return _UseSuperprojectFromConfiguration()
+        else:
+            return False
diff --git a/git_trace2_event_log.py b/git_trace2_event_log.py
index 2edab0e1..d90e9039 100644
--- a/git_trace2_event_log.py
+++ b/git_trace2_event_log.py
@@ -41,291 +41,330 @@ from git_command import GitCommand, RepoSourceVersion
 class EventLog(object):
-  """Event log that records events that occurred during a repo invocation.
+    """Event log that records events that occurred during a repo invocation.
-  Events are written to the log as a consecutive JSON entries, one per line.
-  Entries follow the git trace2 EVENT format.
-  Each entry contains the following common keys:
-  - event: The event name
-  - sid: session-id - Unique string to allow process instance to be identified.
-  - thread: The thread name.
-  - time: is the UTC time of the event.
-  Valid 'event' names and event specific fields are documented here:
-  https://git-scm.com/docs/api-trace2#_event_format
-  """
-  def __init__(self, env=None):
-    """Initializes the event log."""
-    self._log = []
-    # Try to get session-id (sid) from environment (setup in repo launcher).
-    KEY = 'GIT_TRACE2_PARENT_SID'
-    if env is None:
-      env = os.environ
-    now = datetime.datetime.utcnow()
-    # Save both our sid component and the complete sid.
-    # We use our sid component (self._sid) as the unique filename prefix and
-    # the full sid (self._full_sid) in the log itself.
-    self._sid = 'repo-%s-P%08x' % (now.strftime('%Y%m%dT%H%M%SZ'), os.getpid())
-    parent_sid = env.get(KEY)
-    # Append our sid component to the parent sid (if it exists).
-    if parent_sid is not None:
-      self._full_sid = parent_sid + '/' + self._sid
-    else:
-      self._full_sid = self._sid
-    # Set/update the environment variable.
-    # Environment handling across systems is messy.
-    try:
-      env[KEY] = self._full_sid
-    except UnicodeEncodeError:
-      env[KEY] = self._full_sid.encode()
-    # Add a version event to front of the log.
-    self._AddVersionEvent()
-  @property
-  def full_sid(self):
-    return self._full_sid
-  def _AddVersionEvent(self):
-    """Adds a 'version' event at the beginning of current log."""
-    version_event = self._CreateEventDict('version')
-    version_event['evt'] = "2"
-    version_event['exe'] = RepoSourceVersion()
-    self._log.insert(0, version_event)
-  def _CreateEventDict(self, event_name):
-    """Returns a dictionary with the common keys/values for git trace2 events.
-    Args:
-      event_name: The event name.
-    Returns:
-      Dictionary with the common event fields populated.
-    """
-    return {
-        'event': event_name,
-        'sid': self._full_sid,
-        'thread': threading.current_thread().name,
-        'time': datetime.datetime.utcnow().isoformat() + 'Z',
-    }
-  def StartEvent(self):
-    """Append a 'start' event to the current log."""
-    start_event = self._CreateEventDict('start')
-    start_event['argv'] = sys.argv
-    self._log.append(start_event)
-  def ExitEvent(self, result):
-    """Append an 'exit' event to the current log.
-    Args:
-      result: Exit code of the event
-    """
-    exit_event = self._CreateEventDict('exit')
-    # Consider 'None' success (consistent with event_log result handling).
-    if result is None:
-      result = 0
-    exit_event['code'] = result
-    self._log.append(exit_event)
-  def CommandEvent(self, name, subcommands):
-    """Append a 'command' event to the current log.
-    Args:
-      name: Name of the primary command (ex: repo, git)
-      subcommands: List of the sub-commands (ex: version, init, sync)
-    """
-    command_event = self._CreateEventDict('command')
-    command_event['name'] = name
-    command_event['subcommands'] = subcommands
-    self._log.append(command_event)
-  def LogConfigEvents(self, config, event_dict_name):
+    Events are written to the log as a consecutive JSON entries, one per line.
-    """Append a |event_dict_name| event for each config key in |config|.
+    Entries follow the git trace2 EVENT format.
-    Args:
+    Each entry contains the following common keys:
-      config: Configuration dictionary.
+    - event: The event name
-      event_dict_name: Name of the event dictionary for items to be logged under.
+    - sid: session-id - Unique string to allow process instance to be
-    """
+          identified.
-    for param, value in config.items():
+    - thread: The thread name.
-      event = self._CreateEventDict(event_dict_name)
+    - time: is the UTC time of the event.
-      event['param'] = param
-      event['value'] = value
-      self._log.append(event)
-  def DefParamRepoEvents(self, config):
-    """Append a 'def_param' event for each repo.* config key to the current log.
-    Args:
+    Valid 'event' names and event specific fields are documented here:
-      config: Repo configuration dictionary
+    https://git-scm.com/docs/api-trace2#_event_format
    """
-    # Only output the repo.* config parameters.
-    repo_config = {k: v for k, v in config.items() if k.startswith('repo.')}
-    self.LogConfigEvents(repo_config, 'def_param')
-  def GetDataEventName(self, value):
-    """Returns 'data-json' if the value is an array else returns 'data'."""
-    return 'data-json' if value[0] == '[' and value[-1] == ']' else 'data'
-  def LogDataConfigEvents(self, config, prefix):
+    def __init__(self, env=None):
-    """Append a 'data' event for each config key/value in |config| to the current log.
+        """Initializes the event log."""
+        self._log = []
-    For each keyX and valueX of the config, "key" field of the event is '|prefix|/keyX'
+        # Try to get session-id (sid) from environment (setup in repo launcher).
-    and the "value" of the "key" field is valueX.
+        KEY = "GIT_TRACE2_PARENT_SID"
+        if env is None:
-    Args:
+            env = os.environ
-      config: Configuration dictionary.
-      prefix: Prefix for each key that is logged.
+        now = datetime.datetime.utcnow()
-    """
-    for key, value in config.items():
+        # Save both our sid component and the complete sid.
-      event = self._CreateEventDict(self.GetDataEventName(value))
+        # We use our sid component (self._sid) as the unique filename prefix and
-      event['key'] = f'{prefix}/{key}'
+        # the full sid (self._full_sid) in the log itself.
-      event['value'] = value
+        self._sid = "repo-%s-P%08x" % (
-      self._log.append(event)
+            now.strftime("%Y%m%dT%H%M%SZ"),
+            os.getpid(),
-  def ErrorEvent(self, msg, fmt):
+        )
-    """Append a 'error' event to the current log."""
+        parent_sid = env.get(KEY)
-    error_event = self._CreateEventDict('error')
+        # Append our sid component to the parent sid (if it exists).
-    error_event['msg'] = msg
+        if parent_sid is not None:
-    error_event['fmt'] = fmt
+            self._full_sid = parent_sid + "/" + self._sid
-    self._log.append(error_event)
+        else:
+            self._full_sid = self._sid
-  def _GetEventTargetPath(self):
-    """Get the 'trace2.eventtarget' path from git configuration.
+        # Set/update the environment variable.
+        # Environment handling across systems is messy.
-    Returns:
+        try:
-      path: git config's 'trace2.eventtarget' path if it exists, or None
+            env[KEY] = self._full_sid
-    """
+        except UnicodeEncodeError:
-    path = None
+            env[KEY] = self._full_sid.encode()
-    cmd = ['config', '--get', 'trace2.eventtarget']
-    # TODO(https://crbug.com/gerrit/13706): Use GitConfig when it supports
+        # Add a version event to front of the log.
-    # system git config variables.
+        self._AddVersionEvent()
-    p = GitCommand(None, cmd, capture_stdout=True, capture_stderr=True,
-                   bare=True)
+    @property
-    retval = p.Wait()
+    def full_sid(self):
-    if retval == 0:
+        return self._full_sid
-      # Strip trailing carriage-return in path.
-      path = p.stdout.rstrip('\n')
+    def _AddVersionEvent(self):
-    elif retval != 1:
+        """Adds a 'version' event at the beginning of current log."""
-      # `git config --get` is documented to produce an exit status of `1` if
+        version_event = self._CreateEventDict("version")
-      # the requested variable is not present in the configuration. Report any
+        version_event["evt"] = "2"
-      # other return value as an error.
+        version_event["exe"] = RepoSourceVersion()
-      print("repo: error: 'git config --get' call failed with return code: %r, stderr: %r" % (
+        self._log.insert(0, version_event)
-          retval, p.stderr), file=sys.stderr)
-    return path
+    def _CreateEventDict(self, event_name):
+        """Returns a dictionary with common keys/values for git trace2 events.
-  def _WriteLog(self, write_fn):
-    """Writes the log out using a provided writer function.
+        Args:
+            event_name: The event name.
-    Generate compact JSON output for each item in the log, and write it using
-    write_fn.
+        Returns:
+            Dictionary with the common event fields populated.
-    Args:
+        """
-      write_fn: A function that accepts byts and writes them to a destination.
+        return {
-    """
+            "event": event_name,
+            "sid": self._full_sid,
-    for e in self._log:
+            "thread": threading.current_thread().name,
-      # Dump in compact encoding mode.
+            "time": datetime.datetime.utcnow().isoformat() + "Z",
-      # See 'Compact encoding' in Python docs:
+        }
-      # https://docs.python.org/3/library/json.html#module-json
-      write_fn(json.dumps(e, indent=None, separators=(',', ':')).encode('utf-8') + b'\n')
+    def StartEvent(self):
+        """Append a 'start' event to the current log."""
-  def Write(self, path=None):
+        start_event = self._CreateEventDict("start")
-    """Writes the log out to a file or socket.
+        start_event["argv"] = sys.argv
+        self._log.append(start_event)
-    Log is only written if 'path' or 'git config --get trace2.eventtarget'
-    provide a valid path (or socket) to write logs to.
+    def ExitEvent(self, result):
+        """Append an 'exit' event to the current log.
+        Args:
+            result: Exit code of the event
+        """
+        exit_event = self._CreateEventDict("exit")
+        # Consider 'None' success (consistent with event_log result handling).
+        if result is None:
+            result = 0
+        exit_event["code"] = result
+        self._log.append(exit_event)
+    def CommandEvent(self, name, subcommands):
+        """Append a 'command' event to the current log.
+        Args:
+            name: Name of the primary command (ex: repo, git)
+            subcommands: List of the sub-commands (ex: version, init, sync)
+        """
+        command_event = self._CreateEventDict("command")
+        command_event["name"] = name
+        command_event["subcommands"] = subcommands
+        self._log.append(command_event)
+    def LogConfigEvents(self, config, event_dict_name):
+        """Append a |event_dict_name| event for each config key in |config|.
+        Args:
+            config: Configuration dictionary.
+            event_dict_name: Name of the event dictionary for items to be logged
+                under.
+        """
+        for param, value in config.items():
+            event = self._CreateEventDict(event_dict_name)
+            event["param"] = param
+            event["value"] = value
+            self._log.append(event)
+    def DefParamRepoEvents(self, config):
+        """Append 'def_param' events for repo config keys to the current log.
+        This appends one event for each repo.* config key.
+        Args:
+            config: Repo configuration dictionary
+        """
+        # Only output the repo.* config parameters.
+        repo_config = {k: v for k, v in config.items() if k.startswith("repo.")}
+        self.LogConfigEvents(repo_config, "def_param")
+    def GetDataEventName(self, value):
+        """Returns 'data-json' if the value is an array else returns 'data'."""
+        return "data-json" if value[0] == "[" and value[-1] == "]" else "data"
+    def LogDataConfigEvents(self, config, prefix):
+        """Append a 'data' event for each entry in |config| to the current log.
+        For each keyX and valueX of the config, "key" field of the event is
+        '|prefix|/keyX' and the "value" of the "key" field is valueX.
+        Args:
+            config: Configuration dictionary.
+            prefix: Prefix for each key that is logged.
+        """
+        for key, value in config.items():
+            event = self._CreateEventDict(self.GetDataEventName(value))
+            event["key"] = f"{prefix}/{key}"
+            event["value"] = value
+            self._log.append(event)
+    def ErrorEvent(self, msg, fmt):
+        """Append a 'error' event to the current log."""
+        error_event = self._CreateEventDict("error")
+        error_event["msg"] = msg
+        error_event["fmt"] = fmt
+        self._log.append(error_event)
+    def _GetEventTargetPath(self):
+        """Get the 'trace2.eventtarget' path from git configuration.
+        Returns:
+            path: git config's 'trace2.eventtarget' path if it exists, or None
+        """
+        path = None
+        cmd = ["config", "--get", "trace2.eventtarget"]
+        # TODO(https://crbug.com/gerrit/13706): Use GitConfig when it supports
+        # system git config variables.
+        p = GitCommand(
+            None, cmd, capture_stdout=True, capture_stderr=True, bare=True
+        )
+        retval = p.Wait()
+        if retval == 0:
+            # Strip trailing carriage-return in path.
+            path = p.stdout.rstrip("\n")
+        elif retval != 1:
+            # `git config --get` is documented to produce an exit status of `1`
+            # if the requested variable is not present in the configuration.
+            # Report any other return value as an error.
+            print(
+                "repo: error: 'git config --get' call failed with return code: "
+                "%r, stderr: %r" % (retval, p.stderr),
+                file=sys.stderr,
+            )
+        return path
+    def _WriteLog(self, write_fn):
+        """Writes the log out using a provided writer function.
+        Generate compact JSON output for each item in the log, and write it
+        using write_fn.
+        Args:
+            write_fn: A function that accepts byts and writes them to a
+                destination.
+        """
+        for e in self._log:
+            # Dump in compact encoding mode.
+            # See 'Compact encoding' in Python docs:
+            # https://docs.python.org/3/library/json.html#module-json
+            write_fn(
+                json.dumps(e, indent=None, separators=(",", ":")).encode(
+                    "utf-8"
+                )
+                + b"\n"
+            )
+    def Write(self, path=None):
+        """Writes the log out to a file or socket.
+        Log is only written if 'path' or 'git config --get trace2.eventtarget'
+        provide a valid path (or socket) to write logs to.
+        Logging filename format follows the git trace2 style of being a unique
+        (exclusive writable) file.
+        Args:
+            path: Path to where logs should be written. The path may have a
+                prefix of the form "af_unix:[{stream|dgram}:]", in which case
+                the path is treated as a Unix domain socket. See
+                https://git-scm.com/docs/api-trace2#_enabling_a_target for
+                details.
+        Returns:
+            log_path: Path to the log file or socket if log is written,
+                otherwise None
+        """
+        log_path = None
+        # If no logging path is specified, get the path from
+        # 'trace2.eventtarget'.
+        if path is None:
+            path = self._GetEventTargetPath()
+        # If no logging path is specified, exit.
+        if path is None:
+            return None
-    Logging filename format follows the git trace2 style of being a unique
+        path_is_socket = False
-    (exclusive writable) file.
+        socket_type = None
+        if isinstance(path, str):
+            parts = path.split(":", 1)
+            if parts[0] == "af_unix" and len(parts) == 2:
+                path_is_socket = True
+                path = parts[1]
+                parts = path.split(":", 1)
+                if parts[0] == "stream" and len(parts) == 2:
+                    socket_type = socket.SOCK_STREAM
+                    path = parts[1]
+                elif parts[0] == "dgram" and len(parts) == 2:
+                    socket_type = socket.SOCK_DGRAM
+                    path = parts[1]
+            else:
+                # Get absolute path.
+                path = os.path.abspath(os.path.expanduser(path))
+        else:
+            raise TypeError("path: str required but got %s." % type(path))
+        # Git trace2 requires a directory to write log to.
+        # TODO(https://crbug.com/gerrit/13706): Support file (append) mode also.
+        if not (path_is_socket or os.path.isdir(path)):
+            return None
-    Args:
+        if path_is_socket:
-      path: Path to where logs should be written. The path may have a prefix of
+            if socket_type == socket.SOCK_STREAM or socket_type is None:
-          the form "af_unix:[{stream|dgram}:]", in which case the path is
+                try:
-          treated as a Unix domain socket. See
+                    with socket.socket(
-          https://git-scm.com/docs/api-trace2#_enabling_a_target for details.
+                        socket.AF_UNIX, socket.SOCK_STREAM
+                    ) as sock:
+                        sock.connect(path)
+                        self._WriteLog(sock.sendall)
+                    return f"af_unix:stream:{path}"
+                except OSError as err:
+                    # If we tried to connect to a DGRAM socket using STREAM,
+                    # ignore the attempt and continue to DGRAM below. Otherwise,
+                    # issue a warning.
+                    if err.errno != errno.EPROTOTYPE:
+                        print(
+                            f"repo: warning: git trace2 logging failed: {err}",
+                            file=sys.stderr,
+                        )
+                        return None
+            if socket_type == socket.SOCK_DGRAM or socket_type is None:
+                try:
+                    with socket.socket(
+                        socket.AF_UNIX, socket.SOCK_DGRAM
+                    ) as sock:
+                        self._WriteLog(lambda bs: sock.sendto(bs, path))
+                        return f"af_unix:dgram:{path}"
+                except OSError as err:
+                    print(
+                        f"repo: warning: git trace2 logging failed: {err}",
+                        file=sys.stderr,
+                    )
+                    return None
+            # Tried to open a socket but couldn't connect (SOCK_STREAM) or write
+            # (SOCK_DGRAM).
+            print(
+                "repo: warning: git trace2 logging failed: could not write to "
+                "socket",
+                file=sys.stderr,
+            )
+            return None
-    Returns:
+        # Path is an absolute path
-      log_path: Path to the log file or socket if log is written, otherwise None
+        # Use NamedTemporaryFile to generate a unique filename as required by
-    """
+        # git trace2.
-    log_path = None
-    # If no logging path is specified, get the path from 'trace2.eventtarget'.
-    if path is None:
-      path = self._GetEventTargetPath()
-    # If no logging path is specified, exit.
-    if path is None:
-      return None
-    path_is_socket = False
-    socket_type = None
-    if isinstance(path, str):
-      parts = path.split(':', 1)
-      if parts[0] == 'af_unix' and len(parts) == 2:
-        path_is_socket = True
-        path = parts[1]
-        parts = path.split(':', 1)
-        if parts[0] == 'stream' and len(parts) == 2:
-          socket_type = socket.SOCK_STREAM
-          path = parts[1]
-        elif parts[0] == 'dgram' and len(parts) == 2:
-          socket_type = socket.SOCK_DGRAM
-          path = parts[1]
-      else:
-        # Get absolute path.
-        path = os.path.abspath(os.path.expanduser(path))
-    else:
-      raise TypeError('path: str required but got %s.' % type(path))
-    # Git trace2 requires a directory to write log to.
-    # TODO(https://crbug.com/gerrit/13706): Support file (append) mode also.
-    if not (path_is_socket or os.path.isdir(path)):
-      return None
-    if path_is_socket:
-      if socket_type == socket.SOCK_STREAM or socket_type is None:
        try:
-          with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as sock:
+            with tempfile.NamedTemporaryFile(
-            sock.connect(path)
+                mode="xb", prefix=self._sid, dir=path, delete=False
-            self._WriteLog(sock.sendall)
+            ) as f:
-          return f'af_unix:stream:{path}'
+                # TODO(https://crbug.com/gerrit/13706): Support writing events
-        except OSError as err:
+                # as they occur.
-          # If we tried to connect to a DGRAM socket using STREAM, ignore the
+                self._WriteLog(f.write)
-          # attempt and continue to DGRAM below. Otherwise, issue a warning.
+                log_path = f.name
-          if err.errno != errno.EPROTOTYPE:
+        except FileExistsError as err:
-            print(f'repo: warning: git trace2 logging failed: {err}', file=sys.stderr)
+            print(
+                "repo: warning: git trace2 logging failed: %r" % err,
+                file=sys.stderr,
+            )
            return None
-      if socket_type == socket.SOCK_DGRAM or socket_type is None:
+        return log_path
-        try:
-          with socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM) as sock:
-            self._WriteLog(lambda bs: sock.sendto(bs, path))
-            return f'af_unix:dgram:{path}'
-        except OSError as err:
-          print(f'repo: warning: git trace2 logging failed: {err}', file=sys.stderr)
-          return None
-      # Tried to open a socket but couldn't connect (SOCK_STREAM) or write
-      # (SOCK_DGRAM).
-      print('repo: warning: git trace2 logging failed: could not write to socket', file=sys.stderr)
-      return None
-    # Path is an absolute path
-    # Use NamedTemporaryFile to generate a unique filename as required by git trace2.
-    try:
-      with tempfile.NamedTemporaryFile(mode='xb', prefix=self._sid, dir=path,
-                                       delete=False) as f:
-        # TODO(https://crbug.com/gerrit/13706): Support writing events as they
-        # occur.
-        self._WriteLog(f.write)
-        log_path = f.name
-    except FileExistsError as err:
-      print('repo: warning: git trace2 logging failed: %r' % err,
-            file=sys.stderr)
-      return None
-    return log_path
diff --git a/gitc_utils.py b/gitc_utils.py
index dfcfd2a4..7b72048f 100644
--- a/gitc_utils.py
+++ b/gitc_utils.py
@@ -28,128 +28,139 @@ NUM_BATCH_RETRIEVE_REVISIONID = 32
 def get_gitc_manifest_dir():
-  return wrapper.Wrapper().get_gitc_manifest_dir()
+    return wrapper.Wrapper().get_gitc_manifest_dir()
 def parse_clientdir(gitc_fs_path):
-  return wrapper.Wrapper().gitc_parse_clientdir(gitc_fs_path)
+    return wrapper.Wrapper().gitc_parse_clientdir(gitc_fs_path)
 def _get_project_revision(args):
-  """Worker for _set_project_revisions to lookup one project remote."""
+    """Worker for _set_project_revisions to lookup one project remote."""
-  (i, url, expr) = args
+    (i, url, expr) = args
-  gitcmd = git_command.GitCommand(
+    gitcmd = git_command.GitCommand(
-      None, ['ls-remote', url, expr], capture_stdout=True, cwd='/tmp')
+        None, ["ls-remote", url, expr], capture_stdout=True, cwd="/tmp"
-  rc = gitcmd.Wait()
+    )
-  return (i, rc, gitcmd.stdout.split('\t', 1)[0])
+    rc = gitcmd.Wait()
+    return (i, rc, gitcmd.stdout.split("\t", 1)[0])
 def _set_project_revisions(projects):
-  """Sets the revisionExpr for a list of projects.
+    """Sets the revisionExpr for a list of projects.
-  Because of the limit of open file descriptors allowed, length of projects
+    Because of the limit of open file descriptors allowed, length of projects
-  should not be overly large. Recommend calling this function multiple times
+    should not be overly large. Recommend calling this function multiple times
-  with each call not exceeding NUM_BATCH_RETRIEVE_REVISIONID projects.
+    with each call not exceeding NUM_BATCH_RETRIEVE_REVISIONID projects.
-  Args:
+    Args:
-    projects: List of project objects to set the revionExpr for.
+        projects: List of project objects to set the revionExpr for.
-  """
+    """
-  # Retrieve the commit id for each project based off of it's current
+    # Retrieve the commit id for each project based off of its current
-  # revisionExpr and it is not already a commit id.
+    # revisionExpr and it is not already a commit id.
-  with multiprocessing.Pool(NUM_BATCH_RETRIEVE_REVISIONID) as pool:
+    with multiprocessing.Pool(NUM_BATCH_RETRIEVE_REVISIONID) as pool:
-    results_iter = pool.imap_unordered(
+        results_iter = pool.imap_unordered(
-        _get_project_revision,
+            _get_project_revision,
-        ((i, project.remote.url, project.revisionExpr)
+            (
-         for i, project in enumerate(projects)
+                (i, project.remote.url, project.revisionExpr)
-         if not git_config.IsId(project.revisionExpr)),
+                for i, project in enumerate(projects)
-        chunksize=8)
+                if not git_config.IsId(project.revisionExpr)
-    for (i, rc, revisionExpr) in results_iter:
+            ),
-      project = projects[i]
+            chunksize=8,
-      if rc:
+        )
-        print('FATAL: Failed to retrieve revisionExpr for %s' % project.name)
+        for i, rc, revisionExpr in results_iter:
-        pool.terminate()
+            project = projects[i]
-        sys.exit(1)
+            if rc:
-      if not revisionExpr:
+                print(
-        pool.terminate()
+                    "FATAL: Failed to retrieve revisionExpr for %s"
-        raise ManifestParseError('Invalid SHA-1 revision project %s (%s)' %
+                    % project.name
-                                 (project.remote.url, project.revisionExpr))
+                )
-      project.revisionExpr = revisionExpr
+                pool.terminate()
+                sys.exit(1)
+            if not revisionExpr:
+                pool.terminate()
+                raise ManifestParseError(
+                    "Invalid SHA-1 revision project %s (%s)"
+                    % (project.remote.url, project.revisionExpr)
+                )
+            project.revisionExpr = revisionExpr
 def generate_gitc_manifest(gitc_manifest, manifest, paths=None):
-  """Generate a manifest for shafsd to use for this GITC client.
+    """Generate a manifest for shafsd to use for this GITC client.
-  Args:
+    Args:
-    gitc_manifest: Current gitc manifest, or None if there isn't one yet.
+        gitc_manifest: Current gitc manifest, or None if there isn't one yet.
-    manifest: A GitcManifest object loaded with the current repo manifest.
+        manifest: A GitcManifest object loaded with the current repo manifest.
-    paths: List of project paths we want to update.
+        paths: List of project paths we want to update.
-  """
+    """
-  print('Generating GITC Manifest by fetching revision SHAs for each '
+    print(
-        'project.')
+        "Generating GITC Manifest by fetching revision SHAs for each "
-  if paths is None:
+        "project."
-    paths = list(manifest.paths.keys())
+    )
+    if paths is None:
-  groups = [x for x in re.split(r'[,\s]+', manifest.GetGroupsStr()) if x]
+        paths = list(manifest.paths.keys())
-  # Convert the paths to projects, and filter them to the matched groups.
+    groups = [x for x in re.split(r"[,\s]+", manifest.GetGroupsStr()) if x]
-  projects = [manifest.paths[p] for p in paths]
-  projects = [p for p in projects if p.MatchesGroups(groups)]
+    # Convert the paths to projects, and filter them to the matched groups.
+    projects = [manifest.paths[p] for p in paths]
-  if gitc_manifest is not None:
+    projects = [p for p in projects if p.MatchesGroups(groups)]
-    for path, proj in manifest.paths.items():
-      if not proj.MatchesGroups(groups):
+    if gitc_manifest is not None:
-        continue
+        for path, proj in manifest.paths.items():
+            if not proj.MatchesGroups(groups):
-      if not proj.upstream and not git_config.IsId(proj.revisionExpr):
+                continue
-        proj.upstream = proj.revisionExpr
+            if not proj.upstream and not git_config.IsId(proj.revisionExpr):
-      if path not in gitc_manifest.paths:
+                proj.upstream = proj.revisionExpr
-        # Any new projects need their first revision, even if we weren't asked
-        # for them.
+            if path not in gitc_manifest.paths:
-        projects.append(proj)
+                # Any new projects need their first revision, even if we weren't
-      elif path not in paths:
+                # asked for them.
-        # And copy revisions from the previous manifest if we're not updating
+                projects.append(proj)
-        # them now.
+            elif path not in paths:
-        gitc_proj = gitc_manifest.paths[path]
+                # And copy revisions from the previous manifest if we're not
-        if gitc_proj.old_revision:
+                # updating them now.
-          proj.revisionExpr = None
+                gitc_proj = gitc_manifest.paths[path]
-          proj.old_revision = gitc_proj.old_revision
+                if gitc_proj.old_revision:
-        else:
+                    proj.revisionExpr = None
-          proj.revisionExpr = gitc_proj.revisionExpr
+                    proj.old_revision = gitc_proj.old_revision
+                else:
-  _set_project_revisions(projects)
+                    proj.revisionExpr = gitc_proj.revisionExpr
-  if gitc_manifest is not None:
+    _set_project_revisions(projects)
-    for path, proj in gitc_manifest.paths.items():
-      if proj.old_revision and path in paths:
+    if gitc_manifest is not None:
-        # If we updated a project that has been started, keep the old-revision
+        for path, proj in gitc_manifest.paths.items():
-        # updated.
+            if proj.old_revision and path in paths:
-        repo_proj = manifest.paths[path]
+                # If we updated a project that has been started, keep the
-        repo_proj.old_revision = repo_proj.revisionExpr
+                # old-revision updated.
-        repo_proj.revisionExpr = None
+                repo_proj = manifest.paths[path]
+                repo_proj.old_revision = repo_proj.revisionExpr
-  # Convert URLs from relative to absolute.
+                repo_proj.revisionExpr = None
-  for _name, remote in manifest.remotes.items():
-    remote.fetchUrl = remote.resolvedFetchUrl
+    # Convert URLs from relative to absolute.
+    for _name, remote in manifest.remotes.items():
-  # Save the manifest.
+        remote.fetchUrl = remote.resolvedFetchUrl
-  save_manifest(manifest)
+    # Save the manifest.
+    save_manifest(manifest)
 def save_manifest(manifest, client_dir=None):
-  """Save the manifest file in the client_dir.
+    """Save the manifest file in the client_dir.
-  Args:
+    Args:
-    manifest: Manifest object to save.
+        manifest: Manifest object to save.
-    client_dir: Client directory to save the manifest in.
+        client_dir: Client directory to save the manifest in.
-  """
+    """
-  if not client_dir:
+    if not client_dir:
-    manifest_file = manifest.manifestFile
+        manifest_file = manifest.manifestFile
-  else:
+    else:
-    manifest_file = os.path.join(client_dir, '.manifest')
+        manifest_file = os.path.join(client_dir, ".manifest")
-  with open(manifest_file, 'w') as f:
+    with open(manifest_file, "w") as f:
-    manifest.Save(f, groups=manifest.GetGroupsStr())
+        manifest.Save(f, groups=manifest.GetGroupsStr())
-  # TODO(sbasi/jorg): Come up with a solution to remove the sleep below.
+    # TODO(sbasi/jorg): Come up with a solution to remove the sleep below.
-  # Give the GITC filesystem time to register the manifest changes.
+    # Give the GITC filesystem time to register the manifest changes.
-  time.sleep(3)
+    time.sleep(3)
diff --git a/hooks.py b/hooks.py
index 67c21a25..decf0699 100644
--- a/hooks.py
+++ b/hooks.py
@@ -26,271 +26,293 @@ from git_refs import HEAD
 class RepoHook(object):
-  """A RepoHook contains information about a script to run as a hook.
+    """A RepoHook contains information about a script to run as a hook.
-  Hooks are used to run a python script before running an upload (for instance,
+    Hooks are used to run a python script before running an upload (for
-  to run presubmit checks).  Eventually, we may have hooks for other actions.
+    instance, to run presubmit checks).  Eventually, we may have hooks for other
+    actions.
-  This shouldn't be confused with files in the 'repo/hooks' directory.  Those
-  files are copied into each '.git/hooks' folder for each project.  Repo-level
+    This shouldn't be confused with files in the 'repo/hooks' directory.  Those
-  hooks are associated instead with repo actions.
+    files are copied into each '.git/hooks' folder for each project.  Repo-level
+    hooks are associated instead with repo actions.
-  Hooks are always python.  When a hook is run, we will load the hook into the
-  interpreter and execute its main() function.
+    Hooks are always python.  When a hook is run, we will load the hook into the
+    interpreter and execute its main() function.
-  Combinations of hook option flags:
-  - no-verify=False, verify=False (DEFAULT):
+    Combinations of hook option flags:
-    If stdout is a tty, can prompt about running hooks if needed.
+    - no-verify=False, verify=False (DEFAULT):
-    If user denies running hooks, the action is cancelled. If stdout is
+      If stdout is a tty, can prompt about running hooks if needed.
-    not a tty and we would need to prompt about hooks, action is
+      If user denies running hooks, the action is cancelled. If stdout is
-    cancelled.
+      not a tty and we would need to prompt about hooks, action is
-  - no-verify=False, verify=True:
+      cancelled.
-    Always run hooks with no prompt.
+    - no-verify=False, verify=True:
-  - no-verify=True, verify=False:
+      Always run hooks with no prompt.
-    Never run hooks, but run action anyway (AKA bypass hooks).
+    - no-verify=True, verify=False:
-  - no-verify=True, verify=True:
+      Never run hooks, but run action anyway (AKA bypass hooks).
-    Invalid
+    - no-verify=True, verify=True:
-  """
+      Invalid
-  def __init__(self,
-               hook_type,
-               hooks_project,
-               repo_topdir,
-               manifest_url,
-               bypass_hooks=False,
-               allow_all_hooks=False,
-               ignore_hooks=False,
-               abort_if_user_denies=False):
-    """RepoHook constructor.
-    Params:
-      hook_type: A string representing the type of hook.  This is also used
-          to figure out the name of the file containing the hook.  For
-          example: 'pre-upload'.
-      hooks_project: The project containing the repo hooks.
-          If you have a manifest, this is manifest.repo_hooks_project.
-          OK if this is None, which will make the hook a no-op.
-      repo_topdir: The top directory of the repo client checkout.
-          This is the one containing the .repo directory. Scripts will
-          run with CWD as this directory.
-          If you have a manifest, this is manifest.topdir.
-      manifest_url: The URL to the manifest git repo.
-      bypass_hooks: If True, then 'Do not run the hook'.
-      allow_all_hooks: If True, then 'Run the hook without prompting'.
-      ignore_hooks: If True, then 'Do not abort action if hooks fail'.
-      abort_if_user_denies: If True, we'll abort running the hook if the user
-          doesn't allow us to run the hook.
    """
-    self._hook_type = hook_type
-    self._hooks_project = hooks_project
-    self._repo_topdir = repo_topdir
-    self._manifest_url = manifest_url
-    self._bypass_hooks = bypass_hooks
-    self._allow_all_hooks = allow_all_hooks
-    self._ignore_hooks = ignore_hooks
-    self._abort_if_user_denies = abort_if_user_denies
-    # Store the full path to the script for convenience.
-    if self._hooks_project:
-      self._script_fullpath = os.path.join(self._hooks_project.worktree,
-                                           self._hook_type + '.py')
-    else:
-      self._script_fullpath = None
-  def _GetHash(self):
-    """Return a hash of the contents of the hooks directory.
-    We'll just use git to do this.  This hash has the property that if anything
-    changes in the directory we will return a different has.
-    SECURITY CONSIDERATION:
-      This hash only represents the contents of files in the hook directory, not
-      any other files imported or called by hooks.  Changes to imported files
-      can change the script behavior without affecting the hash.
-    Returns:
-      A string representing the hash.  This will always be ASCII so that it can
-      be printed to the user easily.
-    """
-    assert self._hooks_project, "Must have hooks to calculate their hash."
-    # We will use the work_git object rather than just calling GetRevisionId().
-    # That gives us a hash of the latest checked in version of the files that
-    # the user will actually be executing.  Specifically, GetRevisionId()
-    # doesn't appear to change even if a user checks out a different version
-    # of the hooks repo (via git checkout) nor if a user commits their own revs.
-    #
-    # NOTE: Local (non-committed) changes will not be factored into this hash.
-    # I think this is OK, since we're really only worried about warning the user
-    # about upstream changes.
-    return self._hooks_project.work_git.rev_parse(HEAD)
-  def _GetMustVerb(self):
-    """Return 'must' if the hook is required; 'should' if not."""
-    if self._abort_if_user_denies:
-      return 'must'
-    else:
-      return 'should'
-  def _CheckForHookApproval(self):
-    """Check to see whether this hook has been approved.
-    We'll accept approval of manifest URLs if they're using secure transports.
-    This way the user can say they trust the manifest hoster.  For insecure
-    hosts, we fall back to checking the hash of the hooks repo.
-    Note that we ask permission for each individual hook even though we use
-    the hash of all hooks when detecting changes.  We'd like the user to be
-    able to approve / deny each hook individually.  We only use the hash of all
-    hooks because there is no other easy way to detect changes to local imports.
-    Returns:
-      True if this hook is approved to run; False otherwise.
-    Raises:
-      HookError: Raised if the user doesn't approve and abort_if_user_denies
-          was passed to the consturctor.
-    """
-    if self._ManifestUrlHasSecureScheme():
-      return self._CheckForHookApprovalManifest()
-    else:
-      return self._CheckForHookApprovalHash()
-  def _CheckForHookApprovalHelper(self, subkey, new_val, main_prompt,
-                                  changed_prompt):
-    """Check for approval for a particular attribute and hook.
-    Args:
-      subkey: The git config key under [repo.hooks.<hook_type>] to store the
-          last approved string.
-      new_val: The new value to compare against the last approved one.
-      main_prompt: Message to display to the user to ask for approval.
-      changed_prompt: Message explaining why we're re-asking for approval.
-    Returns:
-      True if this hook is approved to run; False otherwise.
-    Raises:
-      HookError: Raised if the user doesn't approve and abort_if_user_denies
-          was passed to the consturctor.
-    """
-    hooks_config = self._hooks_project.config
-    git_approval_key = 'repo.hooks.%s.%s' % (self._hook_type, subkey)
-    # Get the last value that the user approved for this hook; may be None.
-    old_val = hooks_config.GetString(git_approval_key)
-    if old_val is not None:
-      # User previously approved hook and asked not to be prompted again.
-      if new_val == old_val:
-        # Approval matched.  We're done.
-        return True
-      else:
-        # Give the user a reason why we're prompting, since they last told
-        # us to "never ask again".
-        prompt = 'WARNING: %s\n\n' % (changed_prompt,)
-    else:
-      prompt = ''
-    # Prompt the user if we're not on a tty; on a tty we'll assume "no".
-    if sys.stdout.isatty():
-      prompt += main_prompt + ' (yes/always/NO)? '
-      response = input(prompt).lower()
-      print()
-      # User is doing a one-time approval.
-      if response in ('y', 'yes'):
-        return True
-      elif response == 'always':
-        hooks_config.SetString(git_approval_key, new_val)
-        return True
-    # For anything else, we'll assume no approval.
-    if self._abort_if_user_denies:
-      raise HookError('You must allow the %s hook or use --no-verify.' %
-                      self._hook_type)
-    return False
-  def _ManifestUrlHasSecureScheme(self):
-    """Check if the URI for the manifest is a secure transport."""
-    secure_schemes = ('file', 'https', 'ssh', 'persistent-https', 'sso', 'rpc')
-    parse_results = urllib.parse.urlparse(self._manifest_url)
-    return parse_results.scheme in secure_schemes
-  def _CheckForHookApprovalManifest(self):
-    """Check whether the user has approved this manifest host.
-    Returns:
-      True if this hook is approved to run; False otherwise.
-    """
-    return self._CheckForHookApprovalHelper(
-        'approvedmanifest',
-        self._manifest_url,
-        'Run hook scripts from %s' % (self._manifest_url,),
-        'Manifest URL has changed since %s was allowed.' % (self._hook_type,))
-  def _CheckForHookApprovalHash(self):
-    """Check whether the user has approved the hooks repo.
-    Returns:
-      True if this hook is approved to run; False otherwise.
-    """
-    prompt = ('Repo %s run the script:\n'
-              '  %s\n'
-              '\n'
-              'Do you want to allow this script to run')
-    return self._CheckForHookApprovalHelper(
-        'approvedhash',
-        self._GetHash(),
-        prompt % (self._GetMustVerb(), self._script_fullpath),
-        'Scripts have changed since %s was allowed.' % (self._hook_type,))
-  @staticmethod
-  def _ExtractInterpFromShebang(data):
-    """Extract the interpreter used in the shebang.
-    Try to locate the interpreter the script is using (ignoring `env`).
-    Args:
-      data: The file content of the script.
-    Returns:
-      The basename of the main script interpreter, or None if a shebang is not
-      used or could not be parsed out.
-    """
-    firstline = data.splitlines()[:1]
-    if not firstline:
-      return None
-    # The format here can be tricky.
-    shebang = firstline[0].strip()
-    m = re.match(r'^#!\s*([^\s]+)(?:\s+([^\s]+))?', shebang)
-    if not m:
-      return None
-    # If the using `env`, find the target program.
-    interp = m.group(1)
-    if os.path.basename(interp) == 'env':
-      interp = m.group(2)
-    return interp
-  def _ExecuteHookViaReexec(self, interp, context, **kwargs):
-    """Execute the hook script through |interp|.
-    Note: Support for this feature should be dropped ~Jun 2021.
+    def __init__(
+        self,
-    Args:
+        hook_type,
-      interp: The Python program to run.
+        hooks_project,
-      context: Basic Python context to execute the hook inside.
+        repo_topdir,
-      kwargs: Arbitrary arguments to pass to the hook script.
+        manifest_url,
+        bypass_hooks=False,
-    Raises:
+        allow_all_hooks=False,
-      HookError: When the hooks failed for any reason.
+        ignore_hooks=False,
-    """
+        abort_if_user_denies=False,
-    # This logic needs to be kept in sync with _ExecuteHookViaImport below.
+    ):
-    script = """
+        """RepoHook constructor.
+        Params:
+            hook_type: A string representing the type of hook. This is also used
+                to figure out the name of the file containing the hook. For
+                example: 'pre-upload'.
+            hooks_project: The project containing the repo hooks.
+                If you have a manifest, this is manifest.repo_hooks_project.
+                OK if this is None, which will make the hook a no-op.
+            repo_topdir: The top directory of the repo client checkout.
+                This is the one containing the .repo directory. Scripts will
+                run with CWD as this directory.
+                If you have a manifest, this is manifest.topdir.
+            manifest_url: The URL to the manifest git repo.
+            bypass_hooks: If True, then 'Do not run the hook'.
+            allow_all_hooks: If True, then 'Run the hook without prompting'.
+            ignore_hooks: If True, then 'Do not abort action if hooks fail'.
+            abort_if_user_denies: If True, we'll abort running the hook if the
+                user doesn't allow us to run the hook.
+        """
+        self._hook_type = hook_type
+        self._hooks_project = hooks_project
+        self._repo_topdir = repo_topdir
+        self._manifest_url = manifest_url
+        self._bypass_hooks = bypass_hooks
+        self._allow_all_hooks = allow_all_hooks
+        self._ignore_hooks = ignore_hooks
+        self._abort_if_user_denies = abort_if_user_denies
+        # Store the full path to the script for convenience.
+        if self._hooks_project:
+            self._script_fullpath = os.path.join(
+                self._hooks_project.worktree, self._hook_type + ".py"
+            )
+        else:
+            self._script_fullpath = None
+    def _GetHash(self):
+        """Return a hash of the contents of the hooks directory.
+        We'll just use git to do this.  This hash has the property that if
+        anything changes in the directory we will return a different has.
+        SECURITY CONSIDERATION:
+            This hash only represents the contents of files in the hook
+            directory, not any other files imported or called by hooks.  Changes
+            to imported files can change the script behavior without affecting
+            the hash.
+        Returns:
+            A string representing the hash.  This will always be ASCII so that
+            it can be printed to the user easily.
+        """
+        assert self._hooks_project, "Must have hooks to calculate their hash."
+        # We will use the work_git object rather than just calling
+        # GetRevisionId(). That gives us a hash of the latest checked in version
+        # of the files that the user will actually be executing.  Specifically,
+        # GetRevisionId() doesn't appear to change even if a user checks out a
+        # different version of the hooks repo (via git checkout) nor if a user
+        # commits their own revs.
+        #
+        # NOTE: Local (non-committed) changes will not be factored into this
+        # hash. I think this is OK, since we're really only worried about
+        # warning the user about upstream changes.
+        return self._hooks_project.work_git.rev_parse(HEAD)
+    def _GetMustVerb(self):
+        """Return 'must' if the hook is required; 'should' if not."""
+        if self._abort_if_user_denies:
+            return "must"
+        else:
+            return "should"
+    def _CheckForHookApproval(self):
+        """Check to see whether this hook has been approved.
+        We'll accept approval of manifest URLs if they're using secure
+        transports. This way the user can say they trust the manifest hoster.
+        For insecure hosts, we fall back to checking the hash of the hooks repo.
+        Note that we ask permission for each individual hook even though we use
+        the hash of all hooks when detecting changes.  We'd like the user to be
+        able to approve / deny each hook individually.  We only use the hash of
+        all hooks because there is no other easy way to detect changes to local
+        imports.
+        Returns:
+            True if this hook is approved to run; False otherwise.
+        Raises:
+            HookError: Raised if the user doesn't approve and
+                abort_if_user_denies was passed to the consturctor.
+        """
+        if self._ManifestUrlHasSecureScheme():
+            return self._CheckForHookApprovalManifest()
+        else:
+            return self._CheckForHookApprovalHash()
+    def _CheckForHookApprovalHelper(
+        self, subkey, new_val, main_prompt, changed_prompt
+    ):
+        """Check for approval for a particular attribute and hook.
+        Args:
+            subkey: The git config key under [repo.hooks.<hook_type>] to store
+                the last approved string.
+            new_val: The new value to compare against the last approved one.
+            main_prompt: Message to display to the user to ask for approval.
+            changed_prompt: Message explaining why we're re-asking for approval.
+        Returns:
+            True if this hook is approved to run; False otherwise.
+        Raises:
+            HookError: Raised if the user doesn't approve and
+                abort_if_user_denies was passed to the consturctor.
+        """
+        hooks_config = self._hooks_project.config
+        git_approval_key = "repo.hooks.%s.%s" % (self._hook_type, subkey)
+        # Get the last value that the user approved for this hook; may be None.
+        old_val = hooks_config.GetString(git_approval_key)
+        if old_val is not None:
+            # User previously approved hook and asked not to be prompted again.
+            if new_val == old_val:
+                # Approval matched.  We're done.
+                return True
+            else:
+                # Give the user a reason why we're prompting, since they last
+                # told us to "never ask again".
+                prompt = "WARNING: %s\n\n" % (changed_prompt,)
+        else:
+            prompt = ""
+        # Prompt the user if we're not on a tty; on a tty we'll assume "no".
+        if sys.stdout.isatty():
+            prompt += main_prompt + " (yes/always/NO)? "
+            response = input(prompt).lower()
+            print()
+            # User is doing a one-time approval.
+            if response in ("y", "yes"):
+                return True
+            elif response == "always":
+                hooks_config.SetString(git_approval_key, new_val)
+                return True
+        # For anything else, we'll assume no approval.
+        if self._abort_if_user_denies:
+            raise HookError(
+                "You must allow the %s hook or use --no-verify."
+                % self._hook_type
+            )
+        return False
+    def _ManifestUrlHasSecureScheme(self):
+        """Check if the URI for the manifest is a secure transport."""
+        secure_schemes = (
+            "file",
+            "https",
+            "ssh",
+            "persistent-https",
+            "sso",
+            "rpc",
+        )
+        parse_results = urllib.parse.urlparse(self._manifest_url)
+        return parse_results.scheme in secure_schemes
+    def _CheckForHookApprovalManifest(self):
+        """Check whether the user has approved this manifest host.
+        Returns:
+            True if this hook is approved to run; False otherwise.
+        """
+        return self._CheckForHookApprovalHelper(
+            "approvedmanifest",
+            self._manifest_url,
+            "Run hook scripts from %s" % (self._manifest_url,),
+            "Manifest URL has changed since %s was allowed."
+            % (self._hook_type,),
+        )
+    def _CheckForHookApprovalHash(self):
+        """Check whether the user has approved the hooks repo.
+        Returns:
+            True if this hook is approved to run; False otherwise.
+        """
+        prompt = (
+            "Repo %s run the script:\n"
+            "  %s\n"
+            "\n"
+            "Do you want to allow this script to run"
+        )
+        return self._CheckForHookApprovalHelper(
+            "approvedhash",
+            self._GetHash(),
+            prompt % (self._GetMustVerb(), self._script_fullpath),
+            "Scripts have changed since %s was allowed." % (self._hook_type,),
+        )
+    @staticmethod
+    def _ExtractInterpFromShebang(data):
+        """Extract the interpreter used in the shebang.
+        Try to locate the interpreter the script is using (ignoring `env`).
+        Args:
+            data: The file content of the script.
+        Returns:
+            The basename of the main script interpreter, or None if a shebang is
+            not used or could not be parsed out.
+        """
+        firstline = data.splitlines()[:1]
+        if not firstline:
+            return None
+        # The format here can be tricky.
+        shebang = firstline[0].strip()
+        m = re.match(r"^#!\s*([^\s]+)(?:\s+([^\s]+))?", shebang)
+        if not m:
+            return None
+        # If the using `env`, find the target program.
+        interp = m.group(1)
+        if os.path.basename(interp) == "env":
+            interp = m.group(2)
+        return interp
+    def _ExecuteHookViaReexec(self, interp, context, **kwargs):
+        """Execute the hook script through |interp|.
+        Note: Support for this feature should be dropped ~Jun 2021.
+        Args:
+            interp: The Python program to run.
+            context: Basic Python context to execute the hook inside.
+            kwargs: Arbitrary arguments to pass to the hook script.
+        Raises:
+            HookError: When the hooks failed for any reason.
+        """
+        # This logic needs to be kept in sync with _ExecuteHookViaImport below.
+        script = """
 import json, os, sys
 path = '''%(path)s'''
 kwargs = json.loads('''%(kwargs)s''')
@@ -300,210 +322,240 @@ data = open(path).read()
 exec(compile(data, path, 'exec'), context)
 context['main'](**kwargs)
 """ % {
-        'path': self._script_fullpath,
+            "path": self._script_fullpath,
-        'kwargs': json.dumps(kwargs),
+            "kwargs": json.dumps(kwargs),
-        'context': json.dumps(context),
+            "context": json.dumps(context),
-    }
+        }
-    # We pass the script via stdin to avoid OS argv limits.  It also makes
+        # We pass the script via stdin to avoid OS argv limits.  It also makes
-    # unhandled exception tracebacks less verbose/confusing for users.
+        # unhandled exception tracebacks less verbose/confusing for users.
-    cmd = [interp, '-c', 'import sys; exec(sys.stdin.read())']
+        cmd = [interp, "-c", "import sys; exec(sys.stdin.read())"]
-    proc = subprocess.Popen(cmd, stdin=subprocess.PIPE)
+        proc = subprocess.Popen(cmd, stdin=subprocess.PIPE)
-    proc.communicate(input=script.encode('utf-8'))
+        proc.communicate(input=script.encode("utf-8"))
-    if proc.returncode:
+        if proc.returncode:
-      raise HookError('Failed to run %s hook.' % (self._hook_type,))
+            raise HookError("Failed to run %s hook." % (self._hook_type,))
-  def _ExecuteHookViaImport(self, data, context, **kwargs):
+    def _ExecuteHookViaImport(self, data, context, **kwargs):
-    """Execute the hook code in |data| directly.
+        """Execute the hook code in |data| directly.
-    Args:
+        Args:
-      data: The code of the hook to execute.
+            data: The code of the hook to execute.
-      context: Basic Python context to execute the hook inside.
+            context: Basic Python context to execute the hook inside.
-      kwargs: Arbitrary arguments to pass to the hook script.
+            kwargs: Arbitrary arguments to pass to the hook script.
-    Raises:
+        Raises:
-      HookError: When the hooks failed for any reason.
+            HookError: When the hooks failed for any reason.
-    """
+        """
-    # Exec, storing global context in the context dict.  We catch exceptions
+        # Exec, storing global context in the context dict.  We catch exceptions
-    # and convert to a HookError w/ just the failing traceback.
+        # and convert to a HookError w/ just the failing traceback.
-    try:
+        try:
-      exec(compile(data, self._script_fullpath, 'exec'), context)
+            exec(compile(data, self._script_fullpath, "exec"), context)
-    except Exception:
+        except Exception:
-      raise HookError('%s\nFailed to import %s hook; see traceback above.' %
+            raise HookError(
-                      (traceback.format_exc(), self._hook_type))
+                "%s\nFailed to import %s hook; see traceback above."
+                % (traceback.format_exc(), self._hook_type)
-    # Running the script should have defined a main() function.
+            )
-    if 'main' not in context:
-      raise HookError('Missing main() in: "%s"' % self._script_fullpath)
+        # Running the script should have defined a main() function.
+        if "main" not in context:
-    # Call the main function in the hook.  If the hook should cause the
+            raise HookError('Missing main() in: "%s"' % self._script_fullpath)
-    # build to fail, it will raise an Exception.  We'll catch that convert
-    # to a HookError w/ just the failing traceback.
+        # Call the main function in the hook.  If the hook should cause the
-    try:
+        # build to fail, it will raise an Exception.  We'll catch that convert
-      context['main'](**kwargs)
+        # to a HookError w/ just the failing traceback.
-    except Exception:
-      raise HookError('%s\nFailed to run main() for %s hook; see traceback '
-                      'above.' % (traceback.format_exc(), self._hook_type))
-  def _ExecuteHook(self, **kwargs):
-    """Actually execute the given hook.
-    This will run the hook's 'main' function in our python interpreter.
-    Args:
-      kwargs: Keyword arguments to pass to the hook.  These are often specific
-          to the hook type.  For instance, pre-upload hooks will contain
-          a project_list.
-    """
-    # Keep sys.path and CWD stashed away so that we can always restore them
-    # upon function exit.
-    orig_path = os.getcwd()
-    orig_syspath = sys.path
-    try:
-      # Always run hooks with CWD as topdir.
-      os.chdir(self._repo_topdir)
-      # Put the hook dir as the first item of sys.path so hooks can do
-      # relative imports.  We want to replace the repo dir as [0] so
-      # hooks can't import repo files.
-      sys.path = [os.path.dirname(self._script_fullpath)] + sys.path[1:]
-      # Initial global context for the hook to run within.
-      context = {'__file__': self._script_fullpath}
-      # Add 'hook_should_take_kwargs' to the arguments to be passed to main.
-      # We don't actually want hooks to define their main with this argument--
-      # it's there to remind them that their hook should always take **kwargs.
-      # For instance, a pre-upload hook should be defined like:
-      #   def main(project_list, **kwargs):
-      #
-      # This allows us to later expand the API without breaking old hooks.
-      kwargs = kwargs.copy()
-      kwargs['hook_should_take_kwargs'] = True
-      # See what version of python the hook has been written against.
-      data = open(self._script_fullpath).read()
-      interp = self._ExtractInterpFromShebang(data)
-      reexec = False
-      if interp:
-        prog = os.path.basename(interp)
-        if prog.startswith('python2') and sys.version_info.major != 2:
-          reexec = True
-        elif prog.startswith('python3') and sys.version_info.major == 2:
-          reexec = True
-      # Attempt to execute the hooks through the requested version of Python.
-      if reexec:
        try:
-          self._ExecuteHookViaReexec(interp, context, **kwargs)
+            context["main"](**kwargs)
-        except OSError as e:
+        except Exception:
-          if e.errno == errno.ENOENT:
+            raise HookError(
-            # We couldn't find the interpreter, so fallback to importing.
+                "%s\nFailed to run main() for %s hook; see traceback "
+                "above." % (traceback.format_exc(), self._hook_type)
+            )
+    def _ExecuteHook(self, **kwargs):
+        """Actually execute the given hook.
+        This will run the hook's 'main' function in our python interpreter.
+        Args:
+            kwargs: Keyword arguments to pass to the hook.  These are often
+                specific to the hook type.  For instance, pre-upload hooks will
+                contain a project_list.
+        """
+        # Keep sys.path and CWD stashed away so that we can always restore them
+        # upon function exit.
+        orig_path = os.getcwd()
+        orig_syspath = sys.path
+        try:
+            # Always run hooks with CWD as topdir.
+            os.chdir(self._repo_topdir)
+            # Put the hook dir as the first item of sys.path so hooks can do
+            # relative imports.  We want to replace the repo dir as [0] so
+            # hooks can't import repo files.
+            sys.path = [os.path.dirname(self._script_fullpath)] + sys.path[1:]
+            # Initial global context for the hook to run within.
+            context = {"__file__": self._script_fullpath}
+            # Add 'hook_should_take_kwargs' to the arguments to be passed to
+            # main. We don't actually want hooks to define their main with this
+            # argument--it's there to remind them that their hook should always
+            # take **kwargs.
+            # For instance, a pre-upload hook should be defined like:
+            #   def main(project_list, **kwargs):
+            #
+            # This allows us to later expand the API without breaking old hooks.
+            kwargs = kwargs.copy()
+            kwargs["hook_should_take_kwargs"] = True
+            # See what version of python the hook has been written against.
+            data = open(self._script_fullpath).read()
+            interp = self._ExtractInterpFromShebang(data)
            reexec = False
-          else:
+            if interp:
-            raise
+                prog = os.path.basename(interp)
+                if prog.startswith("python2") and sys.version_info.major != 2:
-      # Run the hook by importing directly.
+                    reexec = True
-      if not reexec:
+                elif prog.startswith("python3") and sys.version_info.major == 2:
-        self._ExecuteHookViaImport(data, context, **kwargs)
+                    reexec = True
-    finally:
-      # Restore sys.path and CWD.
+            # Attempt to execute the hooks through the requested version of
-      sys.path = orig_syspath
+            # Python.
-      os.chdir(orig_path)
+            if reexec:
+                try:
-  def _CheckHook(self):
+                    self._ExecuteHookViaReexec(interp, context, **kwargs)
-    # Bail with a nice error if we can't find the hook.
+                except OSError as e:
-    if not os.path.isfile(self._script_fullpath):
+                    if e.errno == errno.ENOENT:
-      raise HookError('Couldn\'t find repo hook: %s' % self._script_fullpath)
+                        # We couldn't find the interpreter, so fallback to
+                        # importing.
-  def Run(self, **kwargs):
+                        reexec = False
-    """Run the hook.
+                    else:
+                        raise
-    If the hook doesn't exist (because there is no hooks project or because
-    this particular hook is not enabled), this is a no-op.
+            # Run the hook by importing directly.
+            if not reexec:
-    Args:
+                self._ExecuteHookViaImport(data, context, **kwargs)
-      user_allows_all_hooks: If True, we will never prompt about running the
+        finally:
-          hook--we'll just assume it's OK to run it.
+            # Restore sys.path and CWD.
-      kwargs: Keyword arguments to pass to the hook.  These are often specific
+            sys.path = orig_syspath
-          to the hook type.  For instance, pre-upload hooks will contain
+            os.chdir(orig_path)
-          a project_list.
+    def _CheckHook(self):
-    Returns:
+        # Bail with a nice error if we can't find the hook.
-      True: On success or ignore hooks by user-request
+        if not os.path.isfile(self._script_fullpath):
-      False: The hook failed. The caller should respond with aborting the action.
+            raise HookError(
-        Some examples in which False is returned:
+                "Couldn't find repo hook: %s" % self._script_fullpath
-        * Finding the hook failed while it was enabled, or
+            )
-        * the user declined to run a required hook (from _CheckForHookApproval)
-        In all these cases the user did not pass the proper arguments to
+    def Run(self, **kwargs):
-        ignore the result through the option combinations as listed in
+        """Run the hook.
-        AddHookOptionGroup().
-    """
+        If the hook doesn't exist (because there is no hooks project or because
-    # Do not do anything in case bypass_hooks is set, or
+        this particular hook is not enabled), this is a no-op.
-    # no-op if there is no hooks project or if hook is disabled.
-    if (self._bypass_hooks or
+        Args:
-        not self._hooks_project or
+            user_allows_all_hooks: If True, we will never prompt about running
-        self._hook_type not in self._hooks_project.enabled_repo_hooks):
+                the hook--we'll just assume it's OK to run it.
-      return True
+            kwargs: Keyword arguments to pass to the hook.  These are often
+                specific to the hook type.  For instance, pre-upload hooks will
-    passed = True
+                contain a project_list.
-    try:
-      self._CheckHook()
+        Returns:
+            True: On success or ignore hooks by user-request
-      # Make sure the user is OK with running the hook.
+            False: The hook failed. The caller should respond with aborting the
-      if self._allow_all_hooks or self._CheckForHookApproval():
+                action. Some examples in which False is returned:
-        # Run the hook with the same version of python we're using.
+                * Finding the hook failed while it was enabled, or
-        self._ExecuteHook(**kwargs)
+                * the user declined to run a required hook (from
-    except SystemExit as e:
+                    _CheckForHookApproval)
-      passed = False
+                In all these cases the user did not pass the proper arguments to
-      print('ERROR: %s hooks exited with exit code: %s' % (self._hook_type, str(e)),
+                ignore the result through the option combinations as listed in
-            file=sys.stderr)
+                AddHookOptionGroup().
-    except HookError as e:
+        """
-      passed = False
+        # Do not do anything in case bypass_hooks is set, or
-      print('ERROR: %s' % str(e), file=sys.stderr)
+        # no-op if there is no hooks project or if hook is disabled.
+        if (
-    if not passed and self._ignore_hooks:
+            self._bypass_hooks
-      print('\nWARNING: %s hooks failed, but continuing anyways.' % self._hook_type,
+            or not self._hooks_project
-            file=sys.stderr)
+            or self._hook_type not in self._hooks_project.enabled_repo_hooks
-      passed = True
+        ):
+            return True
-    return passed
+        passed = True
-  @classmethod
+        try:
-  def FromSubcmd(cls, manifest, opt, *args, **kwargs):
+            self._CheckHook()
-    """Method to construct the repo hook class
+            # Make sure the user is OK with running the hook.
-    Args:
+            if self._allow_all_hooks or self._CheckForHookApproval():
-      manifest: The current active manifest for this command from which we
+                # Run the hook with the same version of python we're using.
-          extract a couple of fields.
+                self._ExecuteHook(**kwargs)
-      opt: Contains the commandline options for the action of this hook.
+        except SystemExit as e:
-          It should contain the options added by AddHookOptionGroup() in which
+            passed = False
-          we are interested in RepoHook execution.
+            print(
-    """
+                "ERROR: %s hooks exited with exit code: %s"
-    for key in ('bypass_hooks', 'allow_all_hooks', 'ignore_hooks'):
+                % (self._hook_type, str(e)),
-      kwargs.setdefault(key, getattr(opt, key))
+                file=sys.stderr,
-    kwargs.update({
+            )
-        'hooks_project': manifest.repo_hooks_project,
+        except HookError as e:
-        'repo_topdir': manifest.topdir,
+            passed = False
-        'manifest_url': manifest.manifestProject.GetRemote('origin').url,
+            print("ERROR: %s" % str(e), file=sys.stderr)
-    })
-    return cls(*args, **kwargs)
+        if not passed and self._ignore_hooks:
+            print(
-  @staticmethod
+                "\nWARNING: %s hooks failed, but continuing anyways."
-  def AddOptionGroup(parser, name):
+                % self._hook_type,
-    """Help options relating to the various hooks."""
+                file=sys.stderr,
+            )
-    # Note that verify and no-verify are NOT opposites of each other, which
+            passed = True
-    # is why they store to different locations. We are using them to match
-    # 'git commit' syntax.
+        return passed
-    group = parser.add_option_group(name + ' hooks')
-    group.add_option('--no-verify',
+    @classmethod
-                     dest='bypass_hooks', action='store_true',
+    def FromSubcmd(cls, manifest, opt, *args, **kwargs):
-                     help='Do not run the %s hook.' % name)
+        """Method to construct the repo hook class
-    group.add_option('--verify',
-                     dest='allow_all_hooks', action='store_true',
+        Args:
-                     help='Run the %s hook without prompting.' % name)
+            manifest: The current active manifest for this command from which we
-    group.add_option('--ignore-hooks',
+                extract a couple of fields.
-                     action='store_true',
+            opt: Contains the commandline options for the action of this hook.
-                     help='Do not abort if %s hooks fail.' % name)
+                It should contain the options added by AddHookOptionGroup() in
+                which we are interested in RepoHook execution.
+        """
+        for key in ("bypass_hooks", "allow_all_hooks", "ignore_hooks"):
+            kwargs.setdefault(key, getattr(opt, key))
+        kwargs.update(
+            {
+                "hooks_project": manifest.repo_hooks_project,
+                "repo_topdir": manifest.topdir,
+                "manifest_url": manifest.manifestProject.GetRemote(
+                    "origin"
+                ).url,
+            }
+        )
+        return cls(*args, **kwargs)
+    @staticmethod
+    def AddOptionGroup(parser, name):
+        """Help options relating to the various hooks."""
+        # Note that verify and no-verify are NOT opposites of each other, which
+        # is why they store to different locations. We are using them to match
+        # 'git commit' syntax.
+        group = parser.add_option_group(name + " hooks")
+        group.add_option(
+            "--no-verify",
+            dest="bypass_hooks",
+            action="store_true",
+            help="Do not run the %s hook." % name,
+        )
+        group.add_option(
+            "--verify",
+            dest="allow_all_hooks",
+            action="store_true",
+            help="Run the %s hook without prompting." % name,
+        )
+        group.add_option(
+            "--ignore-hooks",
+            action="store_true",
+            help="Do not abort if %s hooks fail." % name,
+        )
diff --git a/main.py b/main.py
index f4b6e7ac..6dcb66f6 100755
--- a/main.py
+++ b/main.py
@@ -31,9 +31,9 @@ import time
 import urllib.request
 try:
-  import kerberos
+    import kerberos
 except ImportError:
-  kerberos = None
+    kerberos = None
 from color import SetDefaultColoring
 import event_log
@@ -74,347 +74,442 @@ MIN_PYTHON_VERSION_SOFT = (3, 6)
 MIN_PYTHON_VERSION_HARD = (3, 6)
 if sys.version_info.major < 3:
-  print('repo: error: Python 2 is no longer supported; '
+    print(
-        'Please upgrade to Python {}.{}+.'.format(*MIN_PYTHON_VERSION_SOFT),
+        "repo: error: Python 2 is no longer supported; "
-        file=sys.stderr)
+        "Please upgrade to Python {}.{}+.".format(*MIN_PYTHON_VERSION_SOFT),
-  sys.exit(1)
+        file=sys.stderr,
-else:
+    )
-  if sys.version_info < MIN_PYTHON_VERSION_HARD:
-    print('repo: error: Python 3 version is too old; '
-          'Please upgrade to Python {}.{}+.'.format(*MIN_PYTHON_VERSION_SOFT),
-          file=sys.stderr)
    sys.exit(1)
-  elif sys.version_info < MIN_PYTHON_VERSION_SOFT:
+else:
-    print('repo: warning: your Python 3 version is no longer supported; '
+    if sys.version_info < MIN_PYTHON_VERSION_HARD:
-          'Please upgrade to Python {}.{}+.'.format(*MIN_PYTHON_VERSION_SOFT),
+        print(
-          file=sys.stderr)
+            "repo: error: Python 3 version is too old; "
+            "Please upgrade to Python {}.{}+.".format(*MIN_PYTHON_VERSION_SOFT),
+            file=sys.stderr,
+        )
+        sys.exit(1)
+    elif sys.version_info < MIN_PYTHON_VERSION_SOFT:
+        print(
+            "repo: warning: your Python 3 version is no longer supported; "
+            "Please upgrade to Python {}.{}+.".format(*MIN_PYTHON_VERSION_SOFT),
+            file=sys.stderr,
+        )
 global_options = optparse.OptionParser(
-    usage='repo [-p|--paginate|--no-pager] COMMAND [ARGS]',
+    usage="repo [-p|--paginate|--no-pager] COMMAND [ARGS]",
-    add_help_option=False)
+    add_help_option=False,
-global_options.add_option('-h', '--help', action='store_true',
+)
-                          help='show this help message and exit')
+global_options.add_option(
-global_options.add_option('--help-all', action='store_true',
+    "-h", "--help", action="store_true", help="show this help message and exit"
-                          help='show this help message with all subcommands and exit')
+)
-global_options.add_option('-p', '--paginate',
+global_options.add_option(
-                          dest='pager', action='store_true',
+    "--help-all",
-                          help='display command output in the pager')
+    action="store_true",
-global_options.add_option('--no-pager',
+    help="show this help message with all subcommands and exit",
-                          dest='pager', action='store_false',
+)
-                          help='disable the pager')
+global_options.add_option(
-global_options.add_option('--color',
+    "-p",
-                          choices=('auto', 'always', 'never'), default=None,
+    "--paginate",
-                          help='control color usage: auto, always, never')
+    dest="pager",
-global_options.add_option('--trace',
+    action="store_true",
-                          dest='trace', action='store_true',
+    help="display command output in the pager",
-                          help='trace git command execution (REPO_TRACE=1)')
+)
-global_options.add_option('--trace-to-stderr',
+global_options.add_option(
-                          dest='trace_to_stderr', action='store_true',
+    "--no-pager", dest="pager", action="store_false", help="disable the pager"
-                          help='trace outputs go to stderr in addition to .repo/TRACE_FILE')
+)
-global_options.add_option('--trace-python',
+global_options.add_option(
-                          dest='trace_python', action='store_true',
+    "--color",
-                          help='trace python command execution')
+    choices=("auto", "always", "never"),
-global_options.add_option('--time',
+    default=None,
-                          dest='time', action='store_true',
+    help="control color usage: auto, always, never",
-                          help='time repo command execution')
+)
-global_options.add_option('--version',
+global_options.add_option(
-                          dest='show_version', action='store_true',
+    "--trace",
-                          help='display this version of repo')
+    dest="trace",
-global_options.add_option('--show-toplevel',
+    action="store_true",
-                          action='store_true',
+    help="trace git command execution (REPO_TRACE=1)",
-                          help='display the path of the top-level directory of '
+)
-                               'the repo client checkout')
+global_options.add_option(
-global_options.add_option('--event-log',
+    "--trace-to-stderr",
-                          dest='event_log', action='store',
+    dest="trace_to_stderr",
-                          help='filename of event log to append timeline to')
+    action="store_true",
-global_options.add_option('--git-trace2-event-log', action='store',
+    help="trace outputs go to stderr in addition to .repo/TRACE_FILE",
-                          help='directory to write git trace2 event log to')
+)
-global_options.add_option('--submanifest-path', action='store',
+global_options.add_option(
-                          metavar='REL_PATH', help='submanifest path')
+    "--trace-python",
+    dest="trace_python",
+    action="store_true",
+    help="trace python command execution",
+)
+global_options.add_option(
+    "--time",
+    dest="time",
+    action="store_true",
+    help="time repo command execution",
+)
+global_options.add_option(
+    "--version",
+    dest="show_version",
+    action="store_true",
+    help="display this version of repo",
+)
+global_options.add_option(
+    "--show-toplevel",
+    action="store_true",
+    help="display the path of the top-level directory of "
+    "the repo client checkout",
+)
+global_options.add_option(
+    "--event-log",
+    dest="event_log",
+    action="store",
+    help="filename of event log to append timeline to",
+)
+global_options.add_option(
+    "--git-trace2-event-log",
+    action="store",
+    help="directory to write git trace2 event log to",
+)
+global_options.add_option(
+    "--submanifest-path",
+    action="store",
+    metavar="REL_PATH",
+    help="submanifest path",
+)
 class _Repo(object):
-  def __init__(self, repodir):
+    def __init__(self, repodir):
-    self.repodir = repodir
+        self.repodir = repodir
-    self.commands = all_commands
+        self.commands = all_commands
-  def _PrintHelp(self, short: bool = False, all_commands: bool = False):
+    def _PrintHelp(self, short: bool = False, all_commands: bool = False):
-    """Show --help screen."""
+        """Show --help screen."""
-    global_options.print_help()
+        global_options.print_help()
-    print()
+        print()
-    if short:
+        if short:
-      commands = ' '.join(sorted(self.commands))
+            commands = " ".join(sorted(self.commands))
-      wrapped_commands = textwrap.wrap(commands, width=77)
+            wrapped_commands = textwrap.wrap(commands, width=77)
-      print('Available commands:\n  %s' % ('\n  '.join(wrapped_commands),))
+            print(
-      print('\nRun `repo help <command>` for command-specific details.')
+                "Available commands:\n  %s" % ("\n  ".join(wrapped_commands),)
-      print('Bug reports:', Wrapper().BUG_URL)
+            )
-    else:
+            print("\nRun `repo help <command>` for command-specific details.")
-      cmd = self.commands['help']()
+            print("Bug reports:", Wrapper().BUG_URL)
-      if all_commands:
-        cmd.PrintAllCommandsBody()
-      else:
-        cmd.PrintCommonCommandsBody()
-  def _ParseArgs(self, argv):
-    """Parse the main `repo` command line options."""
-    for i, arg in enumerate(argv):
-      if not arg.startswith('-'):
-        name = arg
-        glob = argv[:i]
-        argv = argv[i + 1:]
-        break
-    else:
-      name = None
-      glob = argv
-      argv = []
-    gopts, _gargs = global_options.parse_args(glob)
-    if name:
-      name, alias_args = self._ExpandAlias(name)
-      argv = alias_args + argv
-    return (name, gopts, argv)
-  def _ExpandAlias(self, name):
-    """Look up user registered aliases."""
-    # We don't resolve aliases for existing subcommands.  This matches git.
-    if name in self.commands:
-      return name, []
-    key = 'alias.%s' % (name,)
-    alias = RepoConfig.ForRepository(self.repodir).GetString(key)
-    if alias is None:
-      alias = RepoConfig.ForUser().GetString(key)
-    if alias is None:
-      return name, []
-    args = alias.strip().split(' ', 1)
-    name = args[0]
-    if len(args) == 2:
-      args = shlex.split(args[1])
-    else:
-      args = []
-    return name, args
-  def _Run(self, name, gopts, argv):
-    """Execute the requested subcommand."""
-    result = 0
-    # Handle options that terminate quickly first.
-    if gopts.help or gopts.help_all:
-      self._PrintHelp(short=False, all_commands=gopts.help_all)
-      return 0
-    elif gopts.show_version:
-      # Always allow global --version regardless of subcommand validity.
-      name = 'version'
-    elif gopts.show_toplevel:
-      print(os.path.dirname(self.repodir))
-      return 0
-    elif not name:
-      # No subcommand specified, so show the help/subcommand.
-      self._PrintHelp(short=True)
-      return 1
-    run = lambda: self._RunLong(name, gopts, argv) or 0
-    with Trace('starting new command: %s', ', '.join([name] + argv),
-               first_trace=True):
-      if gopts.trace_python:
-        import trace
-        tracer = trace.Trace(count=False, trace=True, timing=True,
-                             ignoredirs=set(sys.path[1:]))
-        result = tracer.runfunc(run)
-      else:
-        result = run()
-    return result
-  def _RunLong(self, name, gopts, argv):
-    """Execute the (longer running) requested subcommand."""
-    result = 0
-    SetDefaultColoring(gopts.color)
-    git_trace2_event_log = EventLog()
-    outer_client = RepoClient(self.repodir)
-    repo_client = outer_client
-    if gopts.submanifest_path:
-      repo_client = RepoClient(self.repodir,
-                               submanifest_path=gopts.submanifest_path,
-                               outer_client=outer_client)
-    gitc_manifest = None
-    gitc_client_name = gitc_utils.parse_clientdir(os.getcwd())
-    if gitc_client_name:
-      gitc_manifest = GitcClient(self.repodir, gitc_client_name)
-      repo_client.isGitcClient = True
-    try:
-      cmd = self.commands[name](
-          repodir=self.repodir,
-          client=repo_client,
-          manifest=repo_client.manifest,
-          outer_client=outer_client,
-          outer_manifest=outer_client.manifest,
-          gitc_manifest=gitc_manifest,
-          git_event_log=git_trace2_event_log)
-    except KeyError:
-      print("repo: '%s' is not a repo command.  See 'repo help'." % name,
-            file=sys.stderr)
-      return 1
-    Editor.globalConfig = cmd.client.globalConfig
-    if not isinstance(cmd, MirrorSafeCommand) and cmd.manifest.IsMirror:
-      print("fatal: '%s' requires a working directory" % name,
-            file=sys.stderr)
-      return 1
-    if isinstance(cmd, GitcAvailableCommand) and not gitc_utils.get_gitc_manifest_dir():
-      print("fatal: '%s' requires GITC to be available" % name,
-            file=sys.stderr)
-      return 1
-    if isinstance(cmd, GitcClientCommand) and not gitc_client_name:
-      print("fatal: '%s' requires a GITC client" % name,
-            file=sys.stderr)
-      return 1
-    try:
-      copts, cargs = cmd.OptionParser.parse_args(argv)
-      copts = cmd.ReadEnvironmentOptions(copts)
-    except NoManifestException as e:
-      print('error: in `%s`: %s' % (' '.join([name] + argv), str(e)),
-            file=sys.stderr)
-      print('error: manifest missing or unreadable -- please run init',
-            file=sys.stderr)
-      return 1
-    if gopts.pager is not False and not isinstance(cmd, InteractiveCommand):
-      config = cmd.client.globalConfig
-      if gopts.pager:
-        use_pager = True
-      else:
-        use_pager = config.GetBoolean('pager.%s' % name)
-        if use_pager is None:
-          use_pager = cmd.WantPager(copts)
-      if use_pager:
-        RunPager(config)
-    start = time.time()
-    cmd_event = cmd.event_log.Add(name, event_log.TASK_COMMAND, start)
-    cmd.event_log.SetParent(cmd_event)
-    git_trace2_event_log.StartEvent()
-    git_trace2_event_log.CommandEvent(name='repo', subcommands=[name])
-    try:
-      cmd.CommonValidateOptions(copts, cargs)
-      cmd.ValidateOptions(copts, cargs)
-      this_manifest_only = copts.this_manifest_only
-      outer_manifest = copts.outer_manifest
-      if cmd.MULTI_MANIFEST_SUPPORT or this_manifest_only:
-        result = cmd.Execute(copts, cargs)
-      elif outer_manifest and repo_client.manifest.is_submanifest:
-        # The command does not support multi-manifest, we are using a
-        # submanifest, and the command line is for the outermost manifest.
-        # Re-run using the outermost manifest, which will recurse through the
-        # submanifests.
-        gopts.submanifest_path = ''
-        result = self._Run(name, gopts, argv)
-      else:
-        # No multi-manifest support. Run the command in the current
-        # (sub)manifest, and then any child submanifests.
-        result = cmd.Execute(copts, cargs)
-        for submanifest in repo_client.manifest.submanifests.values():
-          spec = submanifest.ToSubmanifestSpec()
-          gopts.submanifest_path = submanifest.repo_client.path_prefix
-          child_argv = argv[:]
-          child_argv.append('--no-outer-manifest')
-          # Not all subcommands support the 3 manifest options, so only add them
-          # if the original command includes them.
-          if hasattr(copts, 'manifest_url'):
-            child_argv.extend(['--manifest-url', spec.manifestUrl])
-          if hasattr(copts, 'manifest_name'):
-            child_argv.extend(['--manifest-name', spec.manifestName])
-          if hasattr(copts, 'manifest_branch'):
-            child_argv.extend(['--manifest-branch', spec.revision])
-          result = self._Run(name, gopts, child_argv) or result
-    except (DownloadError, ManifestInvalidRevisionError,
-            NoManifestException) as e:
-      print('error: in `%s`: %s' % (' '.join([name] + argv), str(e)),
-            file=sys.stderr)
-      if isinstance(e, NoManifestException):
-        print('error: manifest missing or unreadable -- please run init',
-              file=sys.stderr)
-      result = 1
-    except NoSuchProjectError as e:
-      if e.name:
-        print('error: project %s not found' % e.name, file=sys.stderr)
-      else:
-        print('error: no project in current directory', file=sys.stderr)
-      result = 1
-    except InvalidProjectGroupsError as e:
-      if e.name:
-        print('error: project group must be enabled for project %s' % e.name, file=sys.stderr)
-      else:
-        print('error: project group must be enabled for the project in the current directory',
-              file=sys.stderr)
-      result = 1
-    except SystemExit as e:
-      if e.code:
-        result = e.code
-      raise
-    finally:
-      finish = time.time()
-      elapsed = finish - start
-      hours, remainder = divmod(elapsed, 3600)
-      minutes, seconds = divmod(remainder, 60)
-      if gopts.time:
-        if hours == 0:
-          print('real\t%dm%.3fs' % (minutes, seconds), file=sys.stderr)
        else:
-          print('real\t%dh%dm%.3fs' % (hours, minutes, seconds),
+            cmd = self.commands["help"]()
-                file=sys.stderr)
+            if all_commands:
+                cmd.PrintAllCommandsBody()
-      cmd.event_log.FinishEvent(cmd_event, finish,
+            else:
-                                result is None or result == 0)
+                cmd.PrintCommonCommandsBody()
-      git_trace2_event_log.DefParamRepoEvents(
-          cmd.manifest.manifestProject.config.DumpConfigDict())
+    def _ParseArgs(self, argv):
-      git_trace2_event_log.ExitEvent(result)
+        """Parse the main `repo` command line options."""
+        for i, arg in enumerate(argv):
-      if gopts.event_log:
+            if not arg.startswith("-"):
-        cmd.event_log.Write(os.path.abspath(
+                name = arg
-                            os.path.expanduser(gopts.event_log)))
+                glob = argv[:i]
+                argv = argv[i + 1 :]
-      git_trace2_event_log.Write(gopts.git_trace2_event_log)
+                break
-    return result
+        else:
+            name = None
+            glob = argv
+            argv = []
+        gopts, _gargs = global_options.parse_args(glob)
+        if name:
+            name, alias_args = self._ExpandAlias(name)
+            argv = alias_args + argv
+        return (name, gopts, argv)
+    def _ExpandAlias(self, name):
+        """Look up user registered aliases."""
+        # We don't resolve aliases for existing subcommands.  This matches git.
+        if name in self.commands:
+            return name, []
+        key = "alias.%s" % (name,)
+        alias = RepoConfig.ForRepository(self.repodir).GetString(key)
+        if alias is None:
+            alias = RepoConfig.ForUser().GetString(key)
+        if alias is None:
+            return name, []
+        args = alias.strip().split(" ", 1)
+        name = args[0]
+        if len(args) == 2:
+            args = shlex.split(args[1])
+        else:
+            args = []
+        return name, args
+    def _Run(self, name, gopts, argv):
+        """Execute the requested subcommand."""
+        result = 0
+        # Handle options that terminate quickly first.
+        if gopts.help or gopts.help_all:
+            self._PrintHelp(short=False, all_commands=gopts.help_all)
+            return 0
+        elif gopts.show_version:
+            # Always allow global --version regardless of subcommand validity.
+            name = "version"
+        elif gopts.show_toplevel:
+            print(os.path.dirname(self.repodir))
+            return 0
+        elif not name:
+            # No subcommand specified, so show the help/subcommand.
+            self._PrintHelp(short=True)
+            return 1
+        run = lambda: self._RunLong(name, gopts, argv) or 0
+        with Trace(
+            "starting new command: %s",
+            ", ".join([name] + argv),
+            first_trace=True,
+        ):
+            if gopts.trace_python:
+                import trace
+                tracer = trace.Trace(
+                    count=False,
+                    trace=True,
+                    timing=True,
+                    ignoredirs=set(sys.path[1:]),
+                )
+                result = tracer.runfunc(run)
+            else:
+                result = run()
+        return result
+    def _RunLong(self, name, gopts, argv):
+        """Execute the (longer running) requested subcommand."""
+        result = 0
+        SetDefaultColoring(gopts.color)
+        git_trace2_event_log = EventLog()
+        outer_client = RepoClient(self.repodir)
+        repo_client = outer_client
+        if gopts.submanifest_path:
+            repo_client = RepoClient(
+                self.repodir,
+                submanifest_path=gopts.submanifest_path,
+                outer_client=outer_client,
+            )
+        gitc_manifest = None
+        gitc_client_name = gitc_utils.parse_clientdir(os.getcwd())
+        if gitc_client_name:
+            gitc_manifest = GitcClient(self.repodir, gitc_client_name)
+            repo_client.isGitcClient = True
+        try:
+            cmd = self.commands[name](
+                repodir=self.repodir,
+                client=repo_client,
+                manifest=repo_client.manifest,
+                outer_client=outer_client,
+                outer_manifest=outer_client.manifest,
+                gitc_manifest=gitc_manifest,
+                git_event_log=git_trace2_event_log,
+            )
+        except KeyError:
+            print(
+                "repo: '%s' is not a repo command.  See 'repo help'." % name,
+                file=sys.stderr,
+            )
+            return 1
+        Editor.globalConfig = cmd.client.globalConfig
+        if not isinstance(cmd, MirrorSafeCommand) and cmd.manifest.IsMirror:
+            print(
+                "fatal: '%s' requires a working directory" % name,
+                file=sys.stderr,
+            )
+            return 1
+        if (
+            isinstance(cmd, GitcAvailableCommand)
+            and not gitc_utils.get_gitc_manifest_dir()
+        ):
+            print(
+                "fatal: '%s' requires GITC to be available" % name,
+                file=sys.stderr,
+            )
+            return 1
+        if isinstance(cmd, GitcClientCommand) and not gitc_client_name:
+            print("fatal: '%s' requires a GITC client" % name, file=sys.stderr)
+            return 1
+        try:
+            copts, cargs = cmd.OptionParser.parse_args(argv)
+            copts = cmd.ReadEnvironmentOptions(copts)
+        except NoManifestException as e:
+            print(
+                "error: in `%s`: %s" % (" ".join([name] + argv), str(e)),
+                file=sys.stderr,
+            )
+            print(
+                "error: manifest missing or unreadable -- please run init",
+                file=sys.stderr,
+            )
+            return 1
+        if gopts.pager is not False and not isinstance(cmd, InteractiveCommand):
+            config = cmd.client.globalConfig
+            if gopts.pager:
+                use_pager = True
+            else:
+                use_pager = config.GetBoolean("pager.%s" % name)
+                if use_pager is None:
+                    use_pager = cmd.WantPager(copts)
+            if use_pager:
+                RunPager(config)
+        start = time.time()
+        cmd_event = cmd.event_log.Add(name, event_log.TASK_COMMAND, start)
+        cmd.event_log.SetParent(cmd_event)
+        git_trace2_event_log.StartEvent()
+        git_trace2_event_log.CommandEvent(name="repo", subcommands=[name])
+        try:
+            cmd.CommonValidateOptions(copts, cargs)
+            cmd.ValidateOptions(copts, cargs)
+            this_manifest_only = copts.this_manifest_only
+            outer_manifest = copts.outer_manifest
+            if cmd.MULTI_MANIFEST_SUPPORT or this_manifest_only:
+                result = cmd.Execute(copts, cargs)
+            elif outer_manifest and repo_client.manifest.is_submanifest:
+                # The command does not support multi-manifest, we are using a
+                # submanifest, and the command line is for the outermost
+                # manifest. Re-run using the outermost manifest, which will
+                # recurse through the submanifests.
+                gopts.submanifest_path = ""
+                result = self._Run(name, gopts, argv)
+            else:
+                # No multi-manifest support. Run the command in the current
+                # (sub)manifest, and then any child submanifests.
+                result = cmd.Execute(copts, cargs)
+                for submanifest in repo_client.manifest.submanifests.values():
+                    spec = submanifest.ToSubmanifestSpec()
+                    gopts.submanifest_path = submanifest.repo_client.path_prefix
+                    child_argv = argv[:]
+                    child_argv.append("--no-outer-manifest")
+                    # Not all subcommands support the 3 manifest options, so
+                    # only add them if the original command includes them.
+                    if hasattr(copts, "manifest_url"):
+                        child_argv.extend(["--manifest-url", spec.manifestUrl])
+                    if hasattr(copts, "manifest_name"):
+                        child_argv.extend(
+                            ["--manifest-name", spec.manifestName]
+                        )
+                    if hasattr(copts, "manifest_branch"):
+                        child_argv.extend(["--manifest-branch", spec.revision])
+                    result = self._Run(name, gopts, child_argv) or result
+        except (
+            DownloadError,
+            ManifestInvalidRevisionError,
+            NoManifestException,
+        ) as e:
+            print(
+                "error: in `%s`: %s" % (" ".join([name] + argv), str(e)),
+                file=sys.stderr,
+            )
+            if isinstance(e, NoManifestException):
+                print(
+                    "error: manifest missing or unreadable -- please run init",
+                    file=sys.stderr,
+                )
+            result = 1
+        except NoSuchProjectError as e:
+            if e.name:
+                print("error: project %s not found" % e.name, file=sys.stderr)
+            else:
+                print("error: no project in current directory", file=sys.stderr)
+            result = 1
+        except InvalidProjectGroupsError as e:
+            if e.name:
+                print(
+                    "error: project group must be enabled for project %s"
+                    % e.name,
+                    file=sys.stderr,
+                )
+            else:
+                print(
+                    "error: project group must be enabled for the project in "
+                    "the current directory",
+                    file=sys.stderr,
+                )
+            result = 1
+        except SystemExit as e:
+            if e.code:
+                result = e.code
+            raise
+        finally:
+            finish = time.time()
+            elapsed = finish - start
+            hours, remainder = divmod(elapsed, 3600)
+            minutes, seconds = divmod(remainder, 60)
+            if gopts.time:
+                if hours == 0:
+                    print(
+                        "real\t%dm%.3fs" % (minutes, seconds), file=sys.stderr
+                    )
+                else:
+                    print(
+                        "real\t%dh%dm%.3fs" % (hours, minutes, seconds),
+                        file=sys.stderr,
+                    )
+            cmd.event_log.FinishEvent(
+                cmd_event, finish, result is None or result == 0
+            )
+            git_trace2_event_log.DefParamRepoEvents(
+                cmd.manifest.manifestProject.config.DumpConfigDict()
+            )
+            git_trace2_event_log.ExitEvent(result)
+            if gopts.event_log:
+                cmd.event_log.Write(
+                    os.path.abspath(os.path.expanduser(gopts.event_log))
+                )
+            git_trace2_event_log.Write(gopts.git_trace2_event_log)
+        return result
 def _CheckWrapperVersion(ver_str, repo_path):
-  """Verify the repo launcher is new enough for this checkout.
+    """Verify the repo launcher is new enough for this checkout.
-  Args:
+    Args:
-    ver_str: The version string passed from the repo launcher when it ran us.
+        ver_str: The version string passed from the repo launcher when it ran
-    repo_path: The path to the repo launcher that loaded us.
+            us.
-  """
+        repo_path: The path to the repo launcher that loaded us.
-  # Refuse to work with really old wrapper versions.  We don't test these,
+    """
-  # so might as well require a somewhat recent sane version.
+    # Refuse to work with really old wrapper versions.  We don't test these,
-  # v1.15 of the repo launcher was released in ~Mar 2012.
+    # so might as well require a somewhat recent sane version.
-  MIN_REPO_VERSION = (1, 15)
+    # v1.15 of the repo launcher was released in ~Mar 2012.
-  min_str = '.'.join(str(x) for x in MIN_REPO_VERSION)
+    MIN_REPO_VERSION = (1, 15)
+    min_str = ".".join(str(x) for x in MIN_REPO_VERSION)
-  if not repo_path:
-    repo_path = '~/bin/repo'
+    if not repo_path:
+        repo_path = "~/bin/repo"
-  if not ver_str:
-    print('no --wrapper-version argument', file=sys.stderr)
+    if not ver_str:
-    sys.exit(1)
+        print("no --wrapper-version argument", file=sys.stderr)
+        sys.exit(1)
-  # Pull out the version of the repo launcher we know about to compare.
-  exp = Wrapper().VERSION
+    # Pull out the version of the repo launcher we know about to compare.
-  ver = tuple(map(int, ver_str.split('.')))
+    exp = Wrapper().VERSION
+    ver = tuple(map(int, ver_str.split(".")))
-  exp_str = '.'.join(map(str, exp))
-  if ver < MIN_REPO_VERSION:
+    exp_str = ".".join(map(str, exp))
-    print("""
+    if ver < MIN_REPO_VERSION:
+        print(
+            """
 repo: error:
 !!! Your version of repo %s is too old.
 !!! We need at least version %s.
@@ -422,284 +517,321 @@ repo: error:
 !!! You must upgrade before you can continue:
    cp %s %s
-""" % (ver_str, min_str, exp_str, WrapperPath(), repo_path), file=sys.stderr)
+"""
-    sys.exit(1)
+            % (ver_str, min_str, exp_str, WrapperPath(), repo_path),
+            file=sys.stderr,
-  if exp > ver:
+        )
-    print('\n... A new version of repo (%s) is available.' % (exp_str,),
+        sys.exit(1)
-          file=sys.stderr)
-    if os.access(repo_path, os.W_OK):
+    if exp > ver:
-      print("""\
+        print(
+            "\n... A new version of repo (%s) is available." % (exp_str,),
+            file=sys.stderr,
+        )
+        if os.access(repo_path, os.W_OK):
+            print(
+                """\
 ... You should upgrade soon:
    cp %s %s
-""" % (WrapperPath(), repo_path), file=sys.stderr)
+"""
-    else:
+                % (WrapperPath(), repo_path),
-      print("""\
+                file=sys.stderr,
+            )
+        else:
+            print(
+                """\
 ... New version is available at: %s
 ... The launcher is run from: %s
 !!! The launcher is not writable.  Please talk to your sysadmin or distro
 !!! to get an update installed.
-""" % (WrapperPath(), repo_path), file=sys.stderr)
+"""
+                % (WrapperPath(), repo_path),
+                file=sys.stderr,
+            )
 def _CheckRepoDir(repo_dir):
-  if not repo_dir:
+    if not repo_dir:
-    print('no --repo-dir argument', file=sys.stderr)
+        print("no --repo-dir argument", file=sys.stderr)
-    sys.exit(1)
+        sys.exit(1)
 def _PruneOptions(argv, opt):
-  i = 0
+    i = 0
-  while i < len(argv):
+    while i < len(argv):
-    a = argv[i]
+        a = argv[i]
-    if a == '--':
+        if a == "--":
-      break
+            break
-    if a.startswith('--'):
+        if a.startswith("--"):
-      eq = a.find('=')
+            eq = a.find("=")
-      if eq > 0:
+            if eq > 0:
-        a = a[0:eq]
+                a = a[0:eq]
-    if not opt.has_option(a):
+        if not opt.has_option(a):
-      del argv[i]
+            del argv[i]
-      continue
+            continue
-    i += 1
+        i += 1
 class _UserAgentHandler(urllib.request.BaseHandler):
-  def http_request(self, req):
+    def http_request(self, req):
-    req.add_header('User-Agent', user_agent.repo)
+        req.add_header("User-Agent", user_agent.repo)
-    return req
+        return req
-  def https_request(self, req):
+    def https_request(self, req):
-    req.add_header('User-Agent', user_agent.repo)
+        req.add_header("User-Agent", user_agent.repo)
-    return req
+        return req
 def _AddPasswordFromUserInput(handler, msg, req):
-  # If repo could not find auth info from netrc, try to get it from user input
+    # If repo could not find auth info from netrc, try to get it from user input
-  url = req.get_full_url()
+    url = req.get_full_url()
-  user, password = handler.passwd.find_user_password(None, url)
+    user, password = handler.passwd.find_user_password(None, url)
-  if user is None:
+    if user is None:
-    print(msg)
+        print(msg)
-    try:
+        try:
-      user = input('User: ')
+            user = input("User: ")
-      password = getpass.getpass()
+            password = getpass.getpass()
-    except KeyboardInterrupt:
+        except KeyboardInterrupt:
-      return
+            return
-    handler.passwd.add_password(None, url, user, password)
+        handler.passwd.add_password(None, url, user, password)
 class _BasicAuthHandler(urllib.request.HTTPBasicAuthHandler):
-  def http_error_401(self, req, fp, code, msg, headers):
+    def http_error_401(self, req, fp, code, msg, headers):
-    _AddPasswordFromUserInput(self, msg, req)
+        _AddPasswordFromUserInput(self, msg, req)
-    return urllib.request.HTTPBasicAuthHandler.http_error_401(
+        return urllib.request.HTTPBasicAuthHandler.http_error_401(
-        self, req, fp, code, msg, headers)
+            self, req, fp, code, msg, headers
+        )
-  def http_error_auth_reqed(self, authreq, host, req, headers):
-    try:
+    def http_error_auth_reqed(self, authreq, host, req, headers):
-      old_add_header = req.add_header
+        try:
+            old_add_header = req.add_header
-      def _add_header(name, val):
-        val = val.replace('\n', '')
+            def _add_header(name, val):
-        old_add_header(name, val)
+                val = val.replace("\n", "")
-      req.add_header = _add_header
+                old_add_header(name, val)
-      return urllib.request.AbstractBasicAuthHandler.http_error_auth_reqed(
-          self, authreq, host, req, headers)
+            req.add_header = _add_header
-    except Exception:
+            return (
-      reset = getattr(self, 'reset_retry_count', None)
+                urllib.request.AbstractBasicAuthHandler.http_error_auth_reqed(
-      if reset is not None:
+                    self, authreq, host, req, headers
-        reset()
+                )
-      elif getattr(self, 'retried', None):
+            )
-        self.retried = 0
+        except Exception:
-      raise
+            reset = getattr(self, "reset_retry_count", None)
+            if reset is not None:
+                reset()
+            elif getattr(self, "retried", None):
+                self.retried = 0
+            raise
 class _DigestAuthHandler(urllib.request.HTTPDigestAuthHandler):
-  def http_error_401(self, req, fp, code, msg, headers):
+    def http_error_401(self, req, fp, code, msg, headers):
-    _AddPasswordFromUserInput(self, msg, req)
+        _AddPasswordFromUserInput(self, msg, req)
-    return urllib.request.HTTPDigestAuthHandler.http_error_401(
+        return urllib.request.HTTPDigestAuthHandler.http_error_401(
-        self, req, fp, code, msg, headers)
+            self, req, fp, code, msg, headers
+        )
+    def http_error_auth_reqed(self, auth_header, host, req, headers):
+        try:
+            old_add_header = req.add_header
+            def _add_header(name, val):
+                val = val.replace("\n", "")
+                old_add_header(name, val)
+            req.add_header = _add_header
+            return (
+                urllib.request.AbstractDigestAuthHandler.http_error_auth_reqed(
+                    self, auth_header, host, req, headers
+                )
+            )
+        except Exception:
+            reset = getattr(self, "reset_retry_count", None)
+            if reset is not None:
+                reset()
+            elif getattr(self, "retried", None):
+                self.retried = 0
+            raise
-  def http_error_auth_reqed(self, auth_header, host, req, headers):
-    try:
+class _KerberosAuthHandler(urllib.request.BaseHandler):
-      old_add_header = req.add_header
+    def __init__(self):
+        self.retried = 0
-      def _add_header(name, val):
+        self.context = None
-        val = val.replace('\n', '')
+        self.handler_order = urllib.request.BaseHandler.handler_order - 50
-        old_add_header(name, val)
-      req.add_header = _add_header
+    def http_error_401(self, req, fp, code, msg, headers):
-      return urllib.request.AbstractDigestAuthHandler.http_error_auth_reqed(
+        host = req.get_host()
-          self, auth_header, host, req, headers)
+        retry = self.http_error_auth_reqed(
-    except Exception:
+            "www-authenticate", host, req, headers
-      reset = getattr(self, 'reset_retry_count', None)
+        )
-      if reset is not None:
+        return retry
-        reset()
-      elif getattr(self, 'retried', None):
+    def http_error_auth_reqed(self, auth_header, host, req, headers):
+        try:
+            spn = "HTTP@%s" % host
+            authdata = self._negotiate_get_authdata(auth_header, headers)
+            if self.retried > 3:
+                raise urllib.request.HTTPError(
+                    req.get_full_url(),
+                    401,
+                    "Negotiate auth failed",
+                    headers,
+                    None,
+                )
+            else:
+                self.retried += 1
+            neghdr = self._negotiate_get_svctk(spn, authdata)
+            if neghdr is None:
+                return None
+            req.add_unredirected_header("Authorization", neghdr)
+            response = self.parent.open(req)
+            srvauth = self._negotiate_get_authdata(auth_header, response.info())
+            if self._validate_response(srvauth):
+                return response
+        except kerberos.GSSError:
+            return None
+        except Exception:
+            self.reset_retry_count()
+            raise
+        finally:
+            self._clean_context()
+    def reset_retry_count(self):
        self.retried = 0
-      raise
+    def _negotiate_get_authdata(self, auth_header, headers):
+        authhdr = headers.get(auth_header, None)
+        if authhdr is not None:
+            for mech_tuple in authhdr.split(","):
+                mech, __, authdata = mech_tuple.strip().partition(" ")
+                if mech.lower() == "negotiate":
+                    return authdata.strip()
+        return None
-class _KerberosAuthHandler(urllib.request.BaseHandler):
+    def _negotiate_get_svctk(self, spn, authdata):
-  def __init__(self):
+        if authdata is None:
-    self.retried = 0
+            return None
-    self.context = None
-    self.handler_order = urllib.request.BaseHandler.handler_order - 50
-  def http_error_401(self, req, fp, code, msg, headers):
+        result, self.context = kerberos.authGSSClientInit(spn)
-    host = req.get_host()
+        if result < kerberos.AUTH_GSS_COMPLETE:
-    retry = self.http_error_auth_reqed('www-authenticate', host, req, headers)
+            return None
-    return retry
-  def http_error_auth_reqed(self, auth_header, host, req, headers):
+        result = kerberos.authGSSClientStep(self.context, authdata)
-    try:
+        if result < kerberos.AUTH_GSS_CONTINUE:
-      spn = "HTTP@%s" % host
+            return None
-      authdata = self._negotiate_get_authdata(auth_header, headers)
-      if self.retried > 3:
+        response = kerberos.authGSSClientResponse(self.context)
-        raise urllib.request.HTTPError(req.get_full_url(), 401,
+        return "Negotiate %s" % response
-                                       "Negotiate auth failed", headers, None)
-      else:
-        self.retried += 1
-      neghdr = self._negotiate_get_svctk(spn, authdata)
+    def _validate_response(self, authdata):
-      if neghdr is None:
+        if authdata is None:
+            return None
+        result = kerberos.authGSSClientStep(self.context, authdata)
+        if result == kerberos.AUTH_GSS_COMPLETE:
+            return True
        return None
-      req.add_unredirected_header('Authorization', neghdr)
+    def _clean_context(self):
-      response = self.parent.open(req)
+        if self.context is not None:
+            kerberos.authGSSClientClean(self.context)
-      srvauth = self._negotiate_get_authdata(auth_header, response.info())
+            self.context = None
-      if self._validate_response(srvauth):
-        return response
-    except kerberos.GSSError:
-      return None
-    except Exception:
-      self.reset_retry_count()
-      raise
-    finally:
-      self._clean_context()
-  def reset_retry_count(self):
-    self.retried = 0
-  def _negotiate_get_authdata(self, auth_header, headers):
-    authhdr = headers.get(auth_header, None)
-    if authhdr is not None:
-      for mech_tuple in authhdr.split(","):
-        mech, __, authdata = mech_tuple.strip().partition(" ")
-        if mech.lower() == "negotiate":
-          return authdata.strip()
-    return None
-  def _negotiate_get_svctk(self, spn, authdata):
-    if authdata is None:
-      return None
-    result, self.context = kerberos.authGSSClientInit(spn)
-    if result < kerberos.AUTH_GSS_COMPLETE:
-      return None
-    result = kerberos.authGSSClientStep(self.context, authdata)
-    if result < kerberos.AUTH_GSS_CONTINUE:
-      return None
-    response = kerberos.authGSSClientResponse(self.context)
-    return "Negotiate %s" % response
-  def _validate_response(self, authdata):
-    if authdata is None:
-      return None
-    result = kerberos.authGSSClientStep(self.context, authdata)
-    if result == kerberos.AUTH_GSS_COMPLETE:
-      return True
-    return None
-  def _clean_context(self):
-    if self.context is not None:
-      kerberos.authGSSClientClean(self.context)
-      self.context = None
 def init_http():
-  handlers = [_UserAgentHandler()]
+    handlers = [_UserAgentHandler()]
-  mgr = urllib.request.HTTPPasswordMgrWithDefaultRealm()
+    mgr = urllib.request.HTTPPasswordMgrWithDefaultRealm()
-  try:
+    try:
-    n = netrc.netrc()
+        n = netrc.netrc()
-    for host in n.hosts:
+        for host in n.hosts:
-      p = n.hosts[host]
+            p = n.hosts[host]
-      mgr.add_password(p[1], 'http://%s/' % host, p[0], p[2])
+            mgr.add_password(p[1], "http://%s/" % host, p[0], p[2])
-      mgr.add_password(p[1], 'https://%s/' % host, p[0], p[2])
+            mgr.add_password(p[1], "https://%s/" % host, p[0], p[2])
-  except netrc.NetrcParseError:
+    except netrc.NetrcParseError:
-    pass
+        pass
-  except IOError:
+    except IOError:
-    pass
+        pass
-  handlers.append(_BasicAuthHandler(mgr))
+    handlers.append(_BasicAuthHandler(mgr))
-  handlers.append(_DigestAuthHandler(mgr))
+    handlers.append(_DigestAuthHandler(mgr))
-  if kerberos:
+    if kerberos:
-    handlers.append(_KerberosAuthHandler())
+        handlers.append(_KerberosAuthHandler())
-  if 'http_proxy' in os.environ:
+    if "http_proxy" in os.environ:
-    url = os.environ['http_proxy']
+        url = os.environ["http_proxy"]
-    handlers.append(urllib.request.ProxyHandler({'http': url, 'https': url}))
+        handlers.append(
-  if 'REPO_CURL_VERBOSE' in os.environ:
+            urllib.request.ProxyHandler({"http": url, "https": url})
-    handlers.append(urllib.request.HTTPHandler(debuglevel=1))
+        )
-    handlers.append(urllib.request.HTTPSHandler(debuglevel=1))
+    if "REPO_CURL_VERBOSE" in os.environ:
-  urllib.request.install_opener(urllib.request.build_opener(*handlers))
+        handlers.append(urllib.request.HTTPHandler(debuglevel=1))
+        handlers.append(urllib.request.HTTPSHandler(debuglevel=1))
+    urllib.request.install_opener(urllib.request.build_opener(*handlers))
 def _Main(argv):
-  result = 0
+    result = 0
-  opt = optparse.OptionParser(usage="repo wrapperinfo -- ...")
+    opt = optparse.OptionParser(usage="repo wrapperinfo -- ...")
-  opt.add_option("--repo-dir", dest="repodir",
+    opt.add_option("--repo-dir", dest="repodir", help="path to .repo/")
-                 help="path to .repo/")
+    opt.add_option(
-  opt.add_option("--wrapper-version", dest="wrapper_version",
+        "--wrapper-version",
-                 help="version of the wrapper script")
+        dest="wrapper_version",
-  opt.add_option("--wrapper-path", dest="wrapper_path",
+        help="version of the wrapper script",
-                 help="location of the wrapper script")
+    )
-  _PruneOptions(argv, opt)
+    opt.add_option(
-  opt, argv = opt.parse_args(argv)
+        "--wrapper-path",
+        dest="wrapper_path",
-  _CheckWrapperVersion(opt.wrapper_version, opt.wrapper_path)
+        help="location of the wrapper script",
-  _CheckRepoDir(opt.repodir)
+    )
+    _PruneOptions(argv, opt)
-  Version.wrapper_version = opt.wrapper_version
+    opt, argv = opt.parse_args(argv)
-  Version.wrapper_path = opt.wrapper_path
+    _CheckWrapperVersion(opt.wrapper_version, opt.wrapper_path)
-  repo = _Repo(opt.repodir)
+    _CheckRepoDir(opt.repodir)
-  try:
+    Version.wrapper_version = opt.wrapper_version
-    init_http()
+    Version.wrapper_path = opt.wrapper_path
-    name, gopts, argv = repo._ParseArgs(argv)
+    repo = _Repo(opt.repodir)
-    if gopts.trace:
-      SetTrace()
-    if gopts.trace_to_stderr:
-      SetTraceToStderr()
-    result = repo._Run(name, gopts, argv) or 0
-  except KeyboardInterrupt:
-    print('aborted by user', file=sys.stderr)
-    result = 1
-  except ManifestParseError as mpe:
-    print('fatal: %s' % mpe, file=sys.stderr)
-    result = 1
-  except RepoChangedException as rce:
-    # If repo changed, re-exec ourselves.
-    #
-    argv = list(sys.argv)
-    argv.extend(rce.extra_args)
    try:
-      os.execv(sys.executable, [__file__] + argv)
+        init_http()
-    except OSError as e:
+        name, gopts, argv = repo._ParseArgs(argv)
-      print('fatal: cannot restart repo after upgrade', file=sys.stderr)
-      print('fatal: %s' % e, file=sys.stderr)
-      result = 128
-  TerminatePager()
+        if gopts.trace:
-  sys.exit(result)
+            SetTrace()
+        if gopts.trace_to_stderr:
+            SetTraceToStderr()
-if __name__ == '__main__':
+        result = repo._Run(name, gopts, argv) or 0
-  _Main(sys.argv[1:])
+    except KeyboardInterrupt:
+        print("aborted by user", file=sys.stderr)
+        result = 1
+    except ManifestParseError as mpe:
+        print("fatal: %s" % mpe, file=sys.stderr)
+        result = 1
+    except RepoChangedException as rce:
+        # If repo changed, re-exec ourselves.
+        #
+        argv = list(sys.argv)
+        argv.extend(rce.extra_args)
+        try:
+            os.execv(sys.executable, [__file__] + argv)
+        except OSError as e:
+            print("fatal: cannot restart repo after upgrade", file=sys.stderr)
+            print("fatal: %s" % e, file=sys.stderr)
+            result = 128
+    TerminatePager()
+    sys.exit(result)
+if __name__ == "__main__":
+    _Main(sys.argv[1:])
diff --git a/manifest_xml.py b/manifest_xml.py
index 5b83f368..9603906f 100644
--- a/manifest_xml.py
+++ b/manifest_xml.py
@@ -26,415 +26,452 @@ from git_config import GitConfig
 from git_refs import R_HEADS, HEAD
 from git_superproject import Superproject
 import platform_utils
-from project import (Annotation, RemoteSpec, Project, RepoProject,
+from project import (
-                     ManifestProject)
+    Annotation,
-from error import (ManifestParseError, ManifestInvalidPathError,
+    RemoteSpec,
-                   ManifestInvalidRevisionError)
+    Project,
+    RepoProject,
+    ManifestProject,
+)
+from error import (
+    ManifestParseError,
+    ManifestInvalidPathError,
+    ManifestInvalidRevisionError,
+)
 from wrapper import Wrapper
-MANIFEST_FILE_NAME = 'manifest.xml'
+MANIFEST_FILE_NAME = "manifest.xml"
-LOCAL_MANIFEST_NAME = 'local_manifest.xml'
+LOCAL_MANIFEST_NAME = "local_manifest.xml"
-LOCAL_MANIFESTS_DIR_NAME = 'local_manifests'
+LOCAL_MANIFESTS_DIR_NAME = "local_manifests"
-SUBMANIFEST_DIR = 'submanifests'
+SUBMANIFEST_DIR = "submanifests"
 # Limit submanifests to an arbitrary depth for loop detection.
 MAX_SUBMANIFEST_DEPTH = 8
 # Add all projects from sub manifest into a group.
-SUBMANIFEST_GROUP_PREFIX = 'submanifest:'
+SUBMANIFEST_GROUP_PREFIX = "submanifest:"
 # Add all projects from local manifest into a group.
-LOCAL_MANIFEST_GROUP_PREFIX = 'local:'
+LOCAL_MANIFEST_GROUP_PREFIX = "local:"
 # ContactInfo has the self-registered bug url, supplied by the manifest authors.
-ContactInfo = collections.namedtuple('ContactInfo', 'bugurl')
+ContactInfo = collections.namedtuple("ContactInfo", "bugurl")
 # urljoin gets confused if the scheme is not known.
-urllib.parse.uses_relative.extend([
+urllib.parse.uses_relative.extend(
-    'ssh',
+    ["ssh", "git", "persistent-https", "sso", "rpc"]
-    'git',
+)
-    'persistent-https',
+urllib.parse.uses_netloc.extend(
-    'sso',
+    ["ssh", "git", "persistent-https", "sso", "rpc"]
-    'rpc'])
+)
-urllib.parse.uses_netloc.extend([
-    'ssh',
-    'git',
-    'persistent-https',
-    'sso',
-    'rpc'])
 def XmlBool(node, attr, default=None):
-  """Determine boolean value of |node|'s |attr|.
+    """Determine boolean value of |node|'s |attr|.
-  Invalid values will issue a non-fatal warning.
+    Invalid values will issue a non-fatal warning.
-  Args:
+    Args:
-    node: XML node whose attributes we access.
+        node: XML node whose attributes we access.
-    attr: The attribute to access.
+        attr: The attribute to access.
-    default: If the attribute is not set (value is empty), then use this.
+        default: If the attribute is not set (value is empty), then use this.
-  Returns:
+    Returns:
-    True if the attribute is a valid string representing true.
+        True if the attribute is a valid string representing true.
-    False if the attribute is a valid string representing false.
+        False if the attribute is a valid string representing false.
-    |default| otherwise.
+        |default| otherwise.
-  """
+    """
-  value = node.getAttribute(attr)
+    value = node.getAttribute(attr)
-  s = value.lower()
+    s = value.lower()
-  if s == '':
+    if s == "":
-    return default
+        return default
-  elif s in {'yes', 'true', '1'}:
+    elif s in {"yes", "true", "1"}:
-    return True
+        return True
-  elif s in {'no', 'false', '0'}:
+    elif s in {"no", "false", "0"}:
-    return False
+        return False
-  else:
+    else:
-    print('warning: manifest: %s="%s": ignoring invalid XML boolean' %
+        print(
-          (attr, value), file=sys.stderr)
+            'warning: manifest: %s="%s": ignoring invalid XML boolean'
-    return default
+            % (attr, value),
+            file=sys.stderr,
+        )
+        return default
 def XmlInt(node, attr, default=None):
-  """Determine integer value of |node|'s |attr|.
+    """Determine integer value of |node|'s |attr|.
-  Args:
+    Args:
-    node: XML node whose attributes we access.
+        node: XML node whose attributes we access.
-    attr: The attribute to access.
+        attr: The attribute to access.
-    default: If the attribute is not set (value is empty), then use this.
+        default: If the attribute is not set (value is empty), then use this.
-  Returns:
+    Returns:
-    The number if the attribute is a valid number.
+        The number if the attribute is a valid number.
-  Raises:
+    Raises:
-    ManifestParseError: The number is invalid.
+        ManifestParseError: The number is invalid.
-  """
+    """
-  value = node.getAttribute(attr)
+    value = node.getAttribute(attr)
-  if not value:
+    if not value:
-    return default
+        return default
-  try:
+    try:
-    return int(value)
+        return int(value)
-  except ValueError:
+    except ValueError:
-    raise ManifestParseError('manifest: invalid %s="%s" integer' %
+        raise ManifestParseError(
-                             (attr, value))
+            'manifest: invalid %s="%s" integer' % (attr, value)
+        )
 class _Default(object):
-  """Project defaults within the manifest."""
+    """Project defaults within the manifest."""
-  revisionExpr = None
+    revisionExpr = None
-  destBranchExpr = None
+    destBranchExpr = None
-  upstreamExpr = None
+    upstreamExpr = None
-  remote = None
+    remote = None
-  sync_j = None
+    sync_j = None
-  sync_c = False
+    sync_c = False
-  sync_s = False
+    sync_s = False
-  sync_tags = True
+    sync_tags = True
-  def __eq__(self, other):
+    def __eq__(self, other):
-    if not isinstance(other, _Default):
+        if not isinstance(other, _Default):
-      return False
+            return False
-    return self.__dict__ == other.__dict__
+        return self.__dict__ == other.__dict__
-  def __ne__(self, other):
+    def __ne__(self, other):
-    if not isinstance(other, _Default):
+        if not isinstance(other, _Default):
-      return True
+            return True
-    return self.__dict__ != other.__dict__
+        return self.__dict__ != other.__dict__
 class _XmlRemote(object):
-  def __init__(self,
+    def __init__(
-               name,
+        self,
-               alias=None,
+        name,
-               fetch=None,
+        alias=None,
-               pushUrl=None,
+        fetch=None,
-               manifestUrl=None,
+        pushUrl=None,
-               review=None,
+        manifestUrl=None,
-               revision=None):
+        review=None,
-    self.name = name
+        revision=None,
-    self.fetchUrl = fetch
+    ):
-    self.pushUrl = pushUrl
+        self.name = name
-    self.manifestUrl = manifestUrl
+        self.fetchUrl = fetch
-    self.remoteAlias = alias
+        self.pushUrl = pushUrl
-    self.reviewUrl = review
+        self.manifestUrl = manifestUrl
-    self.revision = revision
+        self.remoteAlias = alias
-    self.resolvedFetchUrl = self._resolveFetchUrl()
+        self.reviewUrl = review
-    self.annotations = []
+        self.revision = revision
+        self.resolvedFetchUrl = self._resolveFetchUrl()
-  def __eq__(self, other):
+        self.annotations = []
-    if not isinstance(other, _XmlRemote):
-      return False
+    def __eq__(self, other):
-    return (sorted(self.annotations) == sorted(other.annotations) and
+        if not isinstance(other, _XmlRemote):
-      self.name == other.name and self.fetchUrl == other.fetchUrl and
+            return False
-      self.pushUrl == other.pushUrl and self.remoteAlias == other.remoteAlias
+        return (
-      and self.reviewUrl == other.reviewUrl and self.revision == other.revision)
+            sorted(self.annotations) == sorted(other.annotations)
+            and self.name == other.name
-  def __ne__(self, other):
+            and self.fetchUrl == other.fetchUrl
-    return not self.__eq__(other)
+            and self.pushUrl == other.pushUrl
+            and self.remoteAlias == other.remoteAlias
-  def _resolveFetchUrl(self):
+            and self.reviewUrl == other.reviewUrl
-    if self.fetchUrl is None:
+            and self.revision == other.revision
-      return ''
+        )
-    url = self.fetchUrl.rstrip('/')
-    manifestUrl = self.manifestUrl.rstrip('/')
+    def __ne__(self, other):
-    # urljoin will gets confused over quite a few things.  The ones we care
+        return not self.__eq__(other)
-    # about here are:
-    # * no scheme in the base url, like <hostname:port>
+    def _resolveFetchUrl(self):
-    # We handle no scheme by replacing it with an obscure protocol, gopher
+        if self.fetchUrl is None:
-    # and then replacing it with the original when we are done.
+            return ""
+        url = self.fetchUrl.rstrip("/")
-    if manifestUrl.find(':') != manifestUrl.find('/') - 1:
+        manifestUrl = self.manifestUrl.rstrip("/")
-      url = urllib.parse.urljoin('gopher://' + manifestUrl, url)
+        # urljoin will gets confused over quite a few things.  The ones we care
-      url = re.sub(r'^gopher://', '', url)
+        # about here are:
-    else:
+        # * no scheme in the base url, like <hostname:port>
-      url = urllib.parse.urljoin(manifestUrl, url)
+        # We handle no scheme by replacing it with an obscure protocol, gopher
-    return url
+        # and then replacing it with the original when we are done.
-  def ToRemoteSpec(self, projectName):
+        if manifestUrl.find(":") != manifestUrl.find("/") - 1:
-    fetchUrl = self.resolvedFetchUrl.rstrip('/')
+            url = urllib.parse.urljoin("gopher://" + manifestUrl, url)
-    url = fetchUrl + '/' + projectName
+            url = re.sub(r"^gopher://", "", url)
-    remoteName = self.name
+        else:
-    if self.remoteAlias:
+            url = urllib.parse.urljoin(manifestUrl, url)
-      remoteName = self.remoteAlias
+        return url
-    return RemoteSpec(remoteName,
-                      url=url,
+    def ToRemoteSpec(self, projectName):
-                      pushUrl=self.pushUrl,
+        fetchUrl = self.resolvedFetchUrl.rstrip("/")
-                      review=self.reviewUrl,
+        url = fetchUrl + "/" + projectName
-                      orig_name=self.name,
+        remoteName = self.name
-                      fetchUrl=self.fetchUrl)
+        if self.remoteAlias:
+            remoteName = self.remoteAlias
-  def AddAnnotation(self, name, value, keep):
+        return RemoteSpec(
-    self.annotations.append(Annotation(name, value, keep))
+            remoteName,
+            url=url,
+            pushUrl=self.pushUrl,
+            review=self.reviewUrl,
+            orig_name=self.name,
+            fetchUrl=self.fetchUrl,
+        )
+    def AddAnnotation(self, name, value, keep):
+        self.annotations.append(Annotation(name, value, keep))
 class _XmlSubmanifest:
-  """Manage the <submanifest> element specified in the manifest.
+    """Manage the <submanifest> element specified in the manifest.
-  Attributes:
+    Attributes:
-    name: a string, the name for this submanifest.
+      name: a string, the name for this submanifest.
-    remote: a string, the remote.name for this submanifest.
+      remote: a string, the remote.name for this submanifest.
-    project: a string, the name of the manifest project.
+      project: a string, the name of the manifest project.
-    revision: a string, the commitish.
+      revision: a string, the commitish.
-    manifestName: a string, the submanifest file name.
+      manifestName: a string, the submanifest file name.
-    groups: a list of strings, the groups to add to all projects in the submanifest.
+      groups: a list of strings, the groups to add to all projects in the
-    default_groups: a list of strings, the default groups to sync.
+          submanifest.
-    path: a string, the relative path for the submanifest checkout.
+      default_groups: a list of strings, the default groups to sync.
-    parent: an XmlManifest, the parent manifest.
+      path: a string, the relative path for the submanifest checkout.
-    annotations: (derived) a list of annotations.
+      parent: an XmlManifest, the parent manifest.
-    present: (derived) a boolean, whether the sub manifest file is present.
+      annotations: (derived) a list of annotations.
-  """
+      present: (derived) a boolean, whether the sub manifest file is present.
-  def __init__(self,
+    """
-               name,
-               remote=None,
-               project=None,
-               revision=None,
-               manifestName=None,
-               groups=None,
-               default_groups=None,
-               path=None,
-               parent=None):
-    self.name = name
-    self.remote = remote
-    self.project = project
-    self.revision = revision
-    self.manifestName = manifestName
-    self.groups = groups
-    self.default_groups = default_groups
-    self.path = path
-    self.parent = parent
-    self.annotations = []
-    outer_client = parent._outer_client or parent
-    if self.remote and not self.project:
-      raise ManifestParseError(
-          f'Submanifest {name}: must specify project when remote is given.')
-    # Construct the absolute path to the manifest file using the parent's
-    # method, so that we can correctly create our repo_client.
-    manifestFile = parent.SubmanifestInfoDir(
-        os.path.join(parent.path_prefix, self.relpath),
-        os.path.join('manifests', manifestName or 'default.xml'))
-    linkFile = parent.SubmanifestInfoDir(
-        os.path.join(parent.path_prefix, self.relpath), MANIFEST_FILE_NAME)
-    rc = self.repo_client = RepoClient(
-        parent.repodir, linkFile, parent_groups=','.join(groups) or '',
-        submanifest_path=self.relpath, outer_client=outer_client,
-        default_groups=default_groups)
-    self.present = os.path.exists(manifestFile)
-  def __eq__(self, other):
-    if not isinstance(other, _XmlSubmanifest):
-      return False
-    return (
-        self.name == other.name and
-        self.remote == other.remote and
-        self.project == other.project and
-        self.revision == other.revision and
-        self.manifestName == other.manifestName and
-        self.groups == other.groups and
-        self.default_groups == other.default_groups and
-        self.path == other.path and
-        sorted(self.annotations) == sorted(other.annotations))
-  def __ne__(self, other):
-    return not self.__eq__(other)
-  def ToSubmanifestSpec(self):
-    """Return a SubmanifestSpec object, populating attributes"""
-    mp = self.parent.manifestProject
-    remote = self.parent.remotes[self.remote or self.parent.default.remote.name]
-    # If a project was given, generate the url from the remote and project.
-    # If not, use this manifestProject's url.
-    if self.project:
-      manifestUrl = remote.ToRemoteSpec(self.project).url
-    else:
-      manifestUrl = mp.GetRemote().url
-    manifestName = self.manifestName or 'default.xml'
-    revision = self.revision or self.name
-    path = self.path or revision.split('/')[-1]
-    groups = self.groups or []
-    default_groups = self.default_groups or []
-    return SubmanifestSpec(self.name, manifestUrl, manifestName, revision, path,
+    def __init__(
-                           groups)
+        self,
+        name,
+        remote=None,
+        project=None,
+        revision=None,
+        manifestName=None,
+        groups=None,
+        default_groups=None,
+        path=None,
+        parent=None,
+    ):
+        self.name = name
+        self.remote = remote
+        self.project = project
+        self.revision = revision
+        self.manifestName = manifestName
+        self.groups = groups
+        self.default_groups = default_groups
+        self.path = path
+        self.parent = parent
+        self.annotations = []
+        outer_client = parent._outer_client or parent
+        if self.remote and not self.project:
+            raise ManifestParseError(
+                f"Submanifest {name}: must specify project when remote is "
+                "given."
+            )
+        # Construct the absolute path to the manifest file using the parent's
+        # method, so that we can correctly create our repo_client.
+        manifestFile = parent.SubmanifestInfoDir(
+            os.path.join(parent.path_prefix, self.relpath),
+            os.path.join("manifests", manifestName or "default.xml"),
+        )
+        linkFile = parent.SubmanifestInfoDir(
+            os.path.join(parent.path_prefix, self.relpath), MANIFEST_FILE_NAME
+        )
+        self.repo_client = RepoClient(
+            parent.repodir,
+            linkFile,
+            parent_groups=",".join(groups) or "",
+            submanifest_path=self.relpath,
+            outer_client=outer_client,
+            default_groups=default_groups,
+        )
+        self.present = os.path.exists(manifestFile)
+    def __eq__(self, other):
+        if not isinstance(other, _XmlSubmanifest):
+            return False
+        return (
+            self.name == other.name
+            and self.remote == other.remote
+            and self.project == other.project
+            and self.revision == other.revision
+            and self.manifestName == other.manifestName
+            and self.groups == other.groups
+            and self.default_groups == other.default_groups
+            and self.path == other.path
+            and sorted(self.annotations) == sorted(other.annotations)
+        )
+    def __ne__(self, other):
+        return not self.__eq__(other)
+    def ToSubmanifestSpec(self):
+        """Return a SubmanifestSpec object, populating attributes"""
+        mp = self.parent.manifestProject
+        remote = self.parent.remotes[
+            self.remote or self.parent.default.remote.name
+        ]
+        # If a project was given, generate the url from the remote and project.
+        # If not, use this manifestProject's url.
+        if self.project:
+            manifestUrl = remote.ToRemoteSpec(self.project).url
+        else:
+            manifestUrl = mp.GetRemote().url
+        manifestName = self.manifestName or "default.xml"
+        revision = self.revision or self.name
+        path = self.path or revision.split("/")[-1]
+        groups = self.groups or []
-  @property
+        return SubmanifestSpec(
-  def relpath(self):
+            self.name, manifestUrl, manifestName, revision, path, groups
-    """The path of this submanifest relative to the parent manifest."""
+        )
-    revision = self.revision or self.name
-    return self.path or revision.split('/')[-1]
-  def GetGroupsStr(self):
+    @property
-    """Returns the `groups` given for this submanifest."""
+    def relpath(self):
-    if self.groups:
+        """The path of this submanifest relative to the parent manifest."""
-      return ','.join(self.groups)
+        revision = self.revision or self.name
-    return ''
+        return self.path or revision.split("/")[-1]
-  def GetDefaultGroupsStr(self):
+    def GetGroupsStr(self):
-    """Returns the `default-groups` given for this submanifest."""
+        """Returns the `groups` given for this submanifest."""
-    return ','.join(self.default_groups or [])
+        if self.groups:
+            return ",".join(self.groups)
+        return ""
-  def AddAnnotation(self, name, value, keep):
+    def GetDefaultGroupsStr(self):
-    """Add annotations to the submanifest."""
+        """Returns the `default-groups` given for this submanifest."""
-    self.annotations.append(Annotation(name, value, keep))
+        return ",".join(self.default_groups or [])
+    def AddAnnotation(self, name, value, keep):
+        """Add annotations to the submanifest."""
+        self.annotations.append(Annotation(name, value, keep))
-class SubmanifestSpec:
-  """The submanifest element, with all fields expanded."""
-  def __init__(self,
-               name,
-               manifestUrl,
-               manifestName,
-               revision,
-               path,
-               groups):
-    self.name = name
-    self.manifestUrl = manifestUrl
-    self.manifestName = manifestName
-    self.revision = revision
-    self.path = path
-    self.groups = groups or []
+class SubmanifestSpec:
+    """The submanifest element, with all fields expanded."""
-class XmlManifest(object):
+    def __init__(self, name, manifestUrl, manifestName, revision, path, groups):
-  """manages the repo configuration file"""
+        self.name = name
+        self.manifestUrl = manifestUrl
+        self.manifestName = manifestName
+        self.revision = revision
+        self.path = path
+        self.groups = groups or []
-  def __init__(self, repodir, manifest_file, local_manifests=None,
-               outer_client=None, parent_groups='', submanifest_path='',
-               default_groups=None):
-    """Initialize.
-    Args:
+class XmlManifest(object):
-      repodir: Path to the .repo/ dir for holding all internal checkout state.
+    """manages the repo configuration file"""
-          It must be in the top directory of the repo client checkout.
-      manifest_file: Full path to the manifest file to parse.  This will usually
+    def __init__(
-          be |repodir|/|MANIFEST_FILE_NAME|.
+        self,
-      local_manifests: Full path to the directory of local override manifests.
+        repodir,
-          This will usually be |repodir|/|LOCAL_MANIFESTS_DIR_NAME|.
+        manifest_file,
-      outer_client: RepoClient of the outer manifest.
+        local_manifests=None,
-      parent_groups: a string, the groups to apply to this projects.
+        outer_client=None,
-      submanifest_path: The submanifest root relative to the repo root.
+        parent_groups="",
-      default_groups: a string, the default manifest groups to use.
+        submanifest_path="",
-    """
+        default_groups=None,
-    # TODO(vapier): Move this out of this class.
+    ):
-    self.globalConfig = GitConfig.ForUser()
+        """Initialize.
-    self.repodir = os.path.abspath(repodir)
+        Args:
-    self._CheckLocalPath(submanifest_path)
+            repodir: Path to the .repo/ dir for holding all internal checkout
-    self.topdir = os.path.dirname(self.repodir)
+                state. It must be in the top directory of the repo client
-    if submanifest_path:
+                checkout.
-      # This avoids a trailing os.path.sep when submanifest_path is empty.
+            manifest_file: Full path to the manifest file to parse.  This will
-      self.topdir = os.path.join(self.topdir, submanifest_path)
+                usually be |repodir|/|MANIFEST_FILE_NAME|.
-    if manifest_file != os.path.abspath(manifest_file):
+            local_manifests: Full path to the directory of local override
-      raise ManifestParseError('manifest_file must be abspath')
+                manifests. This will usually be
-    self.manifestFile = manifest_file
+                |repodir|/|LOCAL_MANIFESTS_DIR_NAME|.
-    if not outer_client or outer_client == self:
+            outer_client: RepoClient of the outer manifest.
-      # manifestFileOverrides only exists in the outer_client's manifest, since
+            parent_groups: a string, the groups to apply to this projects.
-      # that is the only instance left when Unload() is called on the outer
+            submanifest_path: The submanifest root relative to the repo root.
-      # manifest.
+            default_groups: a string, the default manifest groups to use.
-      self.manifestFileOverrides = {}
+        """
-    self.local_manifests = local_manifests
+        # TODO(vapier): Move this out of this class.
-    self._load_local_manifests = True
+        self.globalConfig = GitConfig.ForUser()
-    self.parent_groups = parent_groups
-    self.default_groups = default_groups
+        self.repodir = os.path.abspath(repodir)
+        self._CheckLocalPath(submanifest_path)
-    if outer_client and self.isGitcClient:
+        self.topdir = os.path.dirname(self.repodir)
-      raise ManifestParseError('Multi-manifest is incompatible with `gitc-init`')
+        if submanifest_path:
+            # This avoids a trailing os.path.sep when submanifest_path is empty.
-    if submanifest_path and not outer_client:
+            self.topdir = os.path.join(self.topdir, submanifest_path)
-      # If passing a submanifest_path, there must be an outer_client.
+        if manifest_file != os.path.abspath(manifest_file):
-      raise ManifestParseError(f'Bad call to {self.__class__.__name__}')
+            raise ManifestParseError("manifest_file must be abspath")
+        self.manifestFile = manifest_file
-    # If self._outer_client is None, this is not a checkout that supports
+        if not outer_client or outer_client == self:
-    # multi-tree.
+            # manifestFileOverrides only exists in the outer_client's manifest,
-    self._outer_client = outer_client or self
+            # since that is the only instance left when Unload() is called on
+            # the outer manifest.
-    self.repoProject = RepoProject(self, 'repo',
+            self.manifestFileOverrides = {}
-                                   gitdir=os.path.join(repodir, 'repo/.git'),
+        self.local_manifests = local_manifests
-                                   worktree=os.path.join(repodir, 'repo'))
+        self._load_local_manifests = True
+        self.parent_groups = parent_groups
-    mp = self.SubmanifestProject(self.path_prefix)
+        self.default_groups = default_groups
-    self.manifestProject = mp
+        if outer_client and self.isGitcClient:
-    # This is a bit hacky, but we're in a chicken & egg situation: all the
+            raise ManifestParseError(
-    # normal repo settings live in the manifestProject which we just setup
+                "Multi-manifest is incompatible with `gitc-init`"
-    # above, so we couldn't easily query before that.  We assume Project()
+            )
-    # init doesn't care if this changes afterwards.
-    if os.path.exists(mp.gitdir) and mp.use_worktree:
+        if submanifest_path and not outer_client:
-      mp.use_git_worktrees = True
+            # If passing a submanifest_path, there must be an outer_client.
+            raise ManifestParseError(f"Bad call to {self.__class__.__name__}")
-    self.Unload()
+        # If self._outer_client is None, this is not a checkout that supports
-  def Override(self, name, load_local_manifests=True):
+        # multi-tree.
-    """Use a different manifest, just for the current instantiation.
+        self._outer_client = outer_client or self
-    """
-    path = None
+        self.repoProject = RepoProject(
+            self,
-    # Look for a manifest by path in the filesystem (including the cwd).
+            "repo",
-    if not load_local_manifests:
+            gitdir=os.path.join(repodir, "repo/.git"),
-      local_path = os.path.abspath(name)
+            worktree=os.path.join(repodir, "repo"),
-      if os.path.isfile(local_path):
+        )
-        path = local_path
+        mp = self.SubmanifestProject(self.path_prefix)
-    # Look for manifests by name from the manifests repo.
+        self.manifestProject = mp
-    if path is None:
-      path = os.path.join(self.manifestProject.worktree, name)
+        # This is a bit hacky, but we're in a chicken & egg situation: all the
-      if not os.path.isfile(path):
+        # normal repo settings live in the manifestProject which we just setup
-        raise ManifestParseError('manifest %s not found' % name)
+        # above, so we couldn't easily query before that.  We assume Project()
+        # init doesn't care if this changes afterwards.
-    self._load_local_manifests = load_local_manifests
+        if os.path.exists(mp.gitdir) and mp.use_worktree:
-    self._outer_client.manifestFileOverrides[self.path_prefix] = path
+            mp.use_git_worktrees = True
-    self.Unload()
-    self._Load()
+        self.Unload()
-  def Link(self, name):
+    def Override(self, name, load_local_manifests=True):
-    """Update the repo metadata to use a different manifest.
+        """Use a different manifest, just for the current instantiation."""
-    """
+        path = None
-    self.Override(name)
+        # Look for a manifest by path in the filesystem (including the cwd).
-    # Old versions of repo would generate symlinks we need to clean up.
+        if not load_local_manifests:
-    platform_utils.remove(self.manifestFile, missing_ok=True)
+            local_path = os.path.abspath(name)
-    # This file is interpreted as if it existed inside the manifest repo.
+            if os.path.isfile(local_path):
-    # That allows us to use <include> with the relative file name.
+                path = local_path
-    with open(self.manifestFile, 'w') as fp:
-      fp.write("""<?xml version="1.0" encoding="UTF-8"?>
+        # Look for manifests by name from the manifests repo.
+        if path is None:
+            path = os.path.join(self.manifestProject.worktree, name)
+            if not os.path.isfile(path):
+                raise ManifestParseError("manifest %s not found" % name)
+        self._load_local_manifests = load_local_manifests
+        self._outer_client.manifestFileOverrides[self.path_prefix] = path
+        self.Unload()
+        self._Load()
+    def Link(self, name):
+        """Update the repo metadata to use a different manifest."""
+        self.Override(name)
+        # Old versions of repo would generate symlinks we need to clean up.
+        platform_utils.remove(self.manifestFile, missing_ok=True)
+        # This file is interpreted as if it existed inside the manifest repo.
+        # That allows us to use <include> with the relative file name.
+        with open(self.manifestFile, "w") as fp:
+            fp.write(
+                """<?xml version="1.0" encoding="UTF-8"?>
 <!--
 DO NOT EDIT THIS FILE!  It is generated by repo and changes will be discarded.
 If you want to use a different manifest, use `repo init -m <file>` instead.
@@ -448,1591 +485,1803 @@ https://gerrit.googlesource.com/git-repo/+/HEAD/docs/manifest-format.md
 <manifest>
  <include name="%s" />
 </manifest>
-""" % (name,))
+"""
+                % (name,)
-  def _RemoteToXml(self, r, doc, root):
+            )
-    e = doc.createElement('remote')
-    root.appendChild(e)
+    def _RemoteToXml(self, r, doc, root):
-    e.setAttribute('name', r.name)
+        e = doc.createElement("remote")
-    e.setAttribute('fetch', r.fetchUrl)
+        root.appendChild(e)
-    if r.pushUrl is not None:
+        e.setAttribute("name", r.name)
-      e.setAttribute('pushurl', r.pushUrl)
+        e.setAttribute("fetch", r.fetchUrl)
-    if r.remoteAlias is not None:
+        if r.pushUrl is not None:
-      e.setAttribute('alias', r.remoteAlias)
+            e.setAttribute("pushurl", r.pushUrl)
-    if r.reviewUrl is not None:
+        if r.remoteAlias is not None:
-      e.setAttribute('review', r.reviewUrl)
+            e.setAttribute("alias", r.remoteAlias)
-    if r.revision is not None:
+        if r.reviewUrl is not None:
-      e.setAttribute('revision', r.revision)
+            e.setAttribute("review", r.reviewUrl)
+        if r.revision is not None:
-    for a in r.annotations:
+            e.setAttribute("revision", r.revision)
-      if a.keep == 'true':
-        ae = doc.createElement('annotation')
+        for a in r.annotations:
-        ae.setAttribute('name', a.name)
+            if a.keep == "true":
-        ae.setAttribute('value', a.value)
+                ae = doc.createElement("annotation")
-        e.appendChild(ae)
+                ae.setAttribute("name", a.name)
+                ae.setAttribute("value", a.value)
-  def _SubmanifestToXml(self, r, doc, root):
+                e.appendChild(ae)
-    """Generate XML <submanifest/> node."""
-    e = doc.createElement('submanifest')
+    def _SubmanifestToXml(self, r, doc, root):
-    root.appendChild(e)
+        """Generate XML <submanifest/> node."""
-    e.setAttribute('name', r.name)
+        e = doc.createElement("submanifest")
-    if r.remote is not None:
+        root.appendChild(e)
-      e.setAttribute('remote', r.remote)
+        e.setAttribute("name", r.name)
-    if r.project is not None:
+        if r.remote is not None:
-      e.setAttribute('project', r.project)
+            e.setAttribute("remote", r.remote)
-    if r.manifestName is not None:
+        if r.project is not None:
-      e.setAttribute('manifest-name', r.manifestName)
+            e.setAttribute("project", r.project)
-    if r.revision is not None:
+        if r.manifestName is not None:
-      e.setAttribute('revision', r.revision)
+            e.setAttribute("manifest-name", r.manifestName)
-    if r.path is not None:
+        if r.revision is not None:
-      e.setAttribute('path', r.path)
+            e.setAttribute("revision", r.revision)
-    if r.groups:
+        if r.path is not None:
-      e.setAttribute('groups', r.GetGroupsStr())
+            e.setAttribute("path", r.path)
-    if r.default_groups:
+        if r.groups:
-      e.setAttribute('default-groups', r.GetDefaultGroupsStr())
+            e.setAttribute("groups", r.GetGroupsStr())
+        if r.default_groups:
-    for a in r.annotations:
+            e.setAttribute("default-groups", r.GetDefaultGroupsStr())
-      if a.keep == 'true':
-        ae = doc.createElement('annotation')
+        for a in r.annotations:
-        ae.setAttribute('name', a.name)
+            if a.keep == "true":
-        ae.setAttribute('value', a.value)
+                ae = doc.createElement("annotation")
-        e.appendChild(ae)
+                ae.setAttribute("name", a.name)
+                ae.setAttribute("value", a.value)
-  def _ParseList(self, field):
+                e.appendChild(ae)
-    """Parse fields that contain flattened lists.
+    def _ParseList(self, field):
-    These are whitespace & comma separated.  Empty elements will be discarded.
+        """Parse fields that contain flattened lists.
-    """
-    return [x for x in re.split(r'[,\s]+', field) if x]
+        These are whitespace & comma separated.  Empty elements will be
+        discarded.
-  def ToXml(self, peg_rev=False, peg_rev_upstream=True,
+        """
-            peg_rev_dest_branch=True, groups=None, omit_local=False):
+        return [x for x in re.split(r"[,\s]+", field) if x]
-    """Return the current manifest XML."""
-    mp = self.manifestProject
+    def ToXml(
+        self,
-    if groups is None:
+        peg_rev=False,
-      groups = mp.manifest_groups
+        peg_rev_upstream=True,
-    if groups:
+        peg_rev_dest_branch=True,
-      groups = self._ParseList(groups)
+        groups=None,
+        omit_local=False,
-    doc = xml.dom.minidom.Document()
+    ):
-    root = doc.createElement('manifest')
+        """Return the current manifest XML."""
-    if self.is_submanifest:
+        mp = self.manifestProject
-      root.setAttribute('path', self.path_prefix)
-    doc.appendChild(root)
+        if groups is None:
+            groups = mp.manifest_groups
-    # Save out the notice.  There's a little bit of work here to give it the
+        if groups:
-    # right whitespace, which assumes that the notice is automatically indented
+            groups = self._ParseList(groups)
-    # by 4 by minidom.
-    if self.notice:
+        doc = xml.dom.minidom.Document()
-      notice_element = root.appendChild(doc.createElement('notice'))
+        root = doc.createElement("manifest")
-      notice_lines = self.notice.splitlines()
+        if self.is_submanifest:
-      indented_notice = ('\n'.join(" " * 4 + line for line in notice_lines))[4:]
+            root.setAttribute("path", self.path_prefix)
-      notice_element.appendChild(doc.createTextNode(indented_notice))
+        doc.appendChild(root)
-    d = self.default
+        # Save out the notice.  There's a little bit of work here to give it the
+        # right whitespace, which assumes that the notice is automatically
-    for r in sorted(self.remotes):
+        # indented by 4 by minidom.
-      self._RemoteToXml(self.remotes[r], doc, root)
+        if self.notice:
-    if self.remotes:
+            notice_element = root.appendChild(doc.createElement("notice"))
-      root.appendChild(doc.createTextNode(''))
+            notice_lines = self.notice.splitlines()
+            indented_notice = (
-    have_default = False
+                "\n".join(" " * 4 + line for line in notice_lines)
-    e = doc.createElement('default')
+            )[4:]
-    if d.remote:
+            notice_element.appendChild(doc.createTextNode(indented_notice))
-      have_default = True
-      e.setAttribute('remote', d.remote.name)
+        d = self.default
-    if d.revisionExpr:
-      have_default = True
+        for r in sorted(self.remotes):
-      e.setAttribute('revision', d.revisionExpr)
+            self._RemoteToXml(self.remotes[r], doc, root)
-    if d.destBranchExpr:
+        if self.remotes:
-      have_default = True
+            root.appendChild(doc.createTextNode(""))
-      e.setAttribute('dest-branch', d.destBranchExpr)
-    if d.upstreamExpr:
+        have_default = False
-      have_default = True
+        e = doc.createElement("default")
-      e.setAttribute('upstream', d.upstreamExpr)
+        if d.remote:
-    if d.sync_j is not None:
+            have_default = True
-      have_default = True
+            e.setAttribute("remote", d.remote.name)
-      e.setAttribute('sync-j', '%d' % d.sync_j)
+        if d.revisionExpr:
-    if d.sync_c:
+            have_default = True
-      have_default = True
+            e.setAttribute("revision", d.revisionExpr)
-      e.setAttribute('sync-c', 'true')
+        if d.destBranchExpr:
-    if d.sync_s:
+            have_default = True
-      have_default = True
+            e.setAttribute("dest-branch", d.destBranchExpr)
-      e.setAttribute('sync-s', 'true')
+        if d.upstreamExpr:
-    if not d.sync_tags:
+            have_default = True
-      have_default = True
+            e.setAttribute("upstream", d.upstreamExpr)
-      e.setAttribute('sync-tags', 'false')
+        if d.sync_j is not None:
-    if have_default:
+            have_default = True
-      root.appendChild(e)
+            e.setAttribute("sync-j", "%d" % d.sync_j)
-      root.appendChild(doc.createTextNode(''))
+        if d.sync_c:
+            have_default = True
-    if self._manifest_server:
+            e.setAttribute("sync-c", "true")
-      e = doc.createElement('manifest-server')
+        if d.sync_s:
-      e.setAttribute('url', self._manifest_server)
+            have_default = True
-      root.appendChild(e)
+            e.setAttribute("sync-s", "true")
-      root.appendChild(doc.createTextNode(''))
+        if not d.sync_tags:
+            have_default = True
-    for r in sorted(self.submanifests):
+            e.setAttribute("sync-tags", "false")
-      self._SubmanifestToXml(self.submanifests[r], doc, root)
+        if have_default:
-    if self.submanifests:
+            root.appendChild(e)
-      root.appendChild(doc.createTextNode(''))
+            root.appendChild(doc.createTextNode(""))
-    def output_projects(parent, parent_node, projects):
+        if self._manifest_server:
-      for project_name in projects:
+            e = doc.createElement("manifest-server")
-        for project in self._projects[project_name]:
+            e.setAttribute("url", self._manifest_server)
-          output_project(parent, parent_node, project)
+            root.appendChild(e)
+            root.appendChild(doc.createTextNode(""))
-    def output_project(parent, parent_node, p):
-      if not p.MatchesGroups(groups):
+        for r in sorted(self.submanifests):
-        return
+            self._SubmanifestToXml(self.submanifests[r], doc, root)
+        if self.submanifests:
-      if omit_local and self.IsFromLocalManifest(p):
+            root.appendChild(doc.createTextNode(""))
-        return
+        def output_projects(parent, parent_node, projects):
-      name = p.name
+            for project_name in projects:
-      relpath = p.relpath
+                for project in self._projects[project_name]:
-      if parent:
+                    output_project(parent, parent_node, project)
-        name = self._UnjoinName(parent.name, name)
-        relpath = self._UnjoinRelpath(parent.relpath, relpath)
+        def output_project(parent, parent_node, p):
+            if not p.MatchesGroups(groups):
-      e = doc.createElement('project')
+                return
-      parent_node.appendChild(e)
-      e.setAttribute('name', name)
+            if omit_local and self.IsFromLocalManifest(p):
-      if relpath != name:
+                return
-        e.setAttribute('path', relpath)
-      remoteName = None
+            name = p.name
-      if d.remote:
+            relpath = p.relpath
-        remoteName = d.remote.name
+            if parent:
-      if not d.remote or p.remote.orig_name != remoteName:
+                name = self._UnjoinName(parent.name, name)
-        remoteName = p.remote.orig_name
+                relpath = self._UnjoinRelpath(parent.relpath, relpath)
-        e.setAttribute('remote', remoteName)
-      if peg_rev:
+            e = doc.createElement("project")
-        if self.IsMirror:
+            parent_node.appendChild(e)
-          value = p.bare_git.rev_parse(p.revisionExpr + '^0')
+            e.setAttribute("name", name)
-        else:
+            if relpath != name:
-          value = p.work_git.rev_parse(HEAD + '^0')
+                e.setAttribute("path", relpath)
-        e.setAttribute('revision', value)
+            remoteName = None
-        if peg_rev_upstream:
+            if d.remote:
-          if p.upstream:
+                remoteName = d.remote.name
-            e.setAttribute('upstream', p.upstream)
+            if not d.remote or p.remote.orig_name != remoteName:
-          elif value != p.revisionExpr:
+                remoteName = p.remote.orig_name
-            # Only save the origin if the origin is not a sha1, and the default
+                e.setAttribute("remote", remoteName)
-            # isn't our value
+            if peg_rev:
-            e.setAttribute('upstream', p.revisionExpr)
+                if self.IsMirror:
+                    value = p.bare_git.rev_parse(p.revisionExpr + "^0")
-        if peg_rev_dest_branch:
+                else:
-          if p.dest_branch:
+                    value = p.work_git.rev_parse(HEAD + "^0")
-            e.setAttribute('dest-branch', p.dest_branch)
+                e.setAttribute("revision", value)
-          elif value != p.revisionExpr:
+                if peg_rev_upstream:
-            e.setAttribute('dest-branch', p.revisionExpr)
+                    if p.upstream:
+                        e.setAttribute("upstream", p.upstream)
-      else:
+                    elif value != p.revisionExpr:
-        revision = self.remotes[p.remote.orig_name].revision or d.revisionExpr
+                        # Only save the origin if the origin is not a sha1, and
-        if not revision or revision != p.revisionExpr:
+                        # the default isn't our value
-          e.setAttribute('revision', p.revisionExpr)
+                        e.setAttribute("upstream", p.revisionExpr)
-        elif p.revisionId:
-          e.setAttribute('revision', p.revisionId)
+                if peg_rev_dest_branch:
-        if (p.upstream and (p.upstream != p.revisionExpr or
+                    if p.dest_branch:
-                            p.upstream != d.upstreamExpr)):
+                        e.setAttribute("dest-branch", p.dest_branch)
-          e.setAttribute('upstream', p.upstream)
+                    elif value != p.revisionExpr:
+                        e.setAttribute("dest-branch", p.revisionExpr)
-      if p.dest_branch and p.dest_branch != d.destBranchExpr:
-        e.setAttribute('dest-branch', p.dest_branch)
+            else:
+                revision = (
-      for c in p.copyfiles:
+                    self.remotes[p.remote.orig_name].revision or d.revisionExpr
-        ce = doc.createElement('copyfile')
+                )
-        ce.setAttribute('src', c.src)
+                if not revision or revision != p.revisionExpr:
-        ce.setAttribute('dest', c.dest)
+                    e.setAttribute("revision", p.revisionExpr)
-        e.appendChild(ce)
+                elif p.revisionId:
+                    e.setAttribute("revision", p.revisionId)
-      for l in p.linkfiles:
+                if p.upstream and (
-        le = doc.createElement('linkfile')
+                    p.upstream != p.revisionExpr or p.upstream != d.upstreamExpr
-        le.setAttribute('src', l.src)
+                ):
-        le.setAttribute('dest', l.dest)
+                    e.setAttribute("upstream", p.upstream)
-        e.appendChild(le)
+            if p.dest_branch and p.dest_branch != d.destBranchExpr:
-      default_groups = ['all', 'name:%s' % p.name, 'path:%s' % p.relpath]
+                e.setAttribute("dest-branch", p.dest_branch)
-      egroups = [g for g in p.groups if g not in default_groups]
-      if egroups:
+            for c in p.copyfiles:
-        e.setAttribute('groups', ','.join(egroups))
+                ce = doc.createElement("copyfile")
+                ce.setAttribute("src", c.src)
-      for a in p.annotations:
+                ce.setAttribute("dest", c.dest)
-        if a.keep == "true":
+                e.appendChild(ce)
-          ae = doc.createElement('annotation')
-          ae.setAttribute('name', a.name)
+            for lf in p.linkfiles:
-          ae.setAttribute('value', a.value)
+                le = doc.createElement("linkfile")
-          e.appendChild(ae)
+                le.setAttribute("src", lf.src)
+                le.setAttribute("dest", lf.dest)
-      if p.sync_c:
+                e.appendChild(le)
-        e.setAttribute('sync-c', 'true')
+            default_groups = ["all", "name:%s" % p.name, "path:%s" % p.relpath]
-      if p.sync_s:
+            egroups = [g for g in p.groups if g not in default_groups]
-        e.setAttribute('sync-s', 'true')
+            if egroups:
+                e.setAttribute("groups", ",".join(egroups))
-      if not p.sync_tags:
-        e.setAttribute('sync-tags', 'false')
+            for a in p.annotations:
+                if a.keep == "true":
-      if p.clone_depth:
+                    ae = doc.createElement("annotation")
-        e.setAttribute('clone-depth', str(p.clone_depth))
+                    ae.setAttribute("name", a.name)
+                    ae.setAttribute("value", a.value)
-      self._output_manifest_project_extras(p, e)
+                    e.appendChild(ae)
-      if p.subprojects:
+            if p.sync_c:
-        subprojects = set(subp.name for subp in p.subprojects)
+                e.setAttribute("sync-c", "true")
-        output_projects(p, e, list(sorted(subprojects)))
+            if p.sync_s:
-    projects = set(p.name for p in self._paths.values() if not p.parent)
+                e.setAttribute("sync-s", "true")
-    output_projects(None, root, list(sorted(projects)))
+            if not p.sync_tags:
-    if self._repo_hooks_project:
+                e.setAttribute("sync-tags", "false")
-      root.appendChild(doc.createTextNode(''))
-      e = doc.createElement('repo-hooks')
+            if p.clone_depth:
-      e.setAttribute('in-project', self._repo_hooks_project.name)
+                e.setAttribute("clone-depth", str(p.clone_depth))
-      e.setAttribute('enabled-list',
-                     ' '.join(self._repo_hooks_project.enabled_repo_hooks))
+            self._output_manifest_project_extras(p, e)
-      root.appendChild(e)
+            if p.subprojects:
-    if self._superproject:
+                subprojects = set(subp.name for subp in p.subprojects)
-      root.appendChild(doc.createTextNode(''))
+                output_projects(p, e, list(sorted(subprojects)))
-      e = doc.createElement('superproject')
-      e.setAttribute('name', self._superproject.name)
+        projects = set(p.name for p in self._paths.values() if not p.parent)
-      remoteName = None
+        output_projects(None, root, list(sorted(projects)))
-      if d.remote:
-        remoteName = d.remote.name
+        if self._repo_hooks_project:
-      remote = self._superproject.remote
+            root.appendChild(doc.createTextNode(""))
-      if not d.remote or remote.orig_name != remoteName:
+            e = doc.createElement("repo-hooks")
-        remoteName = remote.orig_name
+            e.setAttribute("in-project", self._repo_hooks_project.name)
-        e.setAttribute('remote', remoteName)
+            e.setAttribute(
-      revision = remote.revision or d.revisionExpr
+                "enabled-list",
-      if not revision or revision != self._superproject.revision:
+                " ".join(self._repo_hooks_project.enabled_repo_hooks),
-        e.setAttribute('revision', self._superproject.revision)
+            )
-      root.appendChild(e)
+            root.appendChild(e)
-    if self._contactinfo.bugurl != Wrapper().BUG_URL:
-      root.appendChild(doc.createTextNode(''))
-      e = doc.createElement('contactinfo')
-      e.setAttribute('bugurl', self._contactinfo.bugurl)
-      root.appendChild(e)
-    return doc
-  def ToDict(self, **kwargs):
-    """Return the current manifest as a dictionary."""
-    # Elements that may only appear once.
-    SINGLE_ELEMENTS = {
-        'notice',
-        'default',
-        'manifest-server',
-        'repo-hooks',
-        'superproject',
-        'contactinfo',
-    }
-    # Elements that may be repeated.
-    MULTI_ELEMENTS = {
-        'remote',
-        'remove-project',
-        'project',
-        'extend-project',
-        'include',
-        'submanifest',
-        # These are children of 'project' nodes.
-        'annotation',
-        'project',
-        'copyfile',
-        'linkfile',
-    }
-    doc = self.ToXml(**kwargs)
-    ret = {}
-    def append_children(ret, node):
-      for child in node.childNodes:
-        if child.nodeType == xml.dom.Node.ELEMENT_NODE:
-          attrs = child.attributes
-          element = dict((attrs.item(i).localName, attrs.item(i).value)
-                         for i in range(attrs.length))
-          if child.nodeName in SINGLE_ELEMENTS:
-            ret[child.nodeName] = element
-          elif child.nodeName in MULTI_ELEMENTS:
-            ret.setdefault(child.nodeName, []).append(element)
-          else:
-            raise ManifestParseError('Unhandled element "%s"' % (child.nodeName,))
-          append_children(element, child)
-    append_children(ret, doc.firstChild)
-    return ret
-  def Save(self, fd, **kwargs):
-    """Write the current manifest out to the given file descriptor."""
-    doc = self.ToXml(**kwargs)
-    doc.writexml(fd, '', '  ', '\n', 'UTF-8')
-  def _output_manifest_project_extras(self, p, e):
-    """Manifests can modify e if they support extra project attributes."""
-  @property
-  def is_multimanifest(self):
-    """Whether this is a multimanifest checkout.
-    This is safe to use as long as the outermost manifest XML has been parsed.
-    """
-    return bool(self._outer_client._submanifests)
-  @property
-  def is_submanifest(self):
-    """Whether this manifest is a submanifest.
-    This is safe to use as long as the outermost manifest XML has been parsed.
-    """
-    return self._outer_client and self._outer_client != self
-  @property
-  def outer_client(self):
-    """The instance of the outermost manifest client."""
-    self._Load()
-    return self._outer_client
-  @property
-  def all_manifests(self):
-    """Generator yielding all (sub)manifests, in depth-first order."""
-    self._Load()
-    outer = self._outer_client
-    yield outer
-    for tree in outer.all_children:
-      yield tree
-  @property
-  def all_children(self):
-    """Generator yielding all (present) child submanifests."""
-    self._Load()
-    for child in self._submanifests.values():
-      if child.repo_client:
-        yield child.repo_client
-        for tree in child.repo_client.all_children:
-          yield tree
-  @property
-  def path_prefix(self):
-    """The path of this submanifest, relative to the outermost manifest."""
-    if not self._outer_client or self == self._outer_client:
-      return ''
-    return os.path.relpath(self.topdir, self._outer_client.topdir)
-  @property
-  def all_paths(self):
-    """All project paths for all (sub)manifests.
-    See also `paths`.
-    Returns:
-      A dictionary of {path: Project()}.  `path` is relative to the outer
-      manifest.
-    """
-    ret = {}
-    for tree in self.all_manifests:
-      prefix = tree.path_prefix
-      ret.update({os.path.join(prefix, k): v for k, v in tree.paths.items()})
-    return ret
-  @property
-  def all_projects(self):
-    """All projects for all (sub)manifests.  See `projects`."""
-    return list(itertools.chain.from_iterable(x._paths.values() for x in self.all_manifests))
-  @property
-  def paths(self):
-    """Return all paths for this manifest.
-    Returns:
-      A dictionary of {path: Project()}.  `path` is relative to this manifest.
-    """
-    self._Load()
-    return self._paths
-  @property
-  def projects(self):
-    """Return a list of all Projects in this manifest."""
-    self._Load()
-    return list(self._paths.values())
-  @property
-  def remotes(self):
-    """Return a list of remotes for this manifest."""
-    self._Load()
-    return self._remotes
-  @property
-  def default(self):
-    """Return default values for this manifest."""
-    self._Load()
-    return self._default
-  @property
-  def submanifests(self):
-    """All submanifests in this manifest."""
-    self._Load()
-    return self._submanifests
-  @property
-  def repo_hooks_project(self):
-    self._Load()
-    return self._repo_hooks_project
-  @property
-  def superproject(self):
-    self._Load()
-    return self._superproject
-  @property
-  def contactinfo(self):
-    self._Load()
-    return self._contactinfo
-  @property
-  def notice(self):
-    self._Load()
-    return self._notice
-  @property
-  def manifest_server(self):
-    self._Load()
-    return self._manifest_server
-  @property
-  def CloneBundle(self):
-    clone_bundle = self.manifestProject.clone_bundle
-    if clone_bundle is None:
-      return False if self.manifestProject.partial_clone else True
-    else:
-      return clone_bundle
-  @property
-  def CloneFilter(self):
-    if self.manifestProject.partial_clone:
-      return self.manifestProject.clone_filter
-    return None
-  @property
-  def PartialCloneExclude(self):
-    exclude = self.manifest.manifestProject.partial_clone_exclude or ''
-    return set(x.strip() for x in exclude.split(','))
-  def SetManifestOverride(self, path):
-    """Override manifestFile.  The caller must call Unload()"""
-    self._outer_client.manifest.manifestFileOverrides[self.path_prefix] = path
-  @property
-  def UseLocalManifests(self):
-    return self._load_local_manifests
-  def SetUseLocalManifests(self, value):
-    self._load_local_manifests = value
-  @property
-  def HasLocalManifests(self):
-    return self._load_local_manifests and self.local_manifests
-  def IsFromLocalManifest(self, project):
-    """Is the project from a local manifest?"""
-    return any(x.startswith(LOCAL_MANIFEST_GROUP_PREFIX)
-               for x in project.groups)
-  @property
-  def IsMirror(self):
-    return self.manifestProject.mirror
-  @property
-  def UseGitWorktrees(self):
-    return self.manifestProject.use_worktree
-  @property
-  def IsArchive(self):
-    return self.manifestProject.archive
-  @property
-  def HasSubmodules(self):
-    return self.manifestProject.submodules
-  @property
-  def EnableGitLfs(self):
-    return self.manifestProject.git_lfs
-  def FindManifestByPath(self, path):
-    """Returns the manifest containing path."""
-    path = os.path.abspath(path)
-    manifest = self._outer_client or self
-    old = None
-    while manifest._submanifests and manifest != old:
-      old = manifest
-      for name in manifest._submanifests:
-        tree = manifest._submanifests[name]
-        if path.startswith(tree.repo_client.manifest.topdir):
-          manifest = tree.repo_client
-          break
-    return manifest
-  @property
-  def subdir(self):
-    """Returns the path for per-submanifest objects for this manifest."""
-    return self.SubmanifestInfoDir(self.path_prefix)
-  def SubmanifestInfoDir(self, submanifest_path, object_path=''):
-    """Return the path to submanifest-specific info for a submanifest.
-    Return the full path of the directory in which to put per-manifest objects.
-    Args:
-      submanifest_path: a string, the path of the submanifest, relative to the
-                        outermost topdir.  If empty, then repodir is returned.
-      object_path: a string, relative path to append to the submanifest info
-                   directory path.
-    """
-    if submanifest_path:
-      return os.path.join(self.repodir, SUBMANIFEST_DIR, submanifest_path,
-                          object_path)
-    else:
-      return os.path.join(self.repodir, object_path)
-  def SubmanifestProject(self, submanifest_path):
-    """Return a manifestProject for a submanifest."""
-    subdir = self.SubmanifestInfoDir(submanifest_path)
-    mp = ManifestProject(self, 'manifests',
-                         gitdir=os.path.join(subdir, 'manifests.git'),
-                         worktree=os.path.join(subdir, 'manifests'))
-    return mp
-  def GetDefaultGroupsStr(self, with_platform=True):
-    """Returns the default group string to use.
-    Args:
-      with_platform: a boolean, whether to include the group for the
-                     underlying platform.
-    """
-    groups = ','.join(self.default_groups or ['default'])
-    if with_platform:
-      groups += f',platform-{platform.system().lower()}'
-    return groups
-  def GetGroupsStr(self):
-    """Returns the manifest group string that should be synced."""
-    return self.manifestProject.manifest_groups or self.GetDefaultGroupsStr()
-  def Unload(self):
-    """Unload the manifest.
-    If the manifest files have been changed since Load() was called, this will
-    cause the new/updated manifest to be used.
-    """
-    self._loaded = False
-    self._projects = {}
-    self._paths = {}
-    self._remotes = {}
-    self._default = None
-    self._submanifests = {}
-    self._repo_hooks_project = None
-    self._superproject = None
-    self._contactinfo = ContactInfo(Wrapper().BUG_URL)
-    self._notice = None
-    self.branch = None
-    self._manifest_server = None
-  def Load(self):
-    """Read the manifest into memory."""
-    # Do not expose internal arguments.
-    self._Load()
-  def _Load(self, initial_client=None, submanifest_depth=0):
-    if submanifest_depth > MAX_SUBMANIFEST_DEPTH:
-      raise ManifestParseError('maximum submanifest depth %d exceeded.' %
-                               MAX_SUBMANIFEST_DEPTH)
-    if not self._loaded:
-      if self._outer_client and self._outer_client != self:
-        # This will load all clients.
-        self._outer_client._Load(initial_client=self)
-      savedManifestFile = self.manifestFile
-      override = self._outer_client.manifestFileOverrides.get(self.path_prefix)
-      if override:
-        self.manifestFile = override
-      try:
-        m = self.manifestProject
-        b = m.GetBranch(m.CurrentBranch).merge
-        if b is not None and b.startswith(R_HEADS):
-          b = b[len(R_HEADS):]
-        self.branch = b
-        parent_groups = self.parent_groups
-        if self.path_prefix:
-          parent_groups = f'{SUBMANIFEST_GROUP_PREFIX}:path:{self.path_prefix},{parent_groups}'
-        # The manifestFile was specified by the user which is why we allow include
-        # paths to point anywhere.
-        nodes = []
-        nodes.append(self._ParseManifestXml(
-            self.manifestFile, self.manifestProject.worktree,
-            parent_groups=parent_groups, restrict_includes=False))
-        if self._load_local_manifests and self.local_manifests:
-          try:
-            for local_file in sorted(platform_utils.listdir(self.local_manifests)):
-              if local_file.endswith('.xml'):
-                local = os.path.join(self.local_manifests, local_file)
-                # Since local manifests are entirely managed by the user, allow
-                # them to point anywhere the user wants.
-                local_group = f'{LOCAL_MANIFEST_GROUP_PREFIX}:{local_file[:-4]}'
-                nodes.append(self._ParseManifestXml(
-                    local, self.subdir,
-                    parent_groups=f'{local_group},{parent_groups}',
-                    restrict_includes=False))
-          except OSError:
-            pass
+        if self._superproject:
+            root.appendChild(doc.createTextNode(""))
+            e = doc.createElement("superproject")
+            e.setAttribute("name", self._superproject.name)
+            remoteName = None
+            if d.remote:
+                remoteName = d.remote.name
+            remote = self._superproject.remote
+            if not d.remote or remote.orig_name != remoteName:
+                remoteName = remote.orig_name
+                e.setAttribute("remote", remoteName)
+            revision = remote.revision or d.revisionExpr
+            if not revision or revision != self._superproject.revision:
+                e.setAttribute("revision", self._superproject.revision)
+            root.appendChild(e)
+        if self._contactinfo.bugurl != Wrapper().BUG_URL:
+            root.appendChild(doc.createTextNode(""))
+            e = doc.createElement("contactinfo")
+            e.setAttribute("bugurl", self._contactinfo.bugurl)
+            root.appendChild(e)
+        return doc
+    def ToDict(self, **kwargs):
+        """Return the current manifest as a dictionary."""
+        # Elements that may only appear once.
+        SINGLE_ELEMENTS = {
+            "notice",
+            "default",
+            "manifest-server",
+            "repo-hooks",
+            "superproject",
+            "contactinfo",
+        }
+        # Elements that may be repeated.
+        MULTI_ELEMENTS = {
+            "remote",
+            "remove-project",
+            "project",
+            "extend-project",
+            "include",
+            "submanifest",
+            # These are children of 'project' nodes.
+            "annotation",
+            "project",
+            "copyfile",
+            "linkfile",
+        }
+        doc = self.ToXml(**kwargs)
+        ret = {}
+        def append_children(ret, node):
+            for child in node.childNodes:
+                if child.nodeType == xml.dom.Node.ELEMENT_NODE:
+                    attrs = child.attributes
+                    element = dict(
+                        (attrs.item(i).localName, attrs.item(i).value)
+                        for i in range(attrs.length)
+                    )
+                    if child.nodeName in SINGLE_ELEMENTS:
+                        ret[child.nodeName] = element
+                    elif child.nodeName in MULTI_ELEMENTS:
+                        ret.setdefault(child.nodeName, []).append(element)
+                    else:
+                        raise ManifestParseError(
+                            'Unhandled element "%s"' % (child.nodeName,)
+                        )
+                    append_children(element, child)
+        append_children(ret, doc.firstChild)
+        return ret
+    def Save(self, fd, **kwargs):
+        """Write the current manifest out to the given file descriptor."""
+        doc = self.ToXml(**kwargs)
+        doc.writexml(fd, "", "  ", "\n", "UTF-8")
+    def _output_manifest_project_extras(self, p, e):
+        """Manifests can modify e if they support extra project attributes."""
+    @property
+    def is_multimanifest(self):
+        """Whether this is a multimanifest checkout.
+        This is safe to use as long as the outermost manifest XML has been
+        parsed.
+        """
+        return bool(self._outer_client._submanifests)
+    @property
+    def is_submanifest(self):
+        """Whether this manifest is a submanifest.
+        This is safe to use as long as the outermost manifest XML has been
+        parsed.
+        """
+        return self._outer_client and self._outer_client != self
+    @property
+    def outer_client(self):
+        """The instance of the outermost manifest client."""
+        self._Load()
+        return self._outer_client
+    @property
+    def all_manifests(self):
+        """Generator yielding all (sub)manifests, in depth-first order."""
+        self._Load()
+        outer = self._outer_client
+        yield outer
+        for tree in outer.all_children:
+            yield tree
+    @property
+    def all_children(self):
+        """Generator yielding all (present) child submanifests."""
+        self._Load()
+        for child in self._submanifests.values():
+            if child.repo_client:
+                yield child.repo_client
+                for tree in child.repo_client.all_children:
+                    yield tree
+    @property
+    def path_prefix(self):
+        """The path of this submanifest, relative to the outermost manifest."""
+        if not self._outer_client or self == self._outer_client:
+            return ""
+        return os.path.relpath(self.topdir, self._outer_client.topdir)
+    @property
+    def all_paths(self):
+        """All project paths for all (sub)manifests.
+        See also `paths`.
+        Returns:
+            A dictionary of {path: Project()}.  `path` is relative to the outer
+            manifest.
+        """
+        ret = {}
+        for tree in self.all_manifests:
+            prefix = tree.path_prefix
+            ret.update(
+                {os.path.join(prefix, k): v for k, v in tree.paths.items()}
+            )
+        return ret
+    @property
+    def all_projects(self):
+        """All projects for all (sub)manifests.  See `projects`."""
+        return list(
+            itertools.chain.from_iterable(
+                x._paths.values() for x in self.all_manifests
+            )
+        )
+    @property
+    def paths(self):
+        """Return all paths for this manifest.
+        Returns:
+            A dictionary of {path: Project()}.  `path` is relative to this
+            manifest.
+        """
+        self._Load()
+        return self._paths
+    @property
+    def projects(self):
+        """Return a list of all Projects in this manifest."""
+        self._Load()
+        return list(self._paths.values())
+    @property
+    def remotes(self):
+        """Return a list of remotes for this manifest."""
+        self._Load()
+        return self._remotes
+    @property
+    def default(self):
+        """Return default values for this manifest."""
+        self._Load()
+        return self._default
+    @property
+    def submanifests(self):
+        """All submanifests in this manifest."""
+        self._Load()
+        return self._submanifests
+    @property
+    def repo_hooks_project(self):
+        self._Load()
+        return self._repo_hooks_project
+    @property
+    def superproject(self):
+        self._Load()
+        return self._superproject
+    @property
+    def contactinfo(self):
+        self._Load()
+        return self._contactinfo
+    @property
+    def notice(self):
+        self._Load()
+        return self._notice
+    @property
+    def manifest_server(self):
+        self._Load()
+        return self._manifest_server
+    @property
+    def CloneBundle(self):
+        clone_bundle = self.manifestProject.clone_bundle
+        if clone_bundle is None:
+            return False if self.manifestProject.partial_clone else True
+        else:
+            return clone_bundle
+    @property
+    def CloneFilter(self):
+        if self.manifestProject.partial_clone:
+            return self.manifestProject.clone_filter
+        return None
+    @property
+    def PartialCloneExclude(self):
+        exclude = self.manifest.manifestProject.partial_clone_exclude or ""
+        return set(x.strip() for x in exclude.split(","))
+    def SetManifestOverride(self, path):
+        """Override manifestFile.  The caller must call Unload()"""
+        self._outer_client.manifest.manifestFileOverrides[
+            self.path_prefix
+        ] = path
+    @property
+    def UseLocalManifests(self):
+        return self._load_local_manifests
+    def SetUseLocalManifests(self, value):
+        self._load_local_manifests = value
+    @property
+    def HasLocalManifests(self):
+        return self._load_local_manifests and self.local_manifests
+    def IsFromLocalManifest(self, project):
+        """Is the project from a local manifest?"""
+        return any(
+            x.startswith(LOCAL_MANIFEST_GROUP_PREFIX) for x in project.groups
+        )
+    @property
+    def IsMirror(self):
+        return self.manifestProject.mirror
+    @property
+    def UseGitWorktrees(self):
+        return self.manifestProject.use_worktree
+    @property
+    def IsArchive(self):
+        return self.manifestProject.archive
+    @property
+    def HasSubmodules(self):
+        return self.manifestProject.submodules
+    @property
+    def EnableGitLfs(self):
+        return self.manifestProject.git_lfs
+    def FindManifestByPath(self, path):
+        """Returns the manifest containing path."""
+        path = os.path.abspath(path)
+        manifest = self._outer_client or self
+        old = None
+        while manifest._submanifests and manifest != old:
+            old = manifest
+            for name in manifest._submanifests:
+                tree = manifest._submanifests[name]
+                if path.startswith(tree.repo_client.manifest.topdir):
+                    manifest = tree.repo_client
+                    break
+        return manifest
+    @property
+    def subdir(self):
+        """Returns the path for per-submanifest objects for this manifest."""
+        return self.SubmanifestInfoDir(self.path_prefix)
+    def SubmanifestInfoDir(self, submanifest_path, object_path=""):
+        """Return the path to submanifest-specific info for a submanifest.
+        Return the full path of the directory in which to put per-manifest
+        objects.
+        Args:
+            submanifest_path: a string, the path of the submanifest, relative to
+                the outermost topdir.  If empty, then repodir is returned.
+            object_path: a string, relative path to append to the submanifest
+                info directory path.
+        """
+        if submanifest_path:
+            return os.path.join(
+                self.repodir, SUBMANIFEST_DIR, submanifest_path, object_path
+            )
+        else:
+            return os.path.join(self.repodir, object_path)
+    def SubmanifestProject(self, submanifest_path):
+        """Return a manifestProject for a submanifest."""
+        subdir = self.SubmanifestInfoDir(submanifest_path)
+        mp = ManifestProject(
+            self,
+            "manifests",
+            gitdir=os.path.join(subdir, "manifests.git"),
+            worktree=os.path.join(subdir, "manifests"),
+        )
+        return mp
+    def GetDefaultGroupsStr(self, with_platform=True):
+        """Returns the default group string to use.
+        Args:
+            with_platform: a boolean, whether to include the group for the
+                          underlying platform.
+        """
+        groups = ",".join(self.default_groups or ["default"])
+        if with_platform:
+            groups += f",platform-{platform.system().lower()}"
+        return groups
+    def GetGroupsStr(self):
+        """Returns the manifest group string that should be synced."""
+        return (
+            self.manifestProject.manifest_groups or self.GetDefaultGroupsStr()
+        )
+    def Unload(self):
+        """Unload the manifest.
+        If the manifest files have been changed since Load() was called, this
+        will cause the new/updated manifest to be used.
+        """
+        self._loaded = False
+        self._projects = {}
+        self._paths = {}
+        self._remotes = {}
+        self._default = None
+        self._submanifests = {}
+        self._repo_hooks_project = None
+        self._superproject = None
+        self._contactinfo = ContactInfo(Wrapper().BUG_URL)
+        self._notice = None
+        self.branch = None
+        self._manifest_server = None
+    def Load(self):
+        """Read the manifest into memory."""
+        # Do not expose internal arguments.
+        self._Load()
+    def _Load(self, initial_client=None, submanifest_depth=0):
+        if submanifest_depth > MAX_SUBMANIFEST_DEPTH:
+            raise ManifestParseError(
+                "maximum submanifest depth %d exceeded." % MAX_SUBMANIFEST_DEPTH
+            )
+        if not self._loaded:
+            if self._outer_client and self._outer_client != self:
+                # This will load all clients.
+                self._outer_client._Load(initial_client=self)
+            savedManifestFile = self.manifestFile
+            override = self._outer_client.manifestFileOverrides.get(
+                self.path_prefix
+            )
+            if override:
+                self.manifestFile = override
+            try:
+                m = self.manifestProject
+                b = m.GetBranch(m.CurrentBranch).merge
+                if b is not None and b.startswith(R_HEADS):
+                    b = b[len(R_HEADS) :]
+                self.branch = b
+                parent_groups = self.parent_groups
+                if self.path_prefix:
+                    parent_groups = (
+                        f"{SUBMANIFEST_GROUP_PREFIX}:path:"
+                        f"{self.path_prefix},{parent_groups}"
+                    )
+                # The manifestFile was specified by the user which is why we
+                # allow include paths to point anywhere.
+                nodes = []
+                nodes.append(
+                    self._ParseManifestXml(
+                        self.manifestFile,
+                        self.manifestProject.worktree,
+                        parent_groups=parent_groups,
+                        restrict_includes=False,
+                    )
+                )
+                if self._load_local_manifests and self.local_manifests:
+                    try:
+                        for local_file in sorted(
+                            platform_utils.listdir(self.local_manifests)
+                        ):
+                            if local_file.endswith(".xml"):
+                                local = os.path.join(
+                                    self.local_manifests, local_file
+                                )
+                                # Since local manifests are entirely managed by
+                                # the user, allow them to point anywhere the
+                                # user wants.
+                                local_group = (
+                                    f"{LOCAL_MANIFEST_GROUP_PREFIX}:"
+                                    f"{local_file[:-4]}"
+                                )
+                                nodes.append(
+                                    self._ParseManifestXml(
+                                        local,
+                                        self.subdir,
+                                        parent_groups=(
+                                            f"{local_group},{parent_groups}"
+                                        ),
+                                        restrict_includes=False,
+                                    )
+                                )
+                    except OSError:
+                        pass
+                try:
+                    self._ParseManifest(nodes)
+                except ManifestParseError as e:
+                    # There was a problem parsing, unload ourselves in case they
+                    # catch this error and try again later, we will show the
+                    # correct error
+                    self.Unload()
+                    raise e
+                if self.IsMirror:
+                    self._AddMetaProjectMirror(self.repoProject)
+                    self._AddMetaProjectMirror(self.manifestProject)
+                self._loaded = True
+            finally:
+                if override:
+                    self.manifestFile = savedManifestFile
+            # Now that we have loaded this manifest, load any submanifests as
+            # well. We need to do this after self._loaded is set to avoid
+            # looping.
+            for name in self._submanifests:
+                tree = self._submanifests[name]
+                tree.ToSubmanifestSpec()
+                present = os.path.exists(
+                    os.path.join(self.subdir, MANIFEST_FILE_NAME)
+                )
+                if present and tree.present and not tree.repo_client:
+                    if initial_client and initial_client.topdir == self.topdir:
+                        tree.repo_client = self
+                        tree.present = present
+                    elif not os.path.exists(self.subdir):
+                        tree.present = False
+                if present and tree.present:
+                    tree.repo_client._Load(
+                        initial_client=initial_client,
+                        submanifest_depth=submanifest_depth + 1,
+                    )
+    def _ParseManifestXml(
+        self, path, include_root, parent_groups="", restrict_includes=True
+    ):
+        """Parse a manifest XML and return the computed nodes.
+        Args:
+            path: The XML file to read & parse.
+            include_root: The path to interpret include "name"s relative to.
+            parent_groups: The groups to apply to this projects.
+            restrict_includes: Whether to constrain the "name" attribute of
+                includes.
+        Returns:
+            List of XML nodes.
+        """
        try:
-          self._ParseManifest(nodes)
+            root = xml.dom.minidom.parse(path)
-        except ManifestParseError as e:
+        except (OSError, xml.parsers.expat.ExpatError) as e:
-          # There was a problem parsing, unload ourselves in case they catch
+            raise ManifestParseError(
-          # this error and try again later, we will show the correct error
+                "error parsing manifest %s: %s" % (path, e)
-          self.Unload()
+            )
-          raise e
+        if not root or not root.childNodes:
-        if self.IsMirror:
+            raise ManifestParseError("no root node in %s" % (path,))
-          self._AddMetaProjectMirror(self.repoProject)
-          self._AddMetaProjectMirror(self.manifestProject)
+        for manifest in root.childNodes:
+            if manifest.nodeName == "manifest":
-        self._loaded = True
+                break
-      finally:
+        else:
-        if override:
+            raise ManifestParseError("no <manifest> in %s" % (path,))
-          self.manifestFile = savedManifestFile
-      # Now that we have loaded this manifest, load any submanifests as well.
-      # We need to do this after self._loaded is set to avoid looping.
-      for name in self._submanifests:
-        tree = self._submanifests[name]
-        spec = tree.ToSubmanifestSpec()
-        present = os.path.exists(os.path.join(self.subdir, MANIFEST_FILE_NAME))
-        if present and tree.present and not tree.repo_client:
-          if initial_client and initial_client.topdir == self.topdir:
-            tree.repo_client = self
-            tree.present = present
-          elif not os.path.exists(self.subdir):
-            tree.present = False
-        if present and tree.present:
-          tree.repo_client._Load(initial_client=initial_client,
-                                 submanifest_depth=submanifest_depth + 1)
-  def _ParseManifestXml(self, path, include_root, parent_groups='',
-                        restrict_includes=True):
-    """Parse a manifest XML and return the computed nodes.
-    Args:
-      path: The XML file to read & parse.
-      include_root: The path to interpret include "name"s relative to.
-      parent_groups: The groups to apply to this projects.
-      restrict_includes: Whether to constrain the "name" attribute of includes.
-    Returns:
-      List of XML nodes.
-    """
-    try:
-      root = xml.dom.minidom.parse(path)
-    except (OSError, xml.parsers.expat.ExpatError) as e:
-      raise ManifestParseError("error parsing manifest %s: %s" % (path, e))
-    if not root or not root.childNodes:
+        nodes = []
-      raise ManifestParseError("no root node in %s" % (path,))
+        for node in manifest.childNodes:
+            if node.nodeName == "include":
+                name = self._reqatt(node, "name")
+                if restrict_includes:
+                    msg = self._CheckLocalPath(name)
+                    if msg:
+                        raise ManifestInvalidPathError(
+                            '<include> invalid "name": %s: %s' % (name, msg)
+                        )
+                include_groups = ""
+                if parent_groups:
+                    include_groups = parent_groups
+                if node.hasAttribute("groups"):
+                    include_groups = (
+                        node.getAttribute("groups") + "," + include_groups
+                    )
+                fp = os.path.join(include_root, name)
+                if not os.path.isfile(fp):
+                    raise ManifestParseError(
+                        "include [%s/]%s doesn't exist or isn't a file"
+                        % (include_root, name)
+                    )
+                try:
+                    nodes.extend(
+                        self._ParseManifestXml(fp, include_root, include_groups)
+                    )
+                # should isolate this to the exact exception, but that's
+                # tricky.  actual parsing implementation may vary.
+                except (
+                    KeyboardInterrupt,
+                    RuntimeError,
+                    SystemExit,
+                    ManifestParseError,
+                ):
+                    raise
+                except Exception as e:
+                    raise ManifestParseError(
+                        "failed parsing included manifest %s: %s" % (name, e)
+                    )
+            else:
+                if parent_groups and node.nodeName == "project":
+                    nodeGroups = parent_groups
+                    if node.hasAttribute("groups"):
+                        nodeGroups = (
+                            node.getAttribute("groups") + "," + nodeGroups
+                        )
+                    node.setAttribute("groups", nodeGroups)
+                nodes.append(node)
+        return nodes
+    def _ParseManifest(self, node_list):
+        for node in itertools.chain(*node_list):
+            if node.nodeName == "remote":
+                remote = self._ParseRemote(node)
+                if remote:
+                    if remote.name in self._remotes:
+                        if remote != self._remotes[remote.name]:
+                            raise ManifestParseError(
+                                "remote %s already exists with different "
+                                "attributes" % (remote.name)
+                            )
+                    else:
+                        self._remotes[remote.name] = remote
+        for node in itertools.chain(*node_list):
+            if node.nodeName == "default":
+                new_default = self._ParseDefault(node)
+                emptyDefault = (
+                    not node.hasAttributes() and not node.hasChildNodes()
+                )
+                if self._default is None:
+                    self._default = new_default
+                elif not emptyDefault and new_default != self._default:
+                    raise ManifestParseError(
+                        "duplicate default in %s" % (self.manifestFile)
+                    )
-    for manifest in root.childNodes:
-      if manifest.nodeName == 'manifest':
-        break
-    else:
-      raise ManifestParseError("no <manifest> in %s" % (path,))
-    nodes = []
-    for node in manifest.childNodes:
-      if node.nodeName == 'include':
-        name = self._reqatt(node, 'name')
-        if restrict_includes:
-          msg = self._CheckLocalPath(name)
-          if msg:
-            raise ManifestInvalidPathError(
-                '<include> invalid "name": %s: %s' % (name, msg))
-        include_groups = ''
-        if parent_groups:
-          include_groups = parent_groups
-        if node.hasAttribute('groups'):
-          include_groups = node.getAttribute('groups') + ',' + include_groups
-        fp = os.path.join(include_root, name)
-        if not os.path.isfile(fp):
-          raise ManifestParseError("include [%s/]%s doesn't exist or isn't a file"
-                                   % (include_root, name))
-        try:
-          nodes.extend(self._ParseManifestXml(fp, include_root, include_groups))
-        # should isolate this to the exact exception, but that's
-        # tricky.  actual parsing implementation may vary.
-        except (KeyboardInterrupt, RuntimeError, SystemExit, ManifestParseError):
-          raise
-        except Exception as e:
-          raise ManifestParseError(
-              "failed parsing included manifest %s: %s" % (name, e))
-      else:
-        if parent_groups and node.nodeName == 'project':
-          nodeGroups = parent_groups
-          if node.hasAttribute('groups'):
-            nodeGroups = node.getAttribute('groups') + ',' + nodeGroups
-          node.setAttribute('groups', nodeGroups)
-        nodes.append(node)
-    return nodes
-  def _ParseManifest(self, node_list):
-    for node in itertools.chain(*node_list):
-      if node.nodeName == 'remote':
-        remote = self._ParseRemote(node)
-        if remote:
-          if remote.name in self._remotes:
-            if remote != self._remotes[remote.name]:
-              raise ManifestParseError(
-                  'remote %s already exists with different attributes' %
-                  (remote.name))
-          else:
-            self._remotes[remote.name] = remote
-    for node in itertools.chain(*node_list):
-      if node.nodeName == 'default':
-        new_default = self._ParseDefault(node)
-        emptyDefault = not node.hasAttributes() and not node.hasChildNodes()
        if self._default is None:
-          self._default = new_default
+            self._default = _Default()
-        elif not emptyDefault and new_default != self._default:
-          raise ManifestParseError('duplicate default in %s' %
+        submanifest_paths = set()
-                                   (self.manifestFile))
+        for node in itertools.chain(*node_list):
+            if node.nodeName == "submanifest":
-    if self._default is None:
+                submanifest = self._ParseSubmanifest(node)
-      self._default = _Default()
+                if submanifest:
+                    if submanifest.name in self._submanifests:
-    submanifest_paths = set()
+                        if submanifest != self._submanifests[submanifest.name]:
-    for node in itertools.chain(*node_list):
+                            raise ManifestParseError(
-      if node.nodeName == 'submanifest':
+                                "submanifest %s already exists with different "
-        submanifest = self._ParseSubmanifest(node)
+                                "attributes" % (submanifest.name)
-        if submanifest:
+                            )
-          if submanifest.name in self._submanifests:
+                    else:
-            if submanifest != self._submanifests[submanifest.name]:
+                        self._submanifests[submanifest.name] = submanifest
-              raise ManifestParseError(
+                        submanifest_paths.add(submanifest.relpath)
-                  'submanifest %s already exists with different attributes' %
-                  (submanifest.name))
+        for node in itertools.chain(*node_list):
-          else:
+            if node.nodeName == "notice":
-            self._submanifests[submanifest.name] = submanifest
+                if self._notice is not None:
-            submanifest_paths.add(submanifest.relpath)
+                    raise ManifestParseError(
+                        "duplicate notice in %s" % (self.manifestFile)
-    for node in itertools.chain(*node_list):
+                    )
-      if node.nodeName == 'notice':
+                self._notice = self._ParseNotice(node)
-        if self._notice is not None:
-          raise ManifestParseError(
+        for node in itertools.chain(*node_list):
-              'duplicate notice in %s' %
+            if node.nodeName == "manifest-server":
-              (self.manifestFile))
+                url = self._reqatt(node, "url")
-        self._notice = self._ParseNotice(node)
+                if self._manifest_server is not None:
+                    raise ManifestParseError(
-    for node in itertools.chain(*node_list):
+                        "duplicate manifest-server in %s" % (self.manifestFile)
-      if node.nodeName == 'manifest-server':
+                    )
-        url = self._reqatt(node, 'url')
+                self._manifest_server = url
-        if self._manifest_server is not None:
-          raise ManifestParseError(
+        def recursively_add_projects(project):
-              'duplicate manifest-server in %s' %
+            projects = self._projects.setdefault(project.name, [])
-              (self.manifestFile))
+            if project.relpath is None:
-        self._manifest_server = url
+                raise ManifestParseError(
+                    "missing path for %s in %s"
-    def recursively_add_projects(project):
+                    % (project.name, self.manifestFile)
-      projects = self._projects.setdefault(project.name, [])
+                )
-      if project.relpath is None:
+            if project.relpath in self._paths:
-        raise ManifestParseError(
+                raise ManifestParseError(
-            'missing path for %s in %s' %
+                    "duplicate path %s in %s"
-            (project.name, self.manifestFile))
+                    % (project.relpath, self.manifestFile)
-      if project.relpath in self._paths:
+                )
-        raise ManifestParseError(
+            for tree in submanifest_paths:
-            'duplicate path %s in %s' %
+                if project.relpath.startswith(tree):
-            (project.relpath, self.manifestFile))
+                    raise ManifestParseError(
-      for tree in submanifest_paths:
+                        "project %s conflicts with submanifest path %s"
-        if project.relpath.startswith(tree):
+                        % (project.relpath, tree)
-          raise ManifestParseError(
+                    )
-              'project %s conflicts with submanifest path %s' %
+            self._paths[project.relpath] = project
-              (project.relpath, tree))
+            projects.append(project)
-      self._paths[project.relpath] = project
+            for subproject in project.subprojects:
-      projects.append(project)
+                recursively_add_projects(subproject)
-      for subproject in project.subprojects:
-        recursively_add_projects(subproject)
+        repo_hooks_project = None
+        enabled_repo_hooks = None
-    repo_hooks_project = None
+        for node in itertools.chain(*node_list):
-    enabled_repo_hooks = None
+            if node.nodeName == "project":
-    for node in itertools.chain(*node_list):
+                project = self._ParseProject(node)
-      if node.nodeName == 'project':
+                recursively_add_projects(project)
-        project = self._ParseProject(node)
+            if node.nodeName == "extend-project":
-        recursively_add_projects(project)
+                name = self._reqatt(node, "name")
-      if node.nodeName == 'extend-project':
-        name = self._reqatt(node, 'name')
+                if name not in self._projects:
+                    raise ManifestParseError(
+                        "extend-project element specifies non-existent "
+                        "project: %s" % name
+                    )
+                path = node.getAttribute("path")
+                dest_path = node.getAttribute("dest-path")
+                groups = node.getAttribute("groups")
+                if groups:
+                    groups = self._ParseList(groups)
+                revision = node.getAttribute("revision")
+                remote_name = node.getAttribute("remote")
+                if not remote_name:
+                    remote = self._default.remote
+                else:
+                    remote = self._get_remote(node)
+                dest_branch = node.getAttribute("dest-branch")
+                upstream = node.getAttribute("upstream")
+                named_projects = self._projects[name]
+                if dest_path and not path and len(named_projects) > 1:
+                    raise ManifestParseError(
+                        "extend-project cannot use dest-path when "
+                        "matching multiple projects: %s" % name
+                    )
+                for p in self._projects[name]:
+                    if path and p.relpath != path:
+                        continue
+                    if groups:
+                        p.groups.extend(groups)
+                    if revision:
+                        p.SetRevision(revision)
+                    if remote_name:
+                        p.remote = remote.ToRemoteSpec(name)
+                    if dest_branch:
+                        p.dest_branch = dest_branch
+                    if upstream:
+                        p.upstream = upstream
+                    if dest_path:
+                        del self._paths[p.relpath]
+                        (
+                            relpath,
+                            worktree,
+                            gitdir,
+                            objdir,
+                            _,
+                        ) = self.GetProjectPaths(name, dest_path, remote.name)
+                        p.UpdatePaths(relpath, worktree, gitdir, objdir)
+                        self._paths[p.relpath] = p
+            if node.nodeName == "repo-hooks":
+                # Only one project can be the hooks project
+                if repo_hooks_project is not None:
+                    raise ManifestParseError(
+                        "duplicate repo-hooks in %s" % (self.manifestFile)
+                    )
+                # Get the name of the project and the (space-separated) list of
+                # enabled.
+                repo_hooks_project = self._reqatt(node, "in-project")
+                enabled_repo_hooks = self._ParseList(
+                    self._reqatt(node, "enabled-list")
+                )
+            if node.nodeName == "superproject":
+                name = self._reqatt(node, "name")
+                # There can only be one superproject.
+                if self._superproject:
+                    raise ManifestParseError(
+                        "duplicate superproject in %s" % (self.manifestFile)
+                    )
+                remote_name = node.getAttribute("remote")
+                if not remote_name:
+                    remote = self._default.remote
+                else:
+                    remote = self._get_remote(node)
+                if remote is None:
+                    raise ManifestParseError(
+                        "no remote for superproject %s within %s"
+                        % (name, self.manifestFile)
+                    )
+                revision = node.getAttribute("revision") or remote.revision
+                if not revision:
+                    revision = self._default.revisionExpr
+                if not revision:
+                    raise ManifestParseError(
+                        "no revision for superproject %s within %s"
+                        % (name, self.manifestFile)
+                    )
+                self._superproject = Superproject(
+                    self,
+                    name=name,
+                    remote=remote.ToRemoteSpec(name),
+                    revision=revision,
+                )
+            if node.nodeName == "contactinfo":
+                bugurl = self._reqatt(node, "bugurl")
+                # This element can be repeated, later entries will clobber
+                # earlier ones.
+                self._contactinfo = ContactInfo(bugurl)
+            if node.nodeName == "remove-project":
+                name = self._reqatt(node, "name")
+                if name in self._projects:
+                    for p in self._projects[name]:
+                        del self._paths[p.relpath]
+                    del self._projects[name]
+                    # If the manifest removes the hooks project, treat it as if
+                    # it deleted
+                    # the repo-hooks element too.
+                    if repo_hooks_project == name:
+                        repo_hooks_project = None
+                elif not XmlBool(node, "optional", False):
+                    raise ManifestParseError(
+                        "remove-project element specifies non-existent "
+                        "project: %s" % name
+                    )
+        # Store repo hooks project information.
+        if repo_hooks_project:
+            # Store a reference to the Project.
+            try:
+                repo_hooks_projects = self._projects[repo_hooks_project]
+            except KeyError:
+                raise ManifestParseError(
+                    "project %s not found for repo-hooks" % (repo_hooks_project)
+                )
+            if len(repo_hooks_projects) != 1:
+                raise ManifestParseError(
+                    "internal error parsing repo-hooks in %s"
+                    % (self.manifestFile)
+                )
+            self._repo_hooks_project = repo_hooks_projects[0]
+            # Store the enabled hooks in the Project object.
+            self._repo_hooks_project.enabled_repo_hooks = enabled_repo_hooks
+    def _AddMetaProjectMirror(self, m):
+        name = None
+        m_url = m.GetRemote().url
+        if m_url.endswith("/.git"):
+            raise ManifestParseError("refusing to mirror %s" % m_url)
+        if self._default and self._default.remote:
+            url = self._default.remote.resolvedFetchUrl
+            if not url.endswith("/"):
+                url += "/"
+            if m_url.startswith(url):
+                remote = self._default.remote
+                name = m_url[len(url) :]
+        if name is None:
+            s = m_url.rindex("/") + 1
+            manifestUrl = self.manifestProject.config.GetString(
+                "remote.origin.url"
+            )
+            remote = _XmlRemote(
+                "origin", fetch=m_url[:s], manifestUrl=manifestUrl
+            )
+            name = m_url[s:]
+        if name.endswith(".git"):
+            name = name[:-4]
        if name not in self._projects:
-          raise ManifestParseError('extend-project element specifies non-existent '
+            m.PreSync()
-                                   'project: %s' % name)
+            gitdir = os.path.join(self.topdir, "%s.git" % name)
+            project = Project(
+                manifest=self,
+                name=name,
+                remote=remote.ToRemoteSpec(name),
+                gitdir=gitdir,
+                objdir=gitdir,
+                worktree=None,
+                relpath=name or None,
+                revisionExpr=m.revisionExpr,
+                revisionId=None,
+            )
+            self._projects[project.name] = [project]
+            self._paths[project.relpath] = project
+    def _ParseRemote(self, node):
+        """
+        reads a <remote> element from the manifest file
+        """
+        name = self._reqatt(node, "name")
+        alias = node.getAttribute("alias")
+        if alias == "":
+            alias = None
+        fetch = self._reqatt(node, "fetch")
+        pushUrl = node.getAttribute("pushurl")
+        if pushUrl == "":
+            pushUrl = None
+        review = node.getAttribute("review")
+        if review == "":
+            review = None
+        revision = node.getAttribute("revision")
+        if revision == "":
+            revision = None
+        manifestUrl = self.manifestProject.config.GetString("remote.origin.url")
+        remote = _XmlRemote(
+            name, alias, fetch, pushUrl, manifestUrl, review, revision
+        )
+        for n in node.childNodes:
+            if n.nodeName == "annotation":
+                self._ParseAnnotation(remote, n)
+        return remote
+    def _ParseDefault(self, node):
+        """
+        reads a <default> element from the manifest file
+        """
+        d = _Default()
+        d.remote = self._get_remote(node)
+        d.revisionExpr = node.getAttribute("revision")
+        if d.revisionExpr == "":
+            d.revisionExpr = None
+        d.destBranchExpr = node.getAttribute("dest-branch") or None
+        d.upstreamExpr = node.getAttribute("upstream") or None
+        d.sync_j = XmlInt(node, "sync-j", None)
+        if d.sync_j is not None and d.sync_j <= 0:
+            raise ManifestParseError(
+                '%s: sync-j must be greater than 0, not "%s"'
+                % (self.manifestFile, d.sync_j)
+            )
+        d.sync_c = XmlBool(node, "sync-c", False)
+        d.sync_s = XmlBool(node, "sync-s", False)
+        d.sync_tags = XmlBool(node, "sync-tags", True)
+        return d
+    def _ParseNotice(self, node):
+        """
+        reads a <notice> element from the manifest file
+        The <notice> element is distinct from other tags in the XML in that the
+        data is conveyed between the start and end tag (it's not an
+        empty-element tag).
+        The white space (carriage returns, indentation) for the notice element
+        is relevant and is parsed in a way that is based on how python
+        docstrings work. In fact, the code is remarkably similar to here:
+          http://www.python.org/dev/peps/pep-0257/
+        """
+        # Get the data out of the node...
+        notice = node.childNodes[0].data
+        # Figure out minimum indentation, skipping the first line (the same line
+        # as the <notice> tag)...
+        minIndent = sys.maxsize
+        lines = notice.splitlines()
+        for line in lines[1:]:
+            lstrippedLine = line.lstrip()
+            if lstrippedLine:
+                indent = len(line) - len(lstrippedLine)
+                minIndent = min(indent, minIndent)
+        # Strip leading / trailing blank lines and also indentation.
+        cleanLines = [lines[0].strip()]
+        for line in lines[1:]:
+            cleanLines.append(line[minIndent:].rstrip())
+        # Clear completely blank lines from front and back...
+        while cleanLines and not cleanLines[0]:
+            del cleanLines[0]
+        while cleanLines and not cleanLines[-1]:
+            del cleanLines[-1]
+        return "\n".join(cleanLines)
+    def _ParseSubmanifest(self, node):
+        """Reads a <submanifest> element from the manifest file."""
+        name = self._reqatt(node, "name")
+        remote = node.getAttribute("remote")
+        if remote == "":
+            remote = None
+        project = node.getAttribute("project")
+        if project == "":
+            project = None
+        revision = node.getAttribute("revision")
+        if revision == "":
+            revision = None
+        manifestName = node.getAttribute("manifest-name")
+        if manifestName == "":
+            manifestName = None
+        groups = ""
+        if node.hasAttribute("groups"):
+            groups = node.getAttribute("groups")
+        groups = self._ParseList(groups)
+        default_groups = self._ParseList(node.getAttribute("default-groups"))
+        path = node.getAttribute("path")
+        if path == "":
+            path = None
+            if revision:
+                msg = self._CheckLocalPath(revision.split("/")[-1])
+                if msg:
+                    raise ManifestInvalidPathError(
+                        '<submanifest> invalid "revision": %s: %s'
+                        % (revision, msg)
+                    )
+            else:
+                msg = self._CheckLocalPath(name)
+                if msg:
+                    raise ManifestInvalidPathError(
+                        '<submanifest> invalid "name": %s: %s' % (name, msg)
+                    )
+        else:
+            msg = self._CheckLocalPath(path)
+            if msg:
+                raise ManifestInvalidPathError(
+                    '<submanifest> invalid "path": %s: %s' % (path, msg)
+                )
+        submanifest = _XmlSubmanifest(
+            name,
+            remote,
+            project,
+            revision,
+            manifestName,
+            groups,
+            default_groups,
+            path,
+            self,
+        )
+        for n in node.childNodes:
+            if n.nodeName == "annotation":
+                self._ParseAnnotation(submanifest, n)
+        return submanifest
+    def _JoinName(self, parent_name, name):
+        return os.path.join(parent_name, name)
+    def _UnjoinName(self, parent_name, name):
+        return os.path.relpath(name, parent_name)
+    def _ParseProject(self, node, parent=None, **extra_proj_attrs):
+        """
+        reads a <project> element from the manifest file
+        """
+        name = self._reqatt(node, "name")
+        msg = self._CheckLocalPath(name, dir_ok=True)
+        if msg:
+            raise ManifestInvalidPathError(
+                '<project> invalid "name": %s: %s' % (name, msg)
+            )
+        if parent:
+            name = self._JoinName(parent.name, name)
-        path = node.getAttribute('path')
+        remote = self._get_remote(node)
-        dest_path = node.getAttribute('dest-path')
+        if remote is None:
-        groups = node.getAttribute('groups')
+            remote = self._default.remote
-        if groups:
+        if remote is None:
-          groups = self._ParseList(groups)
+            raise ManifestParseError(
-        revision = node.getAttribute('revision')
+                "no remote for project %s within %s" % (name, self.manifestFile)
-        remote_name = node.getAttribute('remote')
+            )
-        if not remote_name:
-          remote = self._default.remote
+        revisionExpr = node.getAttribute("revision") or remote.revision
+        if not revisionExpr:
+            revisionExpr = self._default.revisionExpr
+        if not revisionExpr:
+            raise ManifestParseError(
+                "no revision for project %s within %s"
+                % (name, self.manifestFile)
+            )
+        path = node.getAttribute("path")
+        if not path:
+            path = name
        else:
-          remote = self._get_remote(node)
+            # NB: The "." project is handled specially in
-        dest_branch = node.getAttribute('dest-branch')
+            # Project.Sync_LocalHalf.
-        upstream = node.getAttribute('upstream')
+            msg = self._CheckLocalPath(path, dir_ok=True, cwd_dot_ok=True)
+            if msg:
-        named_projects = self._projects[name]
+                raise ManifestInvalidPathError(
-        if dest_path and not path and len(named_projects) > 1:
+                    '<project> invalid "path": %s: %s' % (path, msg)
-          raise ManifestParseError('extend-project cannot use dest-path when '
+                )
-                                   'matching multiple projects: %s' % name)
-        for p in self._projects[name]:
+        rebase = XmlBool(node, "rebase", True)
-          if path and p.relpath != path:
+        sync_c = XmlBool(node, "sync-c", False)
-            continue
+        sync_s = XmlBool(node, "sync-s", self._default.sync_s)
-          if groups:
+        sync_tags = XmlBool(node, "sync-tags", self._default.sync_tags)
-            p.groups.extend(groups)
-          if revision:
+        clone_depth = XmlInt(node, "clone-depth")
-            p.SetRevision(revision)
+        if clone_depth is not None and clone_depth <= 0:
+            raise ManifestParseError(
-          if remote_name:
+                '%s: clone-depth must be greater than 0, not "%s"'
-            p.remote = remote.ToRemoteSpec(name)
+                % (self.manifestFile, clone_depth)
-          if dest_branch:
+            )
-            p.dest_branch = dest_branch
-          if upstream:
+        dest_branch = (
-            p.upstream = upstream
+            node.getAttribute("dest-branch") or self._default.destBranchExpr
+        )
-          if dest_path:
-            del self._paths[p.relpath]
+        upstream = node.getAttribute("upstream") or self._default.upstreamExpr
-            relpath, worktree, gitdir, objdir, _ = self.GetProjectPaths(
-                name, dest_path, remote.name)
+        groups = ""
-            p.UpdatePaths(relpath, worktree, gitdir, objdir)
+        if node.hasAttribute("groups"):
-            self._paths[p.relpath] = p
+            groups = node.getAttribute("groups")
+        groups = self._ParseList(groups)
-      if node.nodeName == 'repo-hooks':
-        # Only one project can be the hooks project
+        if parent is None:
-        if repo_hooks_project is not None:
+            (
-          raise ManifestParseError(
+                relpath,
-              'duplicate repo-hooks in %s' %
+                worktree,
-              (self.manifestFile))
+                gitdir,
+                objdir,
-        # Get the name of the project and the (space-separated) list of enabled.
+                use_git_worktrees,
-        repo_hooks_project = self._reqatt(node, 'in-project')
+            ) = self.GetProjectPaths(name, path, remote.name)
-        enabled_repo_hooks = self._ParseList(self._reqatt(node, 'enabled-list'))
-      if node.nodeName == 'superproject':
-        name = self._reqatt(node, 'name')
-        # There can only be one superproject.
-        if self._superproject:
-          raise ManifestParseError(
-              'duplicate superproject in %s' %
-              (self.manifestFile))
-        remote_name = node.getAttribute('remote')
-        if not remote_name:
-          remote = self._default.remote
        else:
-          remote = self._get_remote(node)
+            use_git_worktrees = False
-        if remote is None:
+            relpath, worktree, gitdir, objdir = self.GetSubprojectPaths(
-          raise ManifestParseError("no remote for superproject %s within %s" %
+                parent, name, path
-                                   (name, self.manifestFile))
+            )
-        revision = node.getAttribute('revision') or remote.revision
-        if not revision:
+        default_groups = ["all", "name:%s" % name, "path:%s" % relpath]
-          revision = self._default.revisionExpr
+        groups.extend(set(default_groups).difference(groups))
-        if not revision:
-          raise ManifestParseError('no revision for superproject %s within %s' %
+        if self.IsMirror and node.hasAttribute("force-path"):
-                                   (name, self.manifestFile))
+            if XmlBool(node, "force-path", False):
-        self._superproject = Superproject(self,
+                gitdir = os.path.join(self.topdir, "%s.git" % path)
-                                          name=name,
-                                          remote=remote.ToRemoteSpec(name),
+        project = Project(
-                                          revision=revision)
+            manifest=self,
-      if node.nodeName == 'contactinfo':
+            name=name,
-        bugurl = self._reqatt(node, 'bugurl')
+            remote=remote.ToRemoteSpec(name),
-        # This element can be repeated, later entries will clobber earlier ones.
+            gitdir=gitdir,
-        self._contactinfo = ContactInfo(bugurl)
+            objdir=objdir,
+            worktree=worktree,
-      if node.nodeName == 'remove-project':
+            relpath=relpath,
-        name = self._reqatt(node, 'name')
+            revisionExpr=revisionExpr,
+            revisionId=None,
-        if name in self._projects:
+            rebase=rebase,
-          for p in self._projects[name]:
+            groups=groups,
-            del self._paths[p.relpath]
+            sync_c=sync_c,
-          del self._projects[name]
+            sync_s=sync_s,
+            sync_tags=sync_tags,
-          # If the manifest removes the hooks project, treat it as if it deleted
+            clone_depth=clone_depth,
-          # the repo-hooks element too.
+            upstream=upstream,
-          if repo_hooks_project == name:
+            parent=parent,
-            repo_hooks_project = None
+            dest_branch=dest_branch,
-        elif not XmlBool(node, 'optional', False):
+            use_git_worktrees=use_git_worktrees,
-          raise ManifestParseError('remove-project element specifies non-existent '
+            **extra_proj_attrs,
-                                   'project: %s' % name)
+        )
-    # Store repo hooks project information.
+        for n in node.childNodes:
-    if repo_hooks_project:
+            if n.nodeName == "copyfile":
-      # Store a reference to the Project.
+                self._ParseCopyFile(project, n)
-      try:
+            if n.nodeName == "linkfile":
-        repo_hooks_projects = self._projects[repo_hooks_project]
+                self._ParseLinkFile(project, n)
-      except KeyError:
+            if n.nodeName == "annotation":
-        raise ManifestParseError(
+                self._ParseAnnotation(project, n)
-            'project %s not found for repo-hooks' %
+            if n.nodeName == "project":
-            (repo_hooks_project))
+                project.subprojects.append(
+                    self._ParseProject(n, parent=project)
-      if len(repo_hooks_projects) != 1:
+                )
-        raise ManifestParseError(
-            'internal error parsing repo-hooks in %s' %
+        return project
-            (self.manifestFile))
-      self._repo_hooks_project = repo_hooks_projects[0]
+    def GetProjectPaths(self, name, path, remote):
-      # Store the enabled hooks in the Project object.
+        """Return the paths for a project.
-      self._repo_hooks_project.enabled_repo_hooks = enabled_repo_hooks
+        Args:
-  def _AddMetaProjectMirror(self, m):
+            name: a string, the name of the project.
-    name = None
+            path: a string, the path of the project.
-    m_url = m.GetRemote().url
+            remote: a string, the remote.name of the project.
-    if m_url.endswith('/.git'):
-      raise ManifestParseError('refusing to mirror %s' % m_url)
+        Returns:
+            A tuple of (relpath, worktree, gitdir, objdir, use_git_worktrees)
-    if self._default and self._default.remote:
+            for the project with |name| and |path|.
-      url = self._default.remote.resolvedFetchUrl
+        """
-      if not url.endswith('/'):
+        # The manifest entries might have trailing slashes.  Normalize them to
-        url += '/'
+        # avoid unexpected filesystem behavior since we do string concatenation
-      if m_url.startswith(url):
+        # below.
-        remote = self._default.remote
+        path = path.rstrip("/")
-        name = m_url[len(url):]
+        name = name.rstrip("/")
+        remote = remote.rstrip("/")
-    if name is None:
+        use_git_worktrees = False
-      s = m_url.rindex('/') + 1
+        use_remote_name = self.is_multimanifest
-      manifestUrl = self.manifestProject.config.GetString('remote.origin.url')
+        relpath = path
-      remote = _XmlRemote('origin', fetch=m_url[:s], manifestUrl=manifestUrl)
+        if self.IsMirror:
-      name = m_url[s:]
+            worktree = None
+            gitdir = os.path.join(self.topdir, "%s.git" % name)
-    if name.endswith('.git'):
+            objdir = gitdir
-      name = name[:-4]
+        else:
+            if use_remote_name:
-    if name not in self._projects:
+                namepath = os.path.join(remote, f"{name}.git")
-      m.PreSync()
+            else:
-      gitdir = os.path.join(self.topdir, '%s.git' % name)
+                namepath = f"{name}.git"
-      project = Project(manifest=self,
+            worktree = os.path.join(self.topdir, path).replace("\\", "/")
-                        name=name,
+            gitdir = os.path.join(self.subdir, "projects", "%s.git" % path)
-                        remote=remote.ToRemoteSpec(name),
+            # We allow people to mix git worktrees & non-git worktrees for now.
-                        gitdir=gitdir,
+            # This allows for in situ migration of repo clients.
-                        objdir=gitdir,
+            if os.path.exists(gitdir) or not self.UseGitWorktrees:
-                        worktree=None,
+                objdir = os.path.join(self.repodir, "project-objects", namepath)
-                        relpath=name or None,
+            else:
-                        revisionExpr=m.revisionExpr,
+                use_git_worktrees = True
-                        revisionId=None)
+                gitdir = os.path.join(self.repodir, "worktrees", namepath)
-      self._projects[project.name] = [project]
+                objdir = gitdir
-      self._paths[project.relpath] = project
+        return relpath, worktree, gitdir, objdir, use_git_worktrees
-  def _ParseRemote(self, node):
+    def GetProjectsWithName(self, name, all_manifests=False):
-    """
+        """All projects with |name|.
-    reads a <remote> element from the manifest file
-    """
+        Args:
-    name = self._reqatt(node, 'name')
+            name: a string, the name of the project.
-    alias = node.getAttribute('alias')
+            all_manifests: a boolean, if True, then all manifests are searched.
-    if alias == '':
+                If False, then only this manifest is searched.
-      alias = None
-    fetch = self._reqatt(node, 'fetch')
+        Returns:
-    pushUrl = node.getAttribute('pushurl')
+            A list of Project instances with name |name|.
-    if pushUrl == '':
+        """
-      pushUrl = None
+        if all_manifests:
-    review = node.getAttribute('review')
+            return list(
-    if review == '':
+                itertools.chain.from_iterable(
-      review = None
+                    x._projects.get(name, []) for x in self.all_manifests
-    revision = node.getAttribute('revision')
+                )
-    if revision == '':
+            )
-      revision = None
+        return self._projects.get(name, [])
-    manifestUrl = self.manifestProject.config.GetString('remote.origin.url')
+    def GetSubprojectName(self, parent, submodule_path):
-    remote = _XmlRemote(name, alias, fetch, pushUrl, manifestUrl, review, revision)
+        return os.path.join(parent.name, submodule_path)
-    for n in node.childNodes:
+    def _JoinRelpath(self, parent_relpath, relpath):
-      if n.nodeName == 'annotation':
+        return os.path.join(parent_relpath, relpath)
-        self._ParseAnnotation(remote, n)
+    def _UnjoinRelpath(self, parent_relpath, relpath):
-    return remote
+        return os.path.relpath(relpath, parent_relpath)
-  def _ParseDefault(self, node):
+    def GetSubprojectPaths(self, parent, name, path):
-    """
+        # The manifest entries might have trailing slashes.  Normalize them to
-    reads a <default> element from the manifest file
+        # avoid unexpected filesystem behavior since we do string concatenation
-    """
+        # below.
-    d = _Default()
+        path = path.rstrip("/")
-    d.remote = self._get_remote(node)
+        name = name.rstrip("/")
-    d.revisionExpr = node.getAttribute('revision')
+        relpath = self._JoinRelpath(parent.relpath, path)
-    if d.revisionExpr == '':
+        gitdir = os.path.join(parent.gitdir, "subprojects", "%s.git" % path)
-      d.revisionExpr = None
+        objdir = os.path.join(
+            parent.gitdir, "subproject-objects", "%s.git" % name
-    d.destBranchExpr = node.getAttribute('dest-branch') or None
+        )
-    d.upstreamExpr = node.getAttribute('upstream') or None
+        if self.IsMirror:
+            worktree = None
-    d.sync_j = XmlInt(node, 'sync-j', None)
+        else:
-    if d.sync_j is not None and d.sync_j <= 0:
+            worktree = os.path.join(parent.worktree, path).replace("\\", "/")
-      raise ManifestParseError('%s: sync-j must be greater than 0, not "%s"' %
+        return relpath, worktree, gitdir, objdir
-                               (self.manifestFile, d.sync_j))
+    @staticmethod
-    d.sync_c = XmlBool(node, 'sync-c', False)
+    def _CheckLocalPath(path, dir_ok=False, cwd_dot_ok=False):
-    d.sync_s = XmlBool(node, 'sync-s', False)
+        """Verify |path| is reasonable for use in filesystem paths.
-    d.sync_tags = XmlBool(node, 'sync-tags', True)
-    return d
+        Used with <copyfile> & <linkfile> & <project> elements.
-  def _ParseNotice(self, node):
+        This only validates the |path| in isolation: it does not check against
-    """
+        the current filesystem state.  Thus it is suitable as a first-past in a
-    reads a <notice> element from the manifest file
+        parser.
-    The <notice> element is distinct from other tags in the XML in that the
+        It enforces a number of constraints:
-    data is conveyed between the start and end tag (it's not an empty-element
+        * No empty paths.
-    tag).
+        * No "~" in paths.
+        * No Unicode codepoints that filesystems might elide when normalizing.
-    The white space (carriage returns, indentation) for the notice element is
+        * No relative path components like "." or "..".
-    relevant and is parsed in a way that is based on how python docstrings work.
+        * No absolute paths.
-    In fact, the code is remarkably similar to here:
+        * No ".git" or ".repo*" path components.
-      http://www.python.org/dev/peps/pep-0257/
-    """
+        Args:
-    # Get the data out of the node...
+            path: The path name to validate.
-    notice = node.childNodes[0].data
+            dir_ok: Whether |path| may force a directory (e.g. end in a /).
+            cwd_dot_ok: Whether |path| may be just ".".
-    # Figure out minimum indentation, skipping the first line (the same line
-    # as the <notice> tag)...
+        Returns:
-    minIndent = sys.maxsize
+            None if |path| is OK, a failure message otherwise.
-    lines = notice.splitlines()
+        """
-    for line in lines[1:]:
+        if not path:
-      lstrippedLine = line.lstrip()
+            return "empty paths not allowed"
-      if lstrippedLine:
-        indent = len(line) - len(lstrippedLine)
+        if "~" in path:
-        minIndent = min(indent, minIndent)
+            return "~ not allowed (due to 8.3 filenames on Windows filesystems)"
-    # Strip leading / trailing blank lines and also indentation.
+        path_codepoints = set(path)
-    cleanLines = [lines[0].strip()]
-    for line in lines[1:]:
+        # Some filesystems (like Apple's HFS+) try to normalize Unicode
-      cleanLines.append(line[minIndent:].rstrip())
+        # codepoints which means there are alternative names for ".git".  Reject
+        # paths with these in it as there shouldn't be any reasonable need for
-    # Clear completely blank lines from front and back...
+        # them here. The set of codepoints here was cribbed from jgit's
-    while cleanLines and not cleanLines[0]:
+        # implementation:
-      del cleanLines[0]
+        # https://eclipse.googlesource.com/jgit/jgit/+/9110037e3e9461ff4dac22fee84ef3694ed57648/org.eclipse.jgit/src/org/eclipse/jgit/lib/ObjectChecker.java#884
-    while cleanLines and not cleanLines[-1]:
+        BAD_CODEPOINTS = {
-      del cleanLines[-1]
+            "\u200C",  # ZERO WIDTH NON-JOINER
+            "\u200D",  # ZERO WIDTH JOINER
-    return '\n'.join(cleanLines)
+            "\u200E",  # LEFT-TO-RIGHT MARK
+            "\u200F",  # RIGHT-TO-LEFT MARK
-  def _ParseSubmanifest(self, node):
+            "\u202A",  # LEFT-TO-RIGHT EMBEDDING
-    """Reads a <submanifest> element from the manifest file."""
+            "\u202B",  # RIGHT-TO-LEFT EMBEDDING
-    name = self._reqatt(node, 'name')
+            "\u202C",  # POP DIRECTIONAL FORMATTING
-    remote = node.getAttribute('remote')
+            "\u202D",  # LEFT-TO-RIGHT OVERRIDE
-    if remote == '':
+            "\u202E",  # RIGHT-TO-LEFT OVERRIDE
-      remote = None
+            "\u206A",  # INHIBIT SYMMETRIC SWAPPING
-    project = node.getAttribute('project')
+            "\u206B",  # ACTIVATE SYMMETRIC SWAPPING
-    if project == '':
+            "\u206C",  # INHIBIT ARABIC FORM SHAPING
-      project = None
+            "\u206D",  # ACTIVATE ARABIC FORM SHAPING
-    revision = node.getAttribute('revision')
+            "\u206E",  # NATIONAL DIGIT SHAPES
-    if revision == '':
+            "\u206F",  # NOMINAL DIGIT SHAPES
-      revision = None
+            "\uFEFF",  # ZERO WIDTH NO-BREAK SPACE
-    manifestName = node.getAttribute('manifest-name')
+        }
-    if manifestName == '':
+        if BAD_CODEPOINTS & path_codepoints:
-      manifestName = None
+            # This message is more expansive than reality, but should be fine.
-    groups = ''
+            return "Unicode combining characters not allowed"
-    if node.hasAttribute('groups'):
-      groups = node.getAttribute('groups')
+        # Reject newlines as there shouldn't be any legitmate use for them,
-    groups = self._ParseList(groups)
+        # they'll be confusing to users, and they can easily break tools that
-    default_groups = self._ParseList(node.getAttribute('default-groups'))
+        # expect to be able to iterate over newline delimited lists.  This even
-    path = node.getAttribute('path')
+        # applies to our own code like .repo/project.list.
-    if path == '':
+        if {"\r", "\n"} & path_codepoints:
-      path = None
+            return "Newlines not allowed"
-      if revision:
-        msg = self._CheckLocalPath(revision.split('/')[-1])
+        # Assume paths might be used on case-insensitive filesystems.
+        path = path.lower()
+        # Split up the path by its components.  We can't use os.path.sep
+        # exclusively as some platforms (like Windows) will convert / to \ and
+        # that bypasses all our constructed logic here.  Especially since
+        # manifest authors only use / in their paths.
+        resep = re.compile(r"[/%s]" % re.escape(os.path.sep))
+        # Strip off trailing slashes as those only produce '' elements, and we
+        # use parts to look for individual bad components.
+        parts = resep.split(path.rstrip("/"))
+        # Some people use src="." to create stable links to projects.  Lets
+        # allow that but reject all other uses of "." to keep things simple.
+        if not cwd_dot_ok or parts != ["."]:
+            for part in set(parts):
+                if part in {".", "..", ".git"} or part.startswith(".repo"):
+                    return "bad component: %s" % (part,)
+        if not dir_ok and resep.match(path[-1]):
+            return "dirs not allowed"
+        # NB: The two abspath checks here are to handle platforms with multiple
+        # filesystem path styles (e.g. Windows).
+        norm = os.path.normpath(path)
+        if (
+            norm == ".."
+            or (
+                len(norm) >= 3
+                and norm.startswith("..")
+                and resep.match(norm[0])
+            )
+            or os.path.isabs(norm)
+            or norm.startswith("/")
+        ):
+            return "path cannot be outside"
+    @classmethod
+    def _ValidateFilePaths(cls, element, src, dest):
+        """Verify |src| & |dest| are reasonable for <copyfile> & <linkfile>.
+        We verify the path independent of any filesystem state as we won't have
+        a checkout available to compare to.  i.e. This is for parsing validation
+        purposes only.
+        We'll do full/live sanity checking before we do the actual filesystem
+        modifications in _CopyFile/_LinkFile/etc...
+        """
+        # |dest| is the file we write to or symlink we create.
+        # It is relative to the top of the repo client checkout.
+        msg = cls._CheckLocalPath(dest)
        if msg:
-          raise ManifestInvalidPathError(
+            raise ManifestInvalidPathError(
-              '<submanifest> invalid "revision": %s: %s' % (revision, msg))
+                '<%s> invalid "dest": %s: %s' % (element, dest, msg)
-      else:
+            )
-        msg = self._CheckLocalPath(name)
+        # |src| is the file we read from or path we point to for symlinks.
+        # It is relative to the top of the git project checkout.
+        is_linkfile = element == "linkfile"
+        msg = cls._CheckLocalPath(
+            src, dir_ok=is_linkfile, cwd_dot_ok=is_linkfile
+        )
        if msg:
-          raise ManifestInvalidPathError(
+            raise ManifestInvalidPathError(
-              '<submanifest> invalid "name": %s: %s' % (name, msg))
+                '<%s> invalid "src": %s: %s' % (element, src, msg)
-    else:
+            )
-      msg = self._CheckLocalPath(path)
-      if msg:
+    def _ParseCopyFile(self, project, node):
-        raise ManifestInvalidPathError(
+        src = self._reqatt(node, "src")
-            '<submanifest> invalid "path": %s: %s' % (path, msg))
+        dest = self._reqatt(node, "dest")
+        if not self.IsMirror:
-    submanifest = _XmlSubmanifest(name, remote, project, revision, manifestName,
+            # src is project relative;
-                                  groups, default_groups, path, self)
+            # dest is relative to the top of the tree.
+            # We only validate paths if we actually plan to process them.
-    for n in node.childNodes:
+            self._ValidateFilePaths("copyfile", src, dest)
-      if n.nodeName == 'annotation':
+            project.AddCopyFile(src, dest, self.topdir)
-        self._ParseAnnotation(submanifest, n)
+    def _ParseLinkFile(self, project, node):
-    return submanifest
+        src = self._reqatt(node, "src")
+        dest = self._reqatt(node, "dest")
-  def _JoinName(self, parent_name, name):
+        if not self.IsMirror:
-    return os.path.join(parent_name, name)
+            # src is project relative;
+            # dest is relative to the top of the tree.
-  def _UnjoinName(self, parent_name, name):
+            # We only validate paths if we actually plan to process them.
-    return os.path.relpath(name, parent_name)
+            self._ValidateFilePaths("linkfile", src, dest)
+            project.AddLinkFile(src, dest, self.topdir)
-  def _ParseProject(self, node, parent=None, **extra_proj_attrs):
-    """
+    def _ParseAnnotation(self, element, node):
-    reads a <project> element from the manifest file
+        name = self._reqatt(node, "name")
-    """
+        value = self._reqatt(node, "value")
-    name = self._reqatt(node, 'name')
-    msg = self._CheckLocalPath(name, dir_ok=True)
-    if msg:
-      raise ManifestInvalidPathError(
-          '<project> invalid "name": %s: %s' % (name, msg))
-    if parent:
-      name = self._JoinName(parent.name, name)
-    remote = self._get_remote(node)
-    if remote is None:
-      remote = self._default.remote
-    if remote is None:
-      raise ManifestParseError("no remote for project %s within %s" %
-                               (name, self.manifestFile))
-    revisionExpr = node.getAttribute('revision') or remote.revision
-    if not revisionExpr:
-      revisionExpr = self._default.revisionExpr
-    if not revisionExpr:
-      raise ManifestParseError("no revision for project %s within %s" %
-                               (name, self.manifestFile))
-    path = node.getAttribute('path')
-    if not path:
-      path = name
-    else:
-      # NB: The "." project is handled specially in Project.Sync_LocalHalf.
-      msg = self._CheckLocalPath(path, dir_ok=True, cwd_dot_ok=True)
-      if msg:
-        raise ManifestInvalidPathError(
-            '<project> invalid "path": %s: %s' % (path, msg))
-    rebase = XmlBool(node, 'rebase', True)
-    sync_c = XmlBool(node, 'sync-c', False)
-    sync_s = XmlBool(node, 'sync-s', self._default.sync_s)
-    sync_tags = XmlBool(node, 'sync-tags', self._default.sync_tags)
-    clone_depth = XmlInt(node, 'clone-depth')
-    if clone_depth is not None and clone_depth <= 0:
-      raise ManifestParseError('%s: clone-depth must be greater than 0, not "%s"' %
-                               (self.manifestFile, clone_depth))
-    dest_branch = node.getAttribute('dest-branch') or self._default.destBranchExpr
-    upstream = node.getAttribute('upstream') or self._default.upstreamExpr
-    groups = ''
-    if node.hasAttribute('groups'):
-      groups = node.getAttribute('groups')
-    groups = self._ParseList(groups)
-    if parent is None:
-      relpath, worktree, gitdir, objdir, use_git_worktrees = \
-          self.GetProjectPaths(name, path, remote.name)
-    else:
-      use_git_worktrees = False
-      relpath, worktree, gitdir, objdir = \
-          self.GetSubprojectPaths(parent, name, path)
-    default_groups = ['all', 'name:%s' % name, 'path:%s' % relpath]
-    groups.extend(set(default_groups).difference(groups))
-    if self.IsMirror and node.hasAttribute('force-path'):
-      if XmlBool(node, 'force-path', False):
-        gitdir = os.path.join(self.topdir, '%s.git' % path)
-    project = Project(manifest=self,
-                      name=name,
-                      remote=remote.ToRemoteSpec(name),
-                      gitdir=gitdir,
-                      objdir=objdir,
-                      worktree=worktree,
-                      relpath=relpath,
-                      revisionExpr=revisionExpr,
-                      revisionId=None,
-                      rebase=rebase,
-                      groups=groups,
-                      sync_c=sync_c,
-                      sync_s=sync_s,
-                      sync_tags=sync_tags,
-                      clone_depth=clone_depth,
-                      upstream=upstream,
-                      parent=parent,
-                      dest_branch=dest_branch,
-                      use_git_worktrees=use_git_worktrees,
-                      **extra_proj_attrs)
-    for n in node.childNodes:
-      if n.nodeName == 'copyfile':
-        self._ParseCopyFile(project, n)
-      if n.nodeName == 'linkfile':
-        self._ParseLinkFile(project, n)
-      if n.nodeName == 'annotation':
-        self._ParseAnnotation(project, n)
-      if n.nodeName == 'project':
-        project.subprojects.append(self._ParseProject(n, parent=project))
-    return project
-  def GetProjectPaths(self, name, path, remote):
-    """Return the paths for a project.
-    Args:
-      name: a string, the name of the project.
-      path: a string, the path of the project.
-      remote: a string, the remote.name of the project.
-    Returns:
-      A tuple of (relpath, worktree, gitdir, objdir, use_git_worktrees) for the
-      project with |name| and |path|.
-    """
-    # The manifest entries might have trailing slashes.  Normalize them to avoid
-    # unexpected filesystem behavior since we do string concatenation below.
-    path = path.rstrip('/')
-    name = name.rstrip('/')
-    remote = remote.rstrip('/')
-    use_git_worktrees = False
-    use_remote_name = self.is_multimanifest
-    relpath = path
-    if self.IsMirror:
-      worktree = None
-      gitdir = os.path.join(self.topdir, '%s.git' % name)
-      objdir = gitdir
-    else:
-      if use_remote_name:
-        namepath = os.path.join(remote, f'{name}.git')
-      else:
-        namepath = f'{name}.git'
-      worktree = os.path.join(self.topdir, path).replace('\\', '/')
-      gitdir = os.path.join(self.subdir, 'projects', '%s.git' % path)
-      # We allow people to mix git worktrees & non-git worktrees for now.
-      # This allows for in situ migration of repo clients.
-      if os.path.exists(gitdir) or not self.UseGitWorktrees:
-        objdir = os.path.join(self.repodir, 'project-objects', namepath)
-      else:
-        use_git_worktrees = True
-        gitdir = os.path.join(self.repodir, 'worktrees', namepath)
-        objdir = gitdir
-    return relpath, worktree, gitdir, objdir, use_git_worktrees
-  def GetProjectsWithName(self, name, all_manifests=False):
-    """All projects with |name|.
-    Args:
-      name: a string, the name of the project.
-      all_manifests: a boolean, if True, then all manifests are searched. If
-                     False, then only this manifest is searched.
-    Returns:
-      A list of Project instances with name |name|.
-    """
-    if all_manifests:
-      return list(itertools.chain.from_iterable(
-          x._projects.get(name, []) for x in self.all_manifests))
-    return self._projects.get(name, [])
-  def GetSubprojectName(self, parent, submodule_path):
-    return os.path.join(parent.name, submodule_path)
-  def _JoinRelpath(self, parent_relpath, relpath):
-    return os.path.join(parent_relpath, relpath)
-  def _UnjoinRelpath(self, parent_relpath, relpath):
-    return os.path.relpath(relpath, parent_relpath)
-  def GetSubprojectPaths(self, parent, name, path):
-    # The manifest entries might have trailing slashes.  Normalize them to avoid
-    # unexpected filesystem behavior since we do string concatenation below.
-    path = path.rstrip('/')
-    name = name.rstrip('/')
-    relpath = self._JoinRelpath(parent.relpath, path)
-    gitdir = os.path.join(parent.gitdir, 'subprojects', '%s.git' % path)
-    objdir = os.path.join(parent.gitdir, 'subproject-objects', '%s.git' % name)
-    if self.IsMirror:
-      worktree = None
-    else:
-      worktree = os.path.join(parent.worktree, path).replace('\\', '/')
-    return relpath, worktree, gitdir, objdir
-  @staticmethod
-  def _CheckLocalPath(path, dir_ok=False, cwd_dot_ok=False):
-    """Verify |path| is reasonable for use in filesystem paths.
-    Used with <copyfile> & <linkfile> & <project> elements.
-    This only validates the |path| in isolation: it does not check against the
-    current filesystem state.  Thus it is suitable as a first-past in a parser.
-    It enforces a number of constraints:
-    * No empty paths.
-    * No "~" in paths.
-    * No Unicode codepoints that filesystems might elide when normalizing.
-    * No relative path components like "." or "..".
-    * No absolute paths.
-    * No ".git" or ".repo*" path components.
-    Args:
-      path: The path name to validate.
-      dir_ok: Whether |path| may force a directory (e.g. end in a /).
-      cwd_dot_ok: Whether |path| may be just ".".
-    Returns:
-      None if |path| is OK, a failure message otherwise.
-    """
-    if not path:
-      return 'empty paths not allowed'
-    if '~' in path:
-      return '~ not allowed (due to 8.3 filenames on Windows filesystems)'
-    path_codepoints = set(path)
-    # Some filesystems (like Apple's HFS+) try to normalize Unicode codepoints
-    # which means there are alternative names for ".git".  Reject paths with
-    # these in it as there shouldn't be any reasonable need for them here.
-    # The set of codepoints here was cribbed from jgit's implementation:
-    # https://eclipse.googlesource.com/jgit/jgit/+/9110037e3e9461ff4dac22fee84ef3694ed57648/org.eclipse.jgit/src/org/eclipse/jgit/lib/ObjectChecker.java#884
-    BAD_CODEPOINTS = {
-        u'\u200C',  # ZERO WIDTH NON-JOINER
-        u'\u200D',  # ZERO WIDTH JOINER
-        u'\u200E',  # LEFT-TO-RIGHT MARK
-        u'\u200F',  # RIGHT-TO-LEFT MARK
-        u'\u202A',  # LEFT-TO-RIGHT EMBEDDING
-        u'\u202B',  # RIGHT-TO-LEFT EMBEDDING
-        u'\u202C',  # POP DIRECTIONAL FORMATTING
-        u'\u202D',  # LEFT-TO-RIGHT OVERRIDE
-        u'\u202E',  # RIGHT-TO-LEFT OVERRIDE
-        u'\u206A',  # INHIBIT SYMMETRIC SWAPPING
-        u'\u206B',  # ACTIVATE SYMMETRIC SWAPPING
-        u'\u206C',  # INHIBIT ARABIC FORM SHAPING
-        u'\u206D',  # ACTIVATE ARABIC FORM SHAPING
-        u'\u206E',  # NATIONAL DIGIT SHAPES
-        u'\u206F',  # NOMINAL DIGIT SHAPES
-        u'\uFEFF',  # ZERO WIDTH NO-BREAK SPACE
-    }
-    if BAD_CODEPOINTS & path_codepoints:
-      # This message is more expansive than reality, but should be fine.
-      return 'Unicode combining characters not allowed'
-    # Reject newlines as there shouldn't be any legitmate use for them, they'll
-    # be confusing to users, and they can easily break tools that expect to be
-    # able to iterate over newline delimited lists.  This even applies to our
-    # own code like .repo/project.list.
-    if {'\r', '\n'} & path_codepoints:
-      return 'Newlines not allowed'
-    # Assume paths might be used on case-insensitive filesystems.
-    path = path.lower()
-    # Split up the path by its components.  We can't use os.path.sep exclusively
-    # as some platforms (like Windows) will convert / to \ and that bypasses all
-    # our constructed logic here.  Especially since manifest authors only use
-    # / in their paths.
-    resep = re.compile(r'[/%s]' % re.escape(os.path.sep))
-    # Strip off trailing slashes as those only produce '' elements, and we use
-    # parts to look for individual bad components.
-    parts = resep.split(path.rstrip('/'))
-    # Some people use src="." to create stable links to projects.  Lets allow
-    # that but reject all other uses of "." to keep things simple.
-    if not cwd_dot_ok or parts != ['.']:
-      for part in set(parts):
-        if part in {'.', '..', '.git'} or part.startswith('.repo'):
-          return 'bad component: %s' % (part,)
-    if not dir_ok and resep.match(path[-1]):
-      return 'dirs not allowed'
-    # NB: The two abspath checks here are to handle platforms with multiple
-    # filesystem path styles (e.g. Windows).
-    norm = os.path.normpath(path)
-    if (norm == '..' or
-        (len(norm) >= 3 and norm.startswith('..') and resep.match(norm[0])) or
-        os.path.isabs(norm) or
-        norm.startswith('/')):
-      return 'path cannot be outside'
-  @classmethod
-  def _ValidateFilePaths(cls, element, src, dest):
-    """Verify |src| & |dest| are reasonable for <copyfile> & <linkfile>.
-    We verify the path independent of any filesystem state as we won't have a
-    checkout available to compare to.  i.e. This is for parsing validation
-    purposes only.
-    We'll do full/live sanity checking before we do the actual filesystem
-    modifications in _CopyFile/_LinkFile/etc...
-    """
-    # |dest| is the file we write to or symlink we create.
-    # It is relative to the top of the repo client checkout.
-    msg = cls._CheckLocalPath(dest)
-    if msg:
-      raise ManifestInvalidPathError(
-          '<%s> invalid "dest": %s: %s' % (element, dest, msg))
-    # |src| is the file we read from or path we point to for symlinks.
-    # It is relative to the top of the git project checkout.
-    is_linkfile = element == 'linkfile'
-    msg = cls._CheckLocalPath(src, dir_ok=is_linkfile, cwd_dot_ok=is_linkfile)
-    if msg:
-      raise ManifestInvalidPathError(
-          '<%s> invalid "src": %s: %s' % (element, src, msg))
-  def _ParseCopyFile(self, project, node):
-    src = self._reqatt(node, 'src')
-    dest = self._reqatt(node, 'dest')
-    if not self.IsMirror:
-      # src is project relative;
-      # dest is relative to the top of the tree.
-      # We only validate paths if we actually plan to process them.
-      self._ValidateFilePaths('copyfile', src, dest)
-      project.AddCopyFile(src, dest, self.topdir)
-  def _ParseLinkFile(self, project, node):
-    src = self._reqatt(node, 'src')
-    dest = self._reqatt(node, 'dest')
-    if not self.IsMirror:
-      # src is project relative;
-      # dest is relative to the top of the tree.
-      # We only validate paths if we actually plan to process them.
-      self._ValidateFilePaths('linkfile', src, dest)
-      project.AddLinkFile(src, dest, self.topdir)
-  def _ParseAnnotation(self, element, node):
-    name = self._reqatt(node, 'name')
-    value = self._reqatt(node, 'value')
-    try:
-      keep = self._reqatt(node, 'keep').lower()
-    except ManifestParseError:
-      keep = "true"
-    if keep != "true" and keep != "false":
-      raise ManifestParseError('optional "keep" attribute must be '
-                               '"true" or "false"')
-    element.AddAnnotation(name, value, keep)
-  def _get_remote(self, node):
-    name = node.getAttribute('remote')
-    if not name:
-      return None
-    v = self._remotes.get(name)
-    if not v:
-      raise ManifestParseError("remote %s not defined in %s" %
-                               (name, self.manifestFile))
-    return v
-  def _reqatt(self, node, attname):
-    """
-    reads a required attribute from the node.
-    """
-    v = node.getAttribute(attname)
-    if not v:
-      raise ManifestParseError("no %s in <%s> within %s" %
-                               (attname, node.nodeName, self.manifestFile))
-    return v
-  def projectsDiff(self, manifest):
-    """return the projects differences between two manifests.
-    The diff will be from self to given manifest.
-    """
-    fromProjects = self.paths
-    toProjects = manifest.paths
-    fromKeys = sorted(fromProjects.keys())
-    toKeys = sorted(toProjects.keys())
-    diff = {'added': [], 'removed': [], 'missing': [], 'changed': [], 'unreachable': []}
-    for proj in fromKeys:
-      if proj not in toKeys:
-        diff['removed'].append(fromProjects[proj])
-      elif not fromProjects[proj].Exists:
-        diff['missing'].append(toProjects[proj])
-        toKeys.remove(proj)
-      else:
-        fromProj = fromProjects[proj]
-        toProj = toProjects[proj]
        try:
-          fromRevId = fromProj.GetCommitRevisionId()
+            keep = self._reqatt(node, "keep").lower()
-          toRevId = toProj.GetCommitRevisionId()
+        except ManifestParseError:
-        except ManifestInvalidRevisionError:
+            keep = "true"
-          diff['unreachable'].append((fromProj, toProj))
+        if keep != "true" and keep != "false":
-        else:
+            raise ManifestParseError(
-          if fromRevId != toRevId:
+                'optional "keep" attribute must be ' '"true" or "false"'
-            diff['changed'].append((fromProj, toProj))
+            )
-        toKeys.remove(proj)
+        element.AddAnnotation(name, value, keep)
-    for proj in toKeys:
+    def _get_remote(self, node):
-      diff['added'].append(toProjects[proj])
+        name = node.getAttribute("remote")
+        if not name:
-    return diff
+            return None
+        v = self._remotes.get(name)
+        if not v:
+            raise ManifestParseError(
+                "remote %s not defined in %s" % (name, self.manifestFile)
+            )
+        return v
+    def _reqatt(self, node, attname):
+        """
+        reads a required attribute from the node.
+        """
+        v = node.getAttribute(attname)
+        if not v:
+            raise ManifestParseError(
+                "no %s in <%s> within %s"
+                % (attname, node.nodeName, self.manifestFile)
+            )
+        return v
+    def projectsDiff(self, manifest):
+        """return the projects differences between two manifests.
+        The diff will be from self to given manifest.
+        """
+        fromProjects = self.paths
+        toProjects = manifest.paths
+        fromKeys = sorted(fromProjects.keys())
+        toKeys = sorted(toProjects.keys())
+        diff = {
+            "added": [],
+            "removed": [],
+            "missing": [],
+            "changed": [],
+            "unreachable": [],
+        }
+        for proj in fromKeys:
+            if proj not in toKeys:
+                diff["removed"].append(fromProjects[proj])
+            elif not fromProjects[proj].Exists:
+                diff["missing"].append(toProjects[proj])
+                toKeys.remove(proj)
+            else:
+                fromProj = fromProjects[proj]
+                toProj = toProjects[proj]
+                try:
+                    fromRevId = fromProj.GetCommitRevisionId()
+                    toRevId = toProj.GetCommitRevisionId()
+                except ManifestInvalidRevisionError:
+                    diff["unreachable"].append((fromProj, toProj))
+                else:
+                    if fromRevId != toRevId:
+                        diff["changed"].append((fromProj, toProj))
+                toKeys.remove(proj)
+        for proj in toKeys:
+            diff["added"].append(toProjects[proj])
+        return diff
 class GitcManifest(XmlManifest):
-  """Parser for GitC (git-in-the-cloud) manifests."""
+    """Parser for GitC (git-in-the-cloud) manifests."""
-  def _ParseProject(self, node, parent=None):
+    def _ParseProject(self, node, parent=None):
-    """Override _ParseProject and add support for GITC specific attributes."""
+        """Override _ParseProject and add support for GITC specific attributes."""  # noqa: E501
-    return super()._ParseProject(
+        return super()._ParseProject(
-        node, parent=parent, old_revision=node.getAttribute('old-revision'))
+            node, parent=parent, old_revision=node.getAttribute("old-revision")
+        )
-  def _output_manifest_project_extras(self, p, e):
+    def _output_manifest_project_extras(self, p, e):
-    """Output GITC Specific Project attributes"""
+        """Output GITC Specific Project attributes"""
-    if p.old_revision:
+        if p.old_revision:
-      e.setAttribute('old-revision', str(p.old_revision))
+            e.setAttribute("old-revision", str(p.old_revision))
 class RepoClient(XmlManifest):
-  """Manages a repo client checkout."""
+    """Manages a repo client checkout."""
-  def __init__(self, repodir, manifest_file=None, submanifest_path='', **kwargs):
+    def __init__(
-    """Initialize.
+        self, repodir, manifest_file=None, submanifest_path="", **kwargs
+    ):
-    Args:
+        """Initialize.
-      repodir: Path to the .repo/ dir for holding all internal checkout state.
-          It must be in the top directory of the repo client checkout.
+        Args:
-      manifest_file: Full path to the manifest file to parse.  This will usually
+            repodir: Path to the .repo/ dir for holding all internal checkout
-          be |repodir|/|MANIFEST_FILE_NAME|.
+                state. It must be in the top directory of the repo client
-      submanifest_path: The submanifest root relative to the repo root.
+                checkout.
-      **kwargs: Additional keyword arguments, passed to XmlManifest.
+            manifest_file: Full path to the manifest file to parse.  This will
-    """
+                usually be |repodir|/|MANIFEST_FILE_NAME|.
-    self.isGitcClient = False
+            submanifest_path: The submanifest root relative to the repo root.
-    submanifest_path = submanifest_path or ''
+            **kwargs: Additional keyword arguments, passed to XmlManifest.
-    if submanifest_path:
+        """
-      self._CheckLocalPath(submanifest_path)
+        self.isGitcClient = False
-      prefix = os.path.join(repodir, SUBMANIFEST_DIR, submanifest_path)
+        submanifest_path = submanifest_path or ""
-    else:
+        if submanifest_path:
-      prefix = repodir
+            self._CheckLocalPath(submanifest_path)
+            prefix = os.path.join(repodir, SUBMANIFEST_DIR, submanifest_path)
-    if os.path.exists(os.path.join(prefix, LOCAL_MANIFEST_NAME)):
+        else:
-      print('error: %s is not supported; put local manifests in `%s` instead' %
+            prefix = repodir
-            (LOCAL_MANIFEST_NAME, os.path.join(prefix, LOCAL_MANIFESTS_DIR_NAME)),
-            file=sys.stderr)
+        if os.path.exists(os.path.join(prefix, LOCAL_MANIFEST_NAME)):
-      sys.exit(1)
+            print(
+                "error: %s is not supported; put local manifests in `%s` "
-    if manifest_file is None:
+                "instead"
-        manifest_file = os.path.join(prefix, MANIFEST_FILE_NAME)
+                % (
-    local_manifests = os.path.abspath(os.path.join(prefix, LOCAL_MANIFESTS_DIR_NAME))
+                    LOCAL_MANIFEST_NAME,
-    super().__init__(repodir, manifest_file, local_manifests,
+                    os.path.join(prefix, LOCAL_MANIFESTS_DIR_NAME),
-                     submanifest_path=submanifest_path, **kwargs)
+                ),
+                file=sys.stderr,
-    # TODO: Completely separate manifest logic out of the client.
+            )
-    self.manifest = self
+            sys.exit(1)
+        if manifest_file is None:
+            manifest_file = os.path.join(prefix, MANIFEST_FILE_NAME)
+        local_manifests = os.path.abspath(
+            os.path.join(prefix, LOCAL_MANIFESTS_DIR_NAME)
+        )
+        super().__init__(
+            repodir,
+            manifest_file,
+            local_manifests,
+            submanifest_path=submanifest_path,
+            **kwargs,
+        )
+        # TODO: Completely separate manifest logic out of the client.
+        self.manifest = self
 class GitcClient(RepoClient, GitcManifest):
-  """Manages a GitC client checkout."""
+    """Manages a GitC client checkout."""
-  def __init__(self, repodir, gitc_client_name):
+    def __init__(self, repodir, gitc_client_name):
-    """Initialize the GitcManifest object."""
+        """Initialize the GitcManifest object."""
-    self.gitc_client_name = gitc_client_name
+        self.gitc_client_name = gitc_client_name
-    self.gitc_client_dir = os.path.join(gitc_utils.get_gitc_manifest_dir(),
+        self.gitc_client_dir = os.path.join(
-                                        gitc_client_name)
+            gitc_utils.get_gitc_manifest_dir(), gitc_client_name
+        )
-    super().__init__(repodir, os.path.join(self.gitc_client_dir, '.manifest'))
-    self.isGitcClient = True
+        super().__init__(
+            repodir, os.path.join(self.gitc_client_dir, ".manifest")
+        )
+        self.isGitcClient = True
diff --git a/pager.py b/pager.py
index 438597ef..dbd5ae85 100644
--- a/pager.py
+++ b/pager.py
@@ -26,102 +26,101 @@ old_stderr = None
 def RunPager(globalConfig):
-  if not os.isatty(0) or not os.isatty(1):
+    if not os.isatty(0) or not os.isatty(1):
-    return
+        return
-  pager = _SelectPager(globalConfig)
+    pager = _SelectPager(globalConfig)
-  if pager == '' or pager == 'cat':
+    if pager == "" or pager == "cat":
-    return
+        return
-  if platform_utils.isWindows():
+    if platform_utils.isWindows():
-    _PipePager(pager)
+        _PipePager(pager)
-  else:
+    else:
-    _ForkPager(pager)
+        _ForkPager(pager)
 def TerminatePager():
-  global pager_process, old_stdout, old_stderr
+    global pager_process, old_stdout, old_stderr
-  if pager_process:
+    if pager_process:
-    sys.stdout.flush()
+        sys.stdout.flush()
-    sys.stderr.flush()
+        sys.stderr.flush()
-    pager_process.stdin.close()
+        pager_process.stdin.close()
-    pager_process.wait()
+        pager_process.wait()
-    pager_process = None
+        pager_process = None
-    # Restore initial stdout/err in case there is more output in this process
+        # Restore initial stdout/err in case there is more output in this
-    # after shutting down the pager process
+        # process after shutting down the pager process.
-    sys.stdout = old_stdout
+        sys.stdout = old_stdout
-    sys.stderr = old_stderr
+        sys.stderr = old_stderr
 def _PipePager(pager):
-  global pager_process, old_stdout, old_stderr
+    global pager_process, old_stdout, old_stderr
-  assert pager_process is None, "Only one active pager process at a time"
+    assert pager_process is None, "Only one active pager process at a time"
-  # Create pager process, piping stdout/err into its stdin
+    # Create pager process, piping stdout/err into its stdin.
-  try:
+    try:
-    pager_process = subprocess.Popen([pager], stdin=subprocess.PIPE, stdout=sys.stdout,
+        pager_process = subprocess.Popen(
-                                     stderr=sys.stderr)
+            [pager], stdin=subprocess.PIPE, stdout=sys.stdout, stderr=sys.stderr
-  except FileNotFoundError:
+        )
-    sys.exit(f'fatal: cannot start pager "{pager}"')
+    except FileNotFoundError:
-  old_stdout = sys.stdout
+        sys.exit(f'fatal: cannot start pager "{pager}"')
-  old_stderr = sys.stderr
+    old_stdout = sys.stdout
-  sys.stdout = pager_process.stdin
+    old_stderr = sys.stderr
-  sys.stderr = pager_process.stdin
+    sys.stdout = pager_process.stdin
+    sys.stderr = pager_process.stdin
 def _ForkPager(pager):
-  global active
+    global active
-  # This process turns into the pager; a child it forks will
+    # This process turns into the pager; a child it forks will
-  # do the real processing and output back to the pager. This
+    # do the real processing and output back to the pager. This
-  # is necessary to keep the pager in control of the tty.
+    # is necessary to keep the pager in control of the tty.
-  #
+    try:
-  try:
+        r, w = os.pipe()
-    r, w = os.pipe()
+        pid = os.fork()
-    pid = os.fork()
+        if not pid:
-    if not pid:
+            os.dup2(w, 1)
-      os.dup2(w, 1)
+            os.dup2(w, 2)
-      os.dup2(w, 2)
+            os.close(r)
-      os.close(r)
+            os.close(w)
-      os.close(w)
+            active = True
-      active = True
+            return
-      return
+        os.dup2(r, 0)
-    os.dup2(r, 0)
+        os.close(r)
-    os.close(r)
+        os.close(w)
-    os.close(w)
+        _BecomePager(pager)
-    _BecomePager(pager)
+    except Exception:
-  except Exception:
+        print("fatal: cannot start pager '%s'" % pager, file=sys.stderr)
-    print("fatal: cannot start pager '%s'" % pager, file=sys.stderr)
+        sys.exit(255)
-    sys.exit(255)
 def _SelectPager(globalConfig):
-  try:
+    try:
-    return os.environ['GIT_PAGER']
+        return os.environ["GIT_PAGER"]
-  except KeyError:
+    except KeyError:
-    pass
+        pass
-  pager = globalConfig.GetString('core.pager')
+    pager = globalConfig.GetString("core.pager")
-  if pager:
+    if pager:
-    return pager
+        return pager
-  try:
+    try:
-    return os.environ['PAGER']
+        return os.environ["PAGER"]
-  except KeyError:
+    except KeyError:
-    pass
+        pass
-  return 'less'
+    return "less"
 def _BecomePager(pager):
-  # Delaying execution of the pager until we have output
+    # Delaying execution of the pager until we have output
-  # ready works around a long-standing bug in popularly
+    # ready works around a long-standing bug in popularly
-  # available versions of 'less', a better 'more'.
+    # available versions of 'less', a better 'more'.
-  #
+    _a, _b, _c = select.select([0], [], [0])
-  _a, _b, _c = select.select([0], [], [0])
+    os.environ["LESS"] = "FRSX"
-  os.environ['LESS'] = 'FRSX'
+    try:
-  try:
+        os.execvp(pager, [pager])
-    os.execvp(pager, [pager])
+    except OSError:
-  except OSError:
+        os.execv("/bin/sh", ["sh", "-c", pager])
-    os.execv('/bin/sh', ['sh', '-c', pager])
diff --git a/platform_utils.py b/platform_utils.py
index 0203249a..2c48e622 100644
--- a/platform_utils.py
+++ b/platform_utils.py
@@ -20,246 +20,264 @@ import stat
 def isWindows():
-  """ Returns True when running with the native port of Python for Windows,
+    """Returns True when running with the native port of Python for Windows,
-  False when running on any other platform (including the Cygwin port of
+    False when running on any other platform (including the Cygwin port of
-  Python).
+    Python).
-  """
+    """
-  # Note: The cygwin port of Python returns "CYGWIN_NT_xxx"
+    # Note: The cygwin port of Python returns "CYGWIN_NT_xxx"
-  return platform.system() == "Windows"
+    return platform.system() == "Windows"
 def symlink(source, link_name):
-  """Creates a symbolic link pointing to source named link_name.
+    """Creates a symbolic link pointing to source named link_name.
-  Note: On Windows, source must exist on disk, as the implementation needs
-  to know whether to create a "File" or a "Directory" symbolic link.
+    Note: On Windows, source must exist on disk, as the implementation needs
-  """
+    to know whether to create a "File" or a "Directory" symbolic link.
-  if isWindows():
+    """
-    import platform_utils_win32
+    if isWindows():
-    source = _validate_winpath(source)
+        import platform_utils_win32
-    link_name = _validate_winpath(link_name)
-    target = os.path.join(os.path.dirname(link_name), source)
+        source = _validate_winpath(source)
-    if isdir(target):
+        link_name = _validate_winpath(link_name)
-      platform_utils_win32.create_dirsymlink(_makelongpath(source), link_name)
+        target = os.path.join(os.path.dirname(link_name), source)
+        if isdir(target):
+            platform_utils_win32.create_dirsymlink(
+                _makelongpath(source), link_name
+            )
+        else:
+            platform_utils_win32.create_filesymlink(
+                _makelongpath(source), link_name
+            )
    else:
-      platform_utils_win32.create_filesymlink(_makelongpath(source), link_name)
+        return os.symlink(source, link_name)
-  else:
-    return os.symlink(source, link_name)
 def _validate_winpath(path):
-  path = os.path.normpath(path)
+    path = os.path.normpath(path)
-  if _winpath_is_valid(path):
+    if _winpath_is_valid(path):
-    return path
+        return path
-  raise ValueError("Path \"%s\" must be a relative path or an absolute "
+    raise ValueError(
-                   "path starting with a drive letter".format(path))
+        'Path "{}" must be a relative path or an absolute '
+        "path starting with a drive letter".format(path)
+    )
 def _winpath_is_valid(path):
-  """Windows only: returns True if path is relative (e.g. ".\\foo") or is
+    """Windows only: returns True if path is relative (e.g. ".\\foo") or is
-  absolute including a drive letter (e.g. "c:\\foo"). Returns False if path
+    absolute including a drive letter (e.g. "c:\\foo"). Returns False if path
-  is ambiguous (e.g. "x:foo" or "\\foo").
+    is ambiguous (e.g. "x:foo" or "\\foo").
-  """
+    """
-  assert isWindows()
+    assert isWindows()
-  path = os.path.normpath(path)
+    path = os.path.normpath(path)
-  drive, tail = os.path.splitdrive(path)
+    drive, tail = os.path.splitdrive(path)
-  if tail:
+    if tail:
-    if not drive:
+        if not drive:
-      return tail[0] != os.sep  # "\\foo" is invalid
+            return tail[0] != os.sep  # "\\foo" is invalid
+        else:
+            return tail[0] == os.sep  # "x:foo" is invalid
    else:
-      return tail[0] == os.sep  # "x:foo" is invalid
+        return not drive  # "x:" is invalid
-  else:
-    return not drive  # "x:" is invalid
 def _makelongpath(path):
-  """Return the input path normalized to support the Windows long path syntax
+    """Return the input path normalized to support the Windows long path syntax
-  ("\\\\?\\" prefix) if needed, i.e. if the input path is longer than the
+    ("\\\\?\\" prefix) if needed, i.e. if the input path is longer than the
-  MAX_PATH limit.
+    MAX_PATH limit.
-  """
+    """
-  if isWindows():
+    if isWindows():
-    # Note: MAX_PATH is 260, but, for directories, the maximum value is actually 246.
+        # Note: MAX_PATH is 260, but, for directories, the maximum value is
-    if len(path) < 246:
+        # actually 246.
-      return path
+        if len(path) < 246:
-    if path.startswith(u"\\\\?\\"):
+            return path
-      return path
+        if path.startswith("\\\\?\\"):
-    if not os.path.isabs(path):
+            return path
-      return path
+        if not os.path.isabs(path):
-    # Append prefix and ensure unicode so that the special longpath syntax
+            return path
-    # is supported by underlying Win32 API calls
+        # Append prefix and ensure unicode so that the special longpath syntax
-    return u"\\\\?\\" + os.path.normpath(path)
+        # is supported by underlying Win32 API calls
-  else:
+        return "\\\\?\\" + os.path.normpath(path)
-    return path
+    else:
+        return path
 def rmtree(path, ignore_errors=False):
-  """shutil.rmtree(path) wrapper with support for long paths on Windows.
+    """shutil.rmtree(path) wrapper with support for long paths on Windows.
-  Availability: Unix, Windows."""
+    Availability: Unix, Windows.
-  onerror = None
+    """
-  if isWindows():
+    onerror = None
-    path = _makelongpath(path)
+    if isWindows():
-    onerror = handle_rmtree_error
+        path = _makelongpath(path)
-  shutil.rmtree(path, ignore_errors=ignore_errors, onerror=onerror)
+        onerror = handle_rmtree_error
+    shutil.rmtree(path, ignore_errors=ignore_errors, onerror=onerror)
 def handle_rmtree_error(function, path, excinfo):
-  # Allow deleting read-only files
+    # Allow deleting read-only files.
-  os.chmod(path, stat.S_IWRITE)
+    os.chmod(path, stat.S_IWRITE)
-  function(path)
+    function(path)
 def rename(src, dst):
-  """os.rename(src, dst) wrapper with support for long paths on Windows.
+    """os.rename(src, dst) wrapper with support for long paths on Windows.
-  Availability: Unix, Windows."""
+    Availability: Unix, Windows.
-  if isWindows():
+    """
-    # On Windows, rename fails if destination exists, see
+    if isWindows():
-    # https://docs.python.org/2/library/os.html#os.rename
+        # On Windows, rename fails if destination exists, see
-    try:
+        # https://docs.python.org/2/library/os.html#os.rename
-      os.rename(_makelongpath(src), _makelongpath(dst))
+        try:
-    except OSError as e:
+            os.rename(_makelongpath(src), _makelongpath(dst))
-      if e.errno == errno.EEXIST:
+        except OSError as e:
-        os.remove(_makelongpath(dst))
+            if e.errno == errno.EEXIST:
-        os.rename(_makelongpath(src), _makelongpath(dst))
+                os.remove(_makelongpath(dst))
-      else:
+                os.rename(_makelongpath(src), _makelongpath(dst))
-        raise
+            else:
-  else:
+                raise
-    shutil.move(src, dst)
+    else:
+        shutil.move(src, dst)
 def remove(path, missing_ok=False):
-  """Remove (delete) the file path. This is a replacement for os.remove that
+    """Remove (delete) the file path. This is a replacement for os.remove that
-  allows deleting read-only files on Windows, with support for long paths and
+    allows deleting read-only files on Windows, with support for long paths and
-  for deleting directory symbolic links.
+    for deleting directory symbolic links.
-  Availability: Unix, Windows."""
+    Availability: Unix, Windows.
-  longpath = _makelongpath(path) if isWindows() else path
+    """
-  try:
+    longpath = _makelongpath(path) if isWindows() else path
-    os.remove(longpath)
+    try:
-  except OSError as e:
-    if e.errno == errno.EACCES:
-      os.chmod(longpath, stat.S_IWRITE)
-      # Directory symbolic links must be deleted with 'rmdir'.
-      if islink(longpath) and isdir(longpath):
-        os.rmdir(longpath)
-      else:
        os.remove(longpath)
-    elif missing_ok and e.errno == errno.ENOENT:
+    except OSError as e:
-      pass
+        if e.errno == errno.EACCES:
-    else:
+            os.chmod(longpath, stat.S_IWRITE)
-      raise
+            # Directory symbolic links must be deleted with 'rmdir'.
+            if islink(longpath) and isdir(longpath):
+                os.rmdir(longpath)
+            else:
+                os.remove(longpath)
+        elif missing_ok and e.errno == errno.ENOENT:
+            pass
+        else:
+            raise
 def walk(top, topdown=True, onerror=None, followlinks=False):
-  """os.walk(path) wrapper with support for long paths on Windows.
+    """os.walk(path) wrapper with support for long paths on Windows.
-  Availability: Windows, Unix.
+    Availability: Windows, Unix.
-  """
+    """
-  if isWindows():
+    if isWindows():
-    return _walk_windows_impl(top, topdown, onerror, followlinks)
+        return _walk_windows_impl(top, topdown, onerror, followlinks)
-  else:
+    else:
-    return os.walk(top, topdown, onerror, followlinks)
+        return os.walk(top, topdown, onerror, followlinks)
 def _walk_windows_impl(top, topdown, onerror, followlinks):
-  try:
+    try:
-    names = listdir(top)
+        names = listdir(top)
-  except Exception as err:
+    except Exception as err:
-    if onerror is not None:
+        if onerror is not None:
-      onerror(err)
+            onerror(err)
-    return
+        return
-  dirs, nondirs = [], []
+    dirs, nondirs = [], []
-  for name in names:
+    for name in names:
-    if isdir(os.path.join(top, name)):
+        if isdir(os.path.join(top, name)):
-      dirs.append(name)
+            dirs.append(name)
-    else:
+        else:
-      nondirs.append(name)
+            nondirs.append(name)
-  if topdown:
+    if topdown:
-    yield top, dirs, nondirs
+        yield top, dirs, nondirs
-  for name in dirs:
+    for name in dirs:
-    new_path = os.path.join(top, name)
+        new_path = os.path.join(top, name)
-    if followlinks or not islink(new_path):
+        if followlinks or not islink(new_path):
-      for x in _walk_windows_impl(new_path, topdown, onerror, followlinks):
+            for x in _walk_windows_impl(
-        yield x
+                new_path, topdown, onerror, followlinks
-  if not topdown:
+            ):
-    yield top, dirs, nondirs
+                yield x
+    if not topdown:
+        yield top, dirs, nondirs
 def listdir(path):
-  """os.listdir(path) wrapper with support for long paths on Windows.
+    """os.listdir(path) wrapper with support for long paths on Windows.
-  Availability: Windows, Unix.
+    Availability: Windows, Unix.
-  """
+    """
-  return os.listdir(_makelongpath(path))
+    return os.listdir(_makelongpath(path))
 def rmdir(path):
-  """os.rmdir(path) wrapper with support for long paths on Windows.
+    """os.rmdir(path) wrapper with support for long paths on Windows.
-  Availability: Windows, Unix.
+    Availability: Windows, Unix.
-  """
+    """
-  os.rmdir(_makelongpath(path))
+    os.rmdir(_makelongpath(path))
 def isdir(path):
-  """os.path.isdir(path) wrapper with support for long paths on Windows.
+    """os.path.isdir(path) wrapper with support for long paths on Windows.
-  Availability: Windows, Unix.
+    Availability: Windows, Unix.
-  """
+    """
-  return os.path.isdir(_makelongpath(path))
+    return os.path.isdir(_makelongpath(path))
 def islink(path):
-  """os.path.islink(path) wrapper with support for long paths on Windows.
+    """os.path.islink(path) wrapper with support for long paths on Windows.
-  Availability: Windows, Unix.
+    Availability: Windows, Unix.
-  """
+    """
-  if isWindows():
+    if isWindows():
-    import platform_utils_win32
+        import platform_utils_win32
-    return platform_utils_win32.islink(_makelongpath(path))
-  else:
+        return platform_utils_win32.islink(_makelongpath(path))
-    return os.path.islink(path)
+    else:
+        return os.path.islink(path)
 def readlink(path):
-  """Return a string representing the path to which the symbolic link
+    """Return a string representing the path to which the symbolic link
-  points. The result may be either an absolute or relative pathname;
+    points. The result may be either an absolute or relative pathname;
-  if it is relative, it may be converted to an absolute pathname using
+    if it is relative, it may be converted to an absolute pathname using
-  os.path.join(os.path.dirname(path), result).
+    os.path.join(os.path.dirname(path), result).
+    Availability: Windows, Unix.
+    """
+    if isWindows():
+        import platform_utils_win32
-  Availability: Windows, Unix.
+        return platform_utils_win32.readlink(_makelongpath(path))
-  """
+    else:
-  if isWindows():
+        return os.readlink(path)
-    import platform_utils_win32
-    return platform_utils_win32.readlink(_makelongpath(path))
-  else:
-    return os.readlink(path)
 def realpath(path):
-  """Return the canonical path of the specified filename, eliminating
+    """Return the canonical path of the specified filename, eliminating
-  any symbolic links encountered in the path.
+    any symbolic links encountered in the path.
-  Availability: Windows, Unix.
+    Availability: Windows, Unix.
-  """
+    """
-  if isWindows():
+    if isWindows():
-    current_path = os.path.abspath(path)
+        current_path = os.path.abspath(path)
-    path_tail = []
+        path_tail = []
-    for c in range(0, 100):  # Avoid cycles
+        for c in range(0, 100):  # Avoid cycles
-      if islink(current_path):
+            if islink(current_path):
-        target = readlink(current_path)
+                target = readlink(current_path)
-        current_path = os.path.join(os.path.dirname(current_path), target)
+                current_path = os.path.join(
-      else:
+                    os.path.dirname(current_path), target
-        basename = os.path.basename(current_path)
+                )
-        if basename == '':
+            else:
-          path_tail.append(current_path)
+                basename = os.path.basename(current_path)
-          break
+                if basename == "":
-        path_tail.append(basename)
+                    path_tail.append(current_path)
-        current_path = os.path.dirname(current_path)
+                    break
-    path_tail.reverse()
+                path_tail.append(basename)
-    result = os.path.normpath(os.path.join(*path_tail))
+                current_path = os.path.dirname(current_path)
-    return result
+        path_tail.reverse()
-  else:
+        result = os.path.normpath(os.path.join(*path_tail))
-    return os.path.realpath(path)
+        return result
+    else:
+        return os.path.realpath(path)
diff --git a/platform_utils_win32.py b/platform_utils_win32.py
index bf916d47..e9b15f46 100644
--- a/platform_utils_win32.py
+++ b/platform_utils_win32.py
@@ -19,7 +19,7 @@ from ctypes import c_buffer, c_ubyte, Structure, Union, byref
 from ctypes.wintypes import BOOL, BOOLEAN, LPCWSTR, DWORD, HANDLE
 from ctypes.wintypes import WCHAR, USHORT, LPVOID, ULONG, LPDWORD
-kernel32 = WinDLL('kernel32', use_last_error=True)
+kernel32 = WinDLL("kernel32", use_last_error=True)
 UCHAR = c_ubyte
@@ -31,14 +31,17 @@ ERROR_PRIVILEGE_NOT_HELD = 1314
 # Win32 API entry points
 CreateSymbolicLinkW = kernel32.CreateSymbolicLinkW
 CreateSymbolicLinkW.restype = BOOLEAN
-CreateSymbolicLinkW.argtypes = (LPCWSTR,  # lpSymlinkFileName In
+CreateSymbolicLinkW.argtypes = (
-                                LPCWSTR,  # lpTargetFileName In
+    LPCWSTR,  # lpSymlinkFileName In
-                                DWORD)    # dwFlags In
+    LPCWSTR,  # lpTargetFileName In
+    DWORD,  # dwFlags In
+)
 # Symbolic link creation flags
 SYMBOLIC_LINK_FLAG_FILE = 0x00
 SYMBOLIC_LINK_FLAG_DIRECTORY = 0x01
-# symlink support for CreateSymbolicLink() starting with Windows 10 (1703, v10.0.14972)
+# symlink support for CreateSymbolicLink() starting with Windows 10 (1703,
+# v10.0.14972)
 SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE = 0x02
 GetFileAttributesW = kernel32.GetFileAttributesW
@@ -50,13 +53,15 @@ FILE_ATTRIBUTE_REPARSE_POINT = 0x00400
 CreateFileW = kernel32.CreateFileW
 CreateFileW.restype = HANDLE
-CreateFileW.argtypes = (LPCWSTR,  # lpFileName In
+CreateFileW.argtypes = (
-                        DWORD,    # dwDesiredAccess In
+    LPCWSTR,  # lpFileName In
-                        DWORD,    # dwShareMode In
+    DWORD,  # dwDesiredAccess In
-                        LPVOID,   # lpSecurityAttributes In_opt
+    DWORD,  # dwShareMode In
-                        DWORD,    # dwCreationDisposition In
+    LPVOID,  # lpSecurityAttributes In_opt
-                        DWORD,    # dwFlagsAndAttributes In
+    DWORD,  # dwCreationDisposition In
-                        HANDLE)   # hTemplateFile In_opt
+    DWORD,  # dwFlagsAndAttributes In
+    HANDLE,  # hTemplateFile In_opt
+)
 CloseHandle = kernel32.CloseHandle
 CloseHandle.restype = BOOL
@@ -69,14 +74,16 @@ FILE_FLAG_OPEN_REPARSE_POINT = 0x00200000
 DeviceIoControl = kernel32.DeviceIoControl
 DeviceIoControl.restype = BOOL
-DeviceIoControl.argtypes = (HANDLE,   # hDevice In
+DeviceIoControl.argtypes = (
-                            DWORD,    # dwIoControlCode In
+    HANDLE,  # hDevice In
-                            LPVOID,   # lpInBuffer In_opt
+    DWORD,  # dwIoControlCode In
-                            DWORD,    # nInBufferSize In
+    LPVOID,  # lpInBuffer In_opt
-                            LPVOID,   # lpOutBuffer Out_opt
+    DWORD,  # nInBufferSize In
-                            DWORD,    # nOutBufferSize In
+    LPVOID,  # lpOutBuffer Out_opt
-                            LPDWORD,  # lpBytesReturned Out_opt
+    DWORD,  # nOutBufferSize In
-                            LPVOID)   # lpOverlapped Inout_opt
+    LPDWORD,  # lpBytesReturned Out_opt
+    LPVOID,  # lpOverlapped Inout_opt
+)
 # Device I/O control flags and options
 FSCTL_GET_REPARSE_POINT = 0x000900A8
@@ -86,124 +93,138 @@ MAXIMUM_REPARSE_DATA_BUFFER_SIZE = 0x4000
 class GENERIC_REPARSE_BUFFER(Structure):
-  _fields_ = (('DataBuffer', UCHAR * 1),)
+    _fields_ = (("DataBuffer", UCHAR * 1),)
 class SYMBOLIC_LINK_REPARSE_BUFFER(Structure):
-  _fields_ = (('SubstituteNameOffset', USHORT),
+    _fields_ = (
-              ('SubstituteNameLength', USHORT),
+        ("SubstituteNameOffset", USHORT),
-              ('PrintNameOffset', USHORT),
+        ("SubstituteNameLength", USHORT),
-              ('PrintNameLength', USHORT),
+        ("PrintNameOffset", USHORT),
-              ('Flags', ULONG),
+        ("PrintNameLength", USHORT),
-              ('PathBuffer', WCHAR * 1))
+        ("Flags", ULONG),
+        ("PathBuffer", WCHAR * 1),
-  @property
+    )
-  def PrintName(self):
-    arrayt = WCHAR * (self.PrintNameLength // 2)
+    @property
-    offset = type(self).PathBuffer.offset + self.PrintNameOffset
+    def PrintName(self):
-    return arrayt.from_address(addressof(self) + offset).value
+        arrayt = WCHAR * (self.PrintNameLength // 2)
+        offset = type(self).PathBuffer.offset + self.PrintNameOffset
+        return arrayt.from_address(addressof(self) + offset).value
 class MOUNT_POINT_REPARSE_BUFFER(Structure):
-  _fields_ = (('SubstituteNameOffset', USHORT),
+    _fields_ = (
-              ('SubstituteNameLength', USHORT),
+        ("SubstituteNameOffset", USHORT),
-              ('PrintNameOffset', USHORT),
+        ("SubstituteNameLength", USHORT),
-              ('PrintNameLength', USHORT),
+        ("PrintNameOffset", USHORT),
-              ('PathBuffer', WCHAR * 1))
+        ("PrintNameLength", USHORT),
+        ("PathBuffer", WCHAR * 1),
+    )
-  @property
+    @property
-  def PrintName(self):
+    def PrintName(self):
-    arrayt = WCHAR * (self.PrintNameLength // 2)
+        arrayt = WCHAR * (self.PrintNameLength // 2)
-    offset = type(self).PathBuffer.offset + self.PrintNameOffset
+        offset = type(self).PathBuffer.offset + self.PrintNameOffset
-    return arrayt.from_address(addressof(self) + offset).value
+        return arrayt.from_address(addressof(self) + offset).value
 class REPARSE_DATA_BUFFER(Structure):
-  class REPARSE_BUFFER(Union):
+    class REPARSE_BUFFER(Union):
-    _fields_ = (('SymbolicLinkReparseBuffer', SYMBOLIC_LINK_REPARSE_BUFFER),
+        _fields_ = (
-                ('MountPointReparseBuffer', MOUNT_POINT_REPARSE_BUFFER),
+            ("SymbolicLinkReparseBuffer", SYMBOLIC_LINK_REPARSE_BUFFER),
-                ('GenericReparseBuffer', GENERIC_REPARSE_BUFFER))
+            ("MountPointReparseBuffer", MOUNT_POINT_REPARSE_BUFFER),
-  _fields_ = (('ReparseTag', ULONG),
+            ("GenericReparseBuffer", GENERIC_REPARSE_BUFFER),
-              ('ReparseDataLength', USHORT),
+        )
-              ('Reserved', USHORT),
-              ('ReparseBuffer', REPARSE_BUFFER))
+    _fields_ = (
-  _anonymous_ = ('ReparseBuffer',)
+        ("ReparseTag", ULONG),
+        ("ReparseDataLength", USHORT),
+        ("Reserved", USHORT),
+        ("ReparseBuffer", REPARSE_BUFFER),
+    )
+    _anonymous_ = ("ReparseBuffer",)
 def create_filesymlink(source, link_name):
-  """Creates a Windows file symbolic link source pointing to link_name."""
+    """Creates a Windows file symbolic link source pointing to link_name."""
-  _create_symlink(source, link_name, SYMBOLIC_LINK_FLAG_FILE)
+    _create_symlink(source, link_name, SYMBOLIC_LINK_FLAG_FILE)
 def create_dirsymlink(source, link_name):
-  """Creates a Windows directory symbolic link source pointing to link_name.
+    """Creates a Windows directory symbolic link source pointing to link_name."""  # noqa: E501
-  """
+    _create_symlink(source, link_name, SYMBOLIC_LINK_FLAG_DIRECTORY)
-  _create_symlink(source, link_name, SYMBOLIC_LINK_FLAG_DIRECTORY)
 def _create_symlink(source, link_name, dwFlags):
-  if not CreateSymbolicLinkW(link_name, source,
+    if not CreateSymbolicLinkW(
-                             dwFlags | SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE):
+        link_name,
-    # See https://github.com/golang/go/pull/24307/files#diff-b87bc12e4da2497308f9ef746086e4f0
+        source,
-    # "the unprivileged create flag is unsupported below Windows 10 (1703, v10.0.14972).
+        dwFlags | SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE,
-    # retry without it."
+    ):
-    if not CreateSymbolicLinkW(link_name, source, dwFlags):
+        # See https://github.com/golang/go/pull/24307/files#diff-b87bc12e4da2497308f9ef746086e4f0  # noqa: E501
-      code = get_last_error()
+        # "the unprivileged create flag is unsupported below Windows 10 (1703,
-      error_desc = FormatError(code).strip()
+        # v10.0.14972). retry without it."
-      if code == ERROR_PRIVILEGE_NOT_HELD:
+        if not CreateSymbolicLinkW(link_name, source, dwFlags):
-        raise OSError(errno.EPERM, error_desc, link_name)
+            code = get_last_error()
-      _raise_winerror(
+            error_desc = FormatError(code).strip()
-          code,
+            if code == ERROR_PRIVILEGE_NOT_HELD:
-          'Error creating symbolic link \"%s\"'.format(link_name))
+                raise OSError(errno.EPERM, error_desc, link_name)
+            _raise_winerror(
+                code, 'Error creating symbolic link "{}"'.format(link_name)
+            )
 def islink(path):
-  result = GetFileAttributesW(path)
+    result = GetFileAttributesW(path)
-  if result == INVALID_FILE_ATTRIBUTES:
+    if result == INVALID_FILE_ATTRIBUTES:
-    return False
+        return False
-  return bool(result & FILE_ATTRIBUTE_REPARSE_POINT)
+    return bool(result & FILE_ATTRIBUTE_REPARSE_POINT)
 def readlink(path):
-  reparse_point_handle = CreateFileW(path,
+    reparse_point_handle = CreateFileW(
-                                     0,
+        path,
-                                     0,
+        0,
-                                     None,
+        0,
-                                     OPEN_EXISTING,
+        None,
-                                     FILE_FLAG_OPEN_REPARSE_POINT |
+        OPEN_EXISTING,
-                                     FILE_FLAG_BACKUP_SEMANTICS,
+        FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS,
-                                     None)
+        None,
-  if reparse_point_handle == INVALID_HANDLE_VALUE:
+    )
-    _raise_winerror(
+    if reparse_point_handle == INVALID_HANDLE_VALUE:
-        get_last_error(),
+        _raise_winerror(
-        'Error opening symbolic link \"%s\"'.format(path))
+            get_last_error(), 'Error opening symbolic link "{}"'.format(path)
-  target_buffer = c_buffer(MAXIMUM_REPARSE_DATA_BUFFER_SIZE)
+        )
-  n_bytes_returned = DWORD()
+    target_buffer = c_buffer(MAXIMUM_REPARSE_DATA_BUFFER_SIZE)
-  io_result = DeviceIoControl(reparse_point_handle,
+    n_bytes_returned = DWORD()
-                              FSCTL_GET_REPARSE_POINT,
+    io_result = DeviceIoControl(
-                              None,
+        reparse_point_handle,
-                              0,
+        FSCTL_GET_REPARSE_POINT,
-                              target_buffer,
+        None,
-                              len(target_buffer),
+        0,
-                              byref(n_bytes_returned),
+        target_buffer,
-                              None)
+        len(target_buffer),
-  CloseHandle(reparse_point_handle)
+        byref(n_bytes_returned),
-  if not io_result:
+        None,
+    )
+    CloseHandle(reparse_point_handle)
+    if not io_result:
+        _raise_winerror(
+            get_last_error(), 'Error reading symbolic link "{}"'.format(path)
+        )
+    rdb = REPARSE_DATA_BUFFER.from_buffer(target_buffer)
+    if rdb.ReparseTag == IO_REPARSE_TAG_SYMLINK:
+        return rdb.SymbolicLinkReparseBuffer.PrintName
+    elif rdb.ReparseTag == IO_REPARSE_TAG_MOUNT_POINT:
+        return rdb.MountPointReparseBuffer.PrintName
+    # Unsupported reparse point type.
    _raise_winerror(
-        get_last_error(),
+        ERROR_NOT_SUPPORTED, 'Error reading symbolic link "{}"'.format(path)
-        'Error reading symbolic link \"%s\"'.format(path))
+    )
-  rdb = REPARSE_DATA_BUFFER.from_buffer(target_buffer)
-  if rdb.ReparseTag == IO_REPARSE_TAG_SYMLINK:
-    return rdb.SymbolicLinkReparseBuffer.PrintName
-  elif rdb.ReparseTag == IO_REPARSE_TAG_MOUNT_POINT:
-    return rdb.MountPointReparseBuffer.PrintName
-  # Unsupported reparse point type
-  _raise_winerror(
-      ERROR_NOT_SUPPORTED,
-      'Error reading symbolic link \"%s\"'.format(path))
 def _raise_winerror(code, error_desc):
-  win_error_desc = FormatError(code).strip()
+    win_error_desc = FormatError(code).strip()
-  error_desc = "%s: %s".format(error_desc, win_error_desc)
+    error_desc = "{0}: {1}".format(error_desc, win_error_desc)
-  raise WinError(code, error_desc)
+    raise WinError(code, error_desc)
diff --git a/progress.py b/progress.py
index 526ce6c1..d1a7c543 100644
--- a/progress.py
+++ b/progress.py
@@ -22,115 +22,136 @@ _NOT_TTY = not os.isatty(2)
 # This will erase all content in the current line (wherever the cursor is).
 # It does not move the cursor, so this is usually followed by \r to move to
 # column 0.
-CSI_ERASE_LINE = '\x1b[2K'
+CSI_ERASE_LINE = "\x1b[2K"
 # This will erase all content in the current line after the cursor.  This is
 # useful for partial updates & progress messages as the terminal can display
 # it better.
-CSI_ERASE_LINE_AFTER = '\x1b[K'
+CSI_ERASE_LINE_AFTER = "\x1b[K"
 def duration_str(total):
-  """A less noisy timedelta.__str__.
+    """A less noisy timedelta.__str__.
-  The default timedelta stringification contains a lot of leading zeros and
+    The default timedelta stringification contains a lot of leading zeros and
-  uses microsecond resolution.  This makes for noisy output.
+    uses microsecond resolution.  This makes for noisy output.
-  """
+    """
-  hours, rem = divmod(total, 3600)
+    hours, rem = divmod(total, 3600)
-  mins, secs = divmod(rem, 60)
+    mins, secs = divmod(rem, 60)
-  ret = '%.3fs' % (secs,)
+    ret = "%.3fs" % (secs,)
-  if mins:
+    if mins:
-    ret = '%im%s' % (mins, ret)
+        ret = "%im%s" % (mins, ret)
-  if hours:
+    if hours:
-    ret = '%ih%s' % (hours, ret)
+        ret = "%ih%s" % (hours, ret)
-  return ret
+    return ret
 class Progress(object):
-  def __init__(self, title, total=0, units='', print_newline=False, delay=True,
+    def __init__(
-               quiet=False):
+        self,
-    self._title = title
+        title,
-    self._total = total
+        total=0,
-    self._done = 0
+        units="",
-    self._start = time()
+        print_newline=False,
-    self._show = not delay
+        delay=True,
-    self._units = units
+        quiet=False,
-    self._print_newline = print_newline
+    ):
-    # Only show the active jobs section if we run more than one in parallel.
+        self._title = title
-    self._show_jobs = False
+        self._total = total
-    self._active = 0
+        self._done = 0
+        self._start = time()
-    # When quiet, never show any output.  It's a bit hacky, but reusing the
+        self._show = not delay
-    # existing logic that delays initial output keeps the rest of the class
+        self._units = units
-    # clean.  Basically we set the start time to years in the future.
+        self._print_newline = print_newline
-    if quiet:
+        # Only show the active jobs section if we run more than one in parallel.
-      self._show = False
+        self._show_jobs = False
-      self._start += 2**32
+        self._active = 0
-  def start(self, name):
+        # When quiet, never show any output.  It's a bit hacky, but reusing the
-    self._active += 1
+        # existing logic that delays initial output keeps the rest of the class
-    if not self._show_jobs:
+        # clean.  Basically we set the start time to years in the future.
-      self._show_jobs = self._active > 1
+        if quiet:
-    self.update(inc=0, msg='started ' + name)
+            self._show = False
+            self._start += 2**32
-  def finish(self, name):
-    self.update(msg='finished ' + name)
+    def start(self, name):
-    self._active -= 1
+        self._active += 1
+        if not self._show_jobs:
-  def update(self, inc=1, msg=''):
+            self._show_jobs = self._active > 1
-    self._done += inc
+        self.update(inc=0, msg="started " + name)
-    if _NOT_TTY or IsTraceToStderr():
+    def finish(self, name):
-      return
+        self.update(msg="finished " + name)
+        self._active -= 1
-    if not self._show:
-      if 0.5 <= time() - self._start:
+    def update(self, inc=1, msg=""):
-        self._show = True
+        self._done += inc
-      else:
-        return
+        if _NOT_TTY or IsTraceToStderr():
+            return
-    if self._total <= 0:
-      sys.stderr.write('\r%s: %d,%s' % (
+        if not self._show:
-          self._title,
+            if 0.5 <= time() - self._start:
-          self._done,
+                self._show = True
-          CSI_ERASE_LINE_AFTER))
+            else:
-      sys.stderr.flush()
+                return
-    else:
-      p = (100 * self._done) / self._total
+        if self._total <= 0:
-      if self._show_jobs:
+            sys.stderr.write(
-        jobs = '[%d job%s] ' % (self._active, 's' if self._active > 1 else '')
+                "\r%s: %d,%s" % (self._title, self._done, CSI_ERASE_LINE_AFTER)
-      else:
+            )
-        jobs = ''
+            sys.stderr.flush()
-      sys.stderr.write('\r%s: %2d%% %s(%d%s/%d%s)%s%s%s%s' % (
+        else:
-          self._title,
+            p = (100 * self._done) / self._total
-          p,
+            if self._show_jobs:
-          jobs,
+                jobs = "[%d job%s] " % (
-          self._done, self._units,
+                    self._active,
-          self._total, self._units,
+                    "s" if self._active > 1 else "",
-          ' ' if msg else '', msg,
+                )
-          CSI_ERASE_LINE_AFTER,
+            else:
-          '\n' if self._print_newline else ''))
+                jobs = ""
-      sys.stderr.flush()
+            sys.stderr.write(
+                "\r%s: %2d%% %s(%d%s/%d%s)%s%s%s%s"
-  def end(self):
+                % (
-    if _NOT_TTY or IsTraceToStderr() or not self._show:
+                    self._title,
-      return
+                    p,
+                    jobs,
-    duration = duration_str(time() - self._start)
+                    self._done,
-    if self._total <= 0:
+                    self._units,
-      sys.stderr.write('\r%s: %d, done in %s%s\n' % (
+                    self._total,
-          self._title,
+                    self._units,
-          self._done,
+                    " " if msg else "",
-          duration,
+                    msg,
-          CSI_ERASE_LINE_AFTER))
+                    CSI_ERASE_LINE_AFTER,
-      sys.stderr.flush()
+                    "\n" if self._print_newline else "",
-    else:
+                )
-      p = (100 * self._done) / self._total
+            )
-      sys.stderr.write('\r%s: %3d%% (%d%s/%d%s), done in %s%s\n' % (
+            sys.stderr.flush()
-          self._title,
-          p,
+    def end(self):
-          self._done, self._units,
+        if _NOT_TTY or IsTraceToStderr() or not self._show:
-          self._total, self._units,
+            return
-          duration,
-          CSI_ERASE_LINE_AFTER))
+        duration = duration_str(time() - self._start)
-      sys.stderr.flush()
+        if self._total <= 0:
+            sys.stderr.write(
+                "\r%s: %d, done in %s%s\n"
+                % (self._title, self._done, duration, CSI_ERASE_LINE_AFTER)
+            )
+            sys.stderr.flush()
+        else:
+            p = (100 * self._done) / self._total
+            sys.stderr.write(
+                "\r%s: %3d%% (%d%s/%d%s), done in %s%s\n"
+                % (
+                    self._title,
+                    p,
+                    self._done,
+                    self._units,
+                    self._total,
+                    self._units,
+                    duration,
+                    CSI_ERASE_LINE_AFTER,
+                )
+            )
+            sys.stderr.flush()
diff --git a/project.py b/project.py
index 3ccfd140..887fe83a 100644
--- a/project.py
+++ b/project.py
@@ -32,8 +32,13 @@ import urllib.parse
 from color import Coloring
 import fetch
 from git_command import GitCommand, git_require
-from git_config import GitConfig, IsId, GetSchemeFromUrl, GetUrlCookieFile, \
+from git_config import (
-    ID_RE
+    GitConfig,
+    IsId,
+    GetSchemeFromUrl,
+    GetUrlCookieFile,
+    ID_RE,
+)
 import git_superproject
 from git_trace2_event_log import EventLog
 from error import GitError, UploadError, DownloadError
@@ -47,12 +52,13 @@ from git_refs import GitRefs, HEAD, R_HEADS, R_TAGS, R_PUB, R_M, R_WORKTREE_M
 class SyncNetworkHalfResult(NamedTuple):
-  """Sync_NetworkHalf return value."""
+    """Sync_NetworkHalf return value."""
-  # True if successful.
-  success: bool
+    # True if successful.
-  # Did we query the remote? False when optimized_fetch is True and we have the
+    success: bool
-  # commit already present.
+    # Did we query the remote? False when optimized_fetch is True and we have
-  remote_fetched: bool
+    # the commit already present.
+    remote_fetched: bool
 # Maximum sleep time allowed during retries.
@@ -62,3904 +68,4362 @@ RETRY_JITTER_PERCENT = 0.1
 # Whether to use alternates.  Switching back and forth is *NOT* supported.
 # TODO(vapier): Remove knob once behavior is verified.
-_ALTERNATES = os.environ.get('REPO_USE_ALTERNATES') == '1'
+_ALTERNATES = os.environ.get("REPO_USE_ALTERNATES") == "1"
 def _lwrite(path, content):
-  lock = '%s.lock' % path
+    lock = "%s.lock" % path
-  # Maintain Unix line endings on all OS's to match git behavior.
+    # Maintain Unix line endings on all OS's to match git behavior.
-  with open(lock, 'w', newline='\n') as fd:
+    with open(lock, "w", newline="\n") as fd:
-    fd.write(content)
+        fd.write(content)
-  try:
+    try:
-    platform_utils.rename(lock, path)
+        platform_utils.rename(lock, path)
-  except OSError:
+    except OSError:
-    platform_utils.remove(lock)
+        platform_utils.remove(lock)
-    raise
+        raise
 def _error(fmt, *args):
-  msg = fmt % args
+    msg = fmt % args
-  print('error: %s' % msg, file=sys.stderr)
+    print("error: %s" % msg, file=sys.stderr)
 def _warn(fmt, *args):
-  msg = fmt % args
+    msg = fmt % args
-  print('warn: %s' % msg, file=sys.stderr)
+    print("warn: %s" % msg, file=sys.stderr)
 def not_rev(r):
-  return '^' + r
+    return "^" + r
 def sq(r):
-  return "'" + r.replace("'", "'\''") + "'"
+    return "'" + r.replace("'", "'''") + "'"
 _project_hook_list = None
 def _ProjectHooks():
-  """List the hooks present in the 'hooks' directory.
+    """List the hooks present in the 'hooks' directory.
-  These hooks are project hooks and are copied to the '.git/hooks' directory
+    These hooks are project hooks and are copied to the '.git/hooks' directory
-  of all subprojects.
+    of all subprojects.
-  This function caches the list of hooks (based on the contents of the
+    This function caches the list of hooks (based on the contents of the
-  'repo/hooks' directory) on the first call.
+    'repo/hooks' directory) on the first call.
-  Returns:
+    Returns:
-    A list of absolute paths to all of the files in the hooks directory.
+        A list of absolute paths to all of the files in the hooks directory.
-  """
+    """
-  global _project_hook_list
+    global _project_hook_list
-  if _project_hook_list is None:
+    if _project_hook_list is None:
-    d = platform_utils.realpath(os.path.abspath(os.path.dirname(__file__)))
+        d = platform_utils.realpath(os.path.abspath(os.path.dirname(__file__)))
-    d = os.path.join(d, 'hooks')
+        d = os.path.join(d, "hooks")
-    _project_hook_list = [os.path.join(d, x) for x in platform_utils.listdir(d)]
+        _project_hook_list = [
-  return _project_hook_list
+            os.path.join(d, x) for x in platform_utils.listdir(d)
+        ]
+    return _project_hook_list
 class DownloadedChange(object):
-  _commit_cache = None
+    _commit_cache = None
-  def __init__(self, project, base, change_id, ps_id, commit):
+    def __init__(self, project, base, change_id, ps_id, commit):
-    self.project = project
+        self.project = project
-    self.base = base
+        self.base = base
-    self.change_id = change_id
+        self.change_id = change_id
-    self.ps_id = ps_id
+        self.ps_id = ps_id
-    self.commit = commit
+        self.commit = commit
-  @property
+    @property
-  def commits(self):
+    def commits(self):
-    if self._commit_cache is None:
+        if self._commit_cache is None:
-      self._commit_cache = self.project.bare_git.rev_list('--abbrev=8',
+            self._commit_cache = self.project.bare_git.rev_list(
-                                                          '--abbrev-commit',
+                "--abbrev=8",
-                                                          '--pretty=oneline',
+                "--abbrev-commit",
-                                                          '--reverse',
+                "--pretty=oneline",
-                                                          '--date-order',
+                "--reverse",
-                                                          not_rev(self.base),
+                "--date-order",
-                                                          self.commit,
+                not_rev(self.base),
-                                                          '--')
+                self.commit,
-    return self._commit_cache
+                "--",
+            )
+        return self._commit_cache
 class ReviewableBranch(object):
-  _commit_cache = None
+    _commit_cache = None
-  _base_exists = None
+    _base_exists = None
-  def __init__(self, project, branch, base):
+    def __init__(self, project, branch, base):
-    self.project = project
+        self.project = project
-    self.branch = branch
+        self.branch = branch
-    self.base = base
+        self.base = base
-  @property
+    @property
-  def name(self):
+    def name(self):
-    return self.branch.name
+        return self.branch.name
-  @property
+    @property
-  def commits(self):
+    def commits(self):
-    if self._commit_cache is None:
+        if self._commit_cache is None:
-      args = ('--abbrev=8', '--abbrev-commit', '--pretty=oneline', '--reverse',
+            args = (
-              '--date-order', not_rev(self.base), R_HEADS + self.name, '--')
+                "--abbrev=8",
-      try:
+                "--abbrev-commit",
-        self._commit_cache = self.project.bare_git.rev_list(*args)
+                "--pretty=oneline",
-      except GitError:
+                "--reverse",
-        # We weren't able to probe the commits for this branch.  Was it tracking
+                "--date-order",
-        # a branch that no longer exists?  If so, return no commits.  Otherwise,
+                not_rev(self.base),
-        # rethrow the error as we don't know what's going on.
+                R_HEADS + self.name,
-        if self.base_exists:
+                "--",
-          raise
+            )
+            try:
-        self._commit_cache = []
+                self._commit_cache = self.project.bare_git.rev_list(*args)
+            except GitError:
-    return self._commit_cache
+                # We weren't able to probe the commits for this branch.  Was it
+                # tracking a branch that no longer exists?  If so, return no
-  @property
+                # commits.  Otherwise, rethrow the error as we don't know what's
-  def unabbrev_commits(self):
+                # going on.
-    r = dict()
+                if self.base_exists:
-    for commit in self.project.bare_git.rev_list(not_rev(self.base),
+                    raise
-                                                 R_HEADS + self.name,
-                                                 '--'):
+                self._commit_cache = []
-      r[commit[0:8]] = commit
-    return r
+        return self._commit_cache
-  @property
+    @property
-  def date(self):
+    def unabbrev_commits(self):
-    return self.project.bare_git.log('--pretty=format:%cd',
+        r = dict()
-                                     '-n', '1',
+        for commit in self.project.bare_git.rev_list(
-                                     R_HEADS + self.name,
+            not_rev(self.base), R_HEADS + self.name, "--"
-                                     '--')
+        ):
+            r[commit[0:8]] = commit
-  @property
+        return r
-  def base_exists(self):
-    """Whether the branch we're tracking exists.
+    @property
+    def date(self):
-    Normally it should, but sometimes branches we track can get deleted.
+        return self.project.bare_git.log(
-    """
+            "--pretty=format:%cd", "-n", "1", R_HEADS + self.name, "--"
-    if self._base_exists is None:
+        )
-      try:
-        self.project.bare_git.rev_parse('--verify', not_rev(self.base))
-        # If we're still here, the base branch exists.
-        self._base_exists = True
-      except GitError:
-        # If we failed to verify, the base branch doesn't exist.
-        self._base_exists = False
-    return self._base_exists
-  def UploadForReview(self, people,
-                      dryrun=False,
-                      auto_topic=False,
-                      hashtags=(),
-                      labels=(),
-                      private=False,
-                      notify=None,
-                      wip=False,
-                      ready=False,
-                      dest_branch=None,
-                      validate_certs=True,
-                      push_options=None):
-    self.project.UploadForReview(branch=self.name,
-                                 people=people,
-                                 dryrun=dryrun,
-                                 auto_topic=auto_topic,
-                                 hashtags=hashtags,
-                                 labels=labels,
-                                 private=private,
-                                 notify=notify,
-                                 wip=wip,
-                                 ready=ready,
-                                 dest_branch=dest_branch,
-                                 validate_certs=validate_certs,
-                                 push_options=push_options)
-  def GetPublishedRefs(self):
-    refs = {}
-    output = self.project.bare_git.ls_remote(
-        self.branch.remote.SshReviewUrl(self.project.UserEmail),
-        'refs/changes/*')
-    for line in output.split('\n'):
-      try:
-        (sha, ref) = line.split()
-        refs[sha] = ref
-      except ValueError:
-        pass
-    return refs
+    @property
+    def base_exists(self):
+        """Whether the branch we're tracking exists.
-class StatusColoring(Coloring):
+        Normally it should, but sometimes branches we track can get deleted.
+        """
+        if self._base_exists is None:
+            try:
+                self.project.bare_git.rev_parse("--verify", not_rev(self.base))
+                # If we're still here, the base branch exists.
+                self._base_exists = True
+            except GitError:
+                # If we failed to verify, the base branch doesn't exist.
+                self._base_exists = False
+        return self._base_exists
+    def UploadForReview(
+        self,
+        people,
+        dryrun=False,
+        auto_topic=False,
+        hashtags=(),
+        labels=(),
+        private=False,
+        notify=None,
+        wip=False,
+        ready=False,
+        dest_branch=None,
+        validate_certs=True,
+        push_options=None,
+    ):
+        self.project.UploadForReview(
+            branch=self.name,
+            people=people,
+            dryrun=dryrun,
+            auto_topic=auto_topic,
+            hashtags=hashtags,
+            labels=labels,
+            private=private,
+            notify=notify,
+            wip=wip,
+            ready=ready,
+            dest_branch=dest_branch,
+            validate_certs=validate_certs,
+            push_options=push_options,
+        )
-  def __init__(self, config):
+    def GetPublishedRefs(self):
-    super().__init__(config, 'status')
+        refs = {}
-    self.project = self.printer('header', attr='bold')
+        output = self.project.bare_git.ls_remote(
-    self.branch = self.printer('header', attr='bold')
+            self.branch.remote.SshReviewUrl(self.project.UserEmail),
-    self.nobranch = self.printer('nobranch', fg='red')
+            "refs/changes/*",
-    self.important = self.printer('important', fg='red')
+        )
+        for line in output.split("\n"):
+            try:
+                (sha, ref) = line.split()
+                refs[sha] = ref
+            except ValueError:
+                pass
-    self.added = self.printer('added', fg='green')
+        return refs
-    self.changed = self.printer('changed', fg='red')
-    self.untracked = self.printer('untracked', fg='red')
-class DiffColoring(Coloring):
+class StatusColoring(Coloring):
+    def __init__(self, config):
+        super().__init__(config, "status")
+        self.project = self.printer("header", attr="bold")
+        self.branch = self.printer("header", attr="bold")
+        self.nobranch = self.printer("nobranch", fg="red")
+        self.important = self.printer("important", fg="red")
-  def __init__(self, config):
+        self.added = self.printer("added", fg="green")
-    super().__init__(config, 'diff')
+        self.changed = self.printer("changed", fg="red")
-    self.project = self.printer('header', attr='bold')
+        self.untracked = self.printer("untracked", fg="red")
-    self.fail = self.printer('fail', fg='red')
-class Annotation(object):
+class DiffColoring(Coloring):
+    def __init__(self, config):
+        super().__init__(config, "diff")
+        self.project = self.printer("header", attr="bold")
+        self.fail = self.printer("fail", fg="red")
-  def __init__(self, name, value, keep):
+class Annotation(object):
-    self.name = name
+    def __init__(self, name, value, keep):
-    self.value = value
+        self.name = name
-    self.keep = keep
+        self.value = value
+        self.keep = keep
-  def __eq__(self, other):
+    def __eq__(self, other):
-    if not isinstance(other, Annotation):
+        if not isinstance(other, Annotation):
-      return False
+            return False
-    return self.__dict__ == other.__dict__
+        return self.__dict__ == other.__dict__
-  def __lt__(self, other):
+    def __lt__(self, other):
-    # This exists just so that lists of Annotation objects can be sorted, for
+        # This exists just so that lists of Annotation objects can be sorted,
-    # use in comparisons.
+        # for use in comparisons.
-    if not isinstance(other, Annotation):
+        if not isinstance(other, Annotation):
-      raise ValueError('comparison is not between two Annotation objects')
+            raise ValueError("comparison is not between two Annotation objects")
-    if self.name == other.name:
+        if self.name == other.name:
-      if self.value == other.value:
+            if self.value == other.value:
-        return self.keep < other.keep
+                return self.keep < other.keep
-      return self.value < other.value
+            return self.value < other.value
-    return self.name < other.name
+        return self.name < other.name
 def _SafeExpandPath(base, subpath, skipfinal=False):
-  """Make sure |subpath| is completely safe under |base|.
+    """Make sure |subpath| is completely safe under |base|.
-  We make sure no intermediate symlinks are traversed, and that the final path
+    We make sure no intermediate symlinks are traversed, and that the final path
-  is not a special file (e.g. not a socket or fifo).
+    is not a special file (e.g. not a socket or fifo).
-  NB: We rely on a number of paths already being filtered out while parsing the
+    NB: We rely on a number of paths already being filtered out while parsing
-  manifest.  See the validation logic in manifest_xml.py for more details.
+    the manifest.  See the validation logic in manifest_xml.py for more details.
-  """
+    """
-  # Split up the path by its components.  We can't use os.path.sep exclusively
+    # Split up the path by its components.  We can't use os.path.sep exclusively
-  # as some platforms (like Windows) will convert / to \ and that bypasses all
+    # as some platforms (like Windows) will convert / to \ and that bypasses all
-  # our constructed logic here.  Especially since manifest authors only use
+    # our constructed logic here.  Especially since manifest authors only use
-  # / in their paths.
+    # / in their paths.
-  resep = re.compile(r'[/%s]' % re.escape(os.path.sep))
+    resep = re.compile(r"[/%s]" % re.escape(os.path.sep))
-  components = resep.split(subpath)
+    components = resep.split(subpath)
-  if skipfinal:
+    if skipfinal:
-    # Whether the caller handles the final component itself.
+        # Whether the caller handles the final component itself.
-    finalpart = components.pop()
+        finalpart = components.pop()
-  path = base
+    path = base
-  for part in components:
+    for part in components:
-    if part in {'.', '..'}:
+        if part in {".", ".."}:
-      raise ManifestInvalidPathError(
+            raise ManifestInvalidPathError(
-          '%s: "%s" not allowed in paths' % (subpath, part))
+                '%s: "%s" not allowed in paths' % (subpath, part)
+            )
-    path = os.path.join(path, part)
-    if platform_utils.islink(path):
+        path = os.path.join(path, part)
-      raise ManifestInvalidPathError(
+        if platform_utils.islink(path):
-          '%s: traversing symlinks not allow' % (path,))
+            raise ManifestInvalidPathError(
+                "%s: traversing symlinks not allow" % (path,)
-    if os.path.exists(path):
+            )
-      if not os.path.isfile(path) and not platform_utils.isdir(path):
-        raise ManifestInvalidPathError(
+        if os.path.exists(path):
-            '%s: only regular files & directories allowed' % (path,))
+            if not os.path.isfile(path) and not platform_utils.isdir(path):
+                raise ManifestInvalidPathError(
-  if skipfinal:
+                    "%s: only regular files & directories allowed" % (path,)
-    path = os.path.join(path, finalpart)
+                )
-  return path
+    if skipfinal:
+        path = os.path.join(path, finalpart)
+    return path
 class _CopyFile(object):
-  """Container for <copyfile> manifest element."""
+    """Container for <copyfile> manifest element."""
-  def __init__(self, git_worktree, src, topdir, dest):
+    def __init__(self, git_worktree, src, topdir, dest):
-    """Register a <copyfile> request.
+        """Register a <copyfile> request.
-    Args:
+        Args:
-      git_worktree: Absolute path to the git project checkout.
+            git_worktree: Absolute path to the git project checkout.
-      src: Relative path under |git_worktree| of file to read.
+            src: Relative path under |git_worktree| of file to read.
-      topdir: Absolute path to the top of the repo client checkout.
+            topdir: Absolute path to the top of the repo client checkout.
-      dest: Relative path under |topdir| of file to write.
+            dest: Relative path under |topdir| of file to write.
-    """
+        """
-    self.git_worktree = git_worktree
+        self.git_worktree = git_worktree
-    self.topdir = topdir
+        self.topdir = topdir
-    self.src = src
+        self.src = src
-    self.dest = dest
+        self.dest = dest
-  def _Copy(self):
+    def _Copy(self):
-    src = _SafeExpandPath(self.git_worktree, self.src)
+        src = _SafeExpandPath(self.git_worktree, self.src)
-    dest = _SafeExpandPath(self.topdir, self.dest)
+        dest = _SafeExpandPath(self.topdir, self.dest)
-    if platform_utils.isdir(src):
+        if platform_utils.isdir(src):
-      raise ManifestInvalidPathError(
+            raise ManifestInvalidPathError(
-          '%s: copying from directory not supported' % (self.src,))
+                "%s: copying from directory not supported" % (self.src,)
-    if platform_utils.isdir(dest):
+            )
-      raise ManifestInvalidPathError(
+        if platform_utils.isdir(dest):
-          '%s: copying to directory not allowed' % (self.dest,))
+            raise ManifestInvalidPathError(
+                "%s: copying to directory not allowed" % (self.dest,)
-    # copy file if it does not exist or is out of date
+            )
-    if not os.path.exists(dest) or not filecmp.cmp(src, dest):
-      try:
+        # Copy file if it does not exist or is out of date.
-        # remove existing file first, since it might be read-only
+        if not os.path.exists(dest) or not filecmp.cmp(src, dest):
-        if os.path.exists(dest):
+            try:
-          platform_utils.remove(dest)
+                # Remove existing file first, since it might be read-only.
-        else:
+                if os.path.exists(dest):
-          dest_dir = os.path.dirname(dest)
+                    platform_utils.remove(dest)
-          if not platform_utils.isdir(dest_dir):
+                else:
-            os.makedirs(dest_dir)
+                    dest_dir = os.path.dirname(dest)
-        shutil.copy(src, dest)
+                    if not platform_utils.isdir(dest_dir):
-        # make the file read-only
+                        os.makedirs(dest_dir)
-        mode = os.stat(dest)[stat.ST_MODE]
+                shutil.copy(src, dest)
-        mode = mode & ~(stat.S_IWUSR | stat.S_IWGRP | stat.S_IWOTH)
+                # Make the file read-only.
-        os.chmod(dest, mode)
+                mode = os.stat(dest)[stat.ST_MODE]
-      except IOError:
+                mode = mode & ~(stat.S_IWUSR | stat.S_IWGRP | stat.S_IWOTH)
-        _error('Cannot copy file %s to %s', src, dest)
+                os.chmod(dest, mode)
+            except IOError:
+                _error("Cannot copy file %s to %s", src, dest)
 class _LinkFile(object):
-  """Container for <linkfile> manifest element."""
+    """Container for <linkfile> manifest element."""
-  def __init__(self, git_worktree, src, topdir, dest):
+    def __init__(self, git_worktree, src, topdir, dest):
-    """Register a <linkfile> request.
+        """Register a <linkfile> request.
-    Args:
+        Args:
-      git_worktree: Absolute path to the git project checkout.
+            git_worktree: Absolute path to the git project checkout.
-      src: Target of symlink relative to path under |git_worktree|.
+            src: Target of symlink relative to path under |git_worktree|.
-      topdir: Absolute path to the top of the repo client checkout.
+            topdir: Absolute path to the top of the repo client checkout.
-      dest: Relative path under |topdir| of symlink to create.
+            dest: Relative path under |topdir| of symlink to create.
-    """
+        """
-    self.git_worktree = git_worktree
+        self.git_worktree = git_worktree
-    self.topdir = topdir
+        self.topdir = topdir
-    self.src = src
+        self.src = src
-    self.dest = dest
+        self.dest = dest
-  def __linkIt(self, relSrc, absDest):
+    def __linkIt(self, relSrc, absDest):
-    # link file if it does not exist or is out of date
+        # Link file if it does not exist or is out of date.
-    if not platform_utils.islink(absDest) or (platform_utils.readlink(absDest) != relSrc):
+        if not platform_utils.islink(absDest) or (
-      try:
+            platform_utils.readlink(absDest) != relSrc
-        # remove existing file first, since it might be read-only
+        ):
-        if os.path.lexists(absDest):
+            try:
-          platform_utils.remove(absDest)
+                # Remove existing file first, since it might be read-only.
+                if os.path.lexists(absDest):
+                    platform_utils.remove(absDest)
+                else:
+                    dest_dir = os.path.dirname(absDest)
+                    if not platform_utils.isdir(dest_dir):
+                        os.makedirs(dest_dir)
+                platform_utils.symlink(relSrc, absDest)
+            except IOError:
+                _error("Cannot link file %s to %s", relSrc, absDest)
+    def _Link(self):
+        """Link the self.src & self.dest paths.
+        Handles wild cards on the src linking all of the files in the source in
+        to the destination directory.
+        """
+        # Some people use src="." to create stable links to projects.  Let's
+        # allow that but reject all other uses of "." to keep things simple.
+        if self.src == ".":
+            src = self.git_worktree
        else:
-          dest_dir = os.path.dirname(absDest)
+            src = _SafeExpandPath(self.git_worktree, self.src)
-          if not platform_utils.isdir(dest_dir):
-            os.makedirs(dest_dir)
+        if not glob.has_magic(src):
-        platform_utils.symlink(relSrc, absDest)
+            # Entity does not contain a wild card so just a simple one to one
-      except IOError:
+            # link operation.
-        _error('Cannot link file %s to %s', relSrc, absDest)
+            dest = _SafeExpandPath(self.topdir, self.dest, skipfinal=True)
+            # dest & src are absolute paths at this point.  Make sure the target
-  def _Link(self):
+            # of the symlink is relative in the context of the repo client
-    """Link the self.src & self.dest paths.
+            # checkout.
+            relpath = os.path.relpath(src, os.path.dirname(dest))
-    Handles wild cards on the src linking all of the files in the source in to
+            self.__linkIt(relpath, dest)
-    the destination directory.
+        else:
-    """
+            dest = _SafeExpandPath(self.topdir, self.dest)
-    # Some people use src="." to create stable links to projects.  Lets allow
+            # Entity contains a wild card.
-    # that but reject all other uses of "." to keep things simple.
+            if os.path.exists(dest) and not platform_utils.isdir(dest):
-    if self.src == '.':
+                _error(
-      src = self.git_worktree
+                    "Link error: src with wildcard, %s must be a directory",
-    else:
+                    dest,
-      src = _SafeExpandPath(self.git_worktree, self.src)
+                )
+            else:
-    if not glob.has_magic(src):
+                for absSrcFile in glob.glob(src):
-      # Entity does not contain a wild card so just a simple one to one link operation.
+                    # Create a releative path from source dir to destination
-      dest = _SafeExpandPath(self.topdir, self.dest, skipfinal=True)
+                    # dir.
-      # dest & src are absolute paths at this point.  Make sure the target of
+                    absSrcDir = os.path.dirname(absSrcFile)
-      # the symlink is relative in the context of the repo client checkout.
+                    relSrcDir = os.path.relpath(absSrcDir, dest)
-      relpath = os.path.relpath(src, os.path.dirname(dest))
-      self.__linkIt(relpath, dest)
+                    # Get the source file name.
-    else:
+                    srcFile = os.path.basename(absSrcFile)
-      dest = _SafeExpandPath(self.topdir, self.dest)
-      # Entity contains a wild card.
+                    # Now form the final full paths to srcFile. They will be
-      if os.path.exists(dest) and not platform_utils.isdir(dest):
+                    # absolute for the desintaiton and relative for the source.
-        _error('Link error: src with wildcard, %s must be a directory', dest)
+                    absDest = os.path.join(dest, srcFile)
-      else:
+                    relSrc = os.path.join(relSrcDir, srcFile)
-        for absSrcFile in glob.glob(src):
+                    self.__linkIt(relSrc, absDest)
-          # Create a releative path from source dir to destination dir
-          absSrcDir = os.path.dirname(absSrcFile)
-          relSrcDir = os.path.relpath(absSrcDir, dest)
-          # Get the source file name
-          srcFile = os.path.basename(absSrcFile)
-          # Now form the final full paths to srcFile. They will be
-          # absolute for the desintaiton and relative for the srouce.
-          absDest = os.path.join(dest, srcFile)
-          relSrc = os.path.join(relSrcDir, srcFile)
-          self.__linkIt(relSrc, absDest)
 class RemoteSpec(object):
+    def __init__(
-  def __init__(self,
+        self,
-               name,
+        name,
-               url=None,
+        url=None,
-               pushUrl=None,
+        pushUrl=None,
-               review=None,
+        review=None,
-               revision=None,
+        revision=None,
-               orig_name=None,
+        orig_name=None,
-               fetchUrl=None):
+        fetchUrl=None,
-    self.name = name
+    ):
-    self.url = url
+        self.name = name
-    self.pushUrl = pushUrl
+        self.url = url
-    self.review = review
+        self.pushUrl = pushUrl
-    self.revision = revision
+        self.review = review
-    self.orig_name = orig_name
+        self.revision = revision
-    self.fetchUrl = fetchUrl
+        self.orig_name = orig_name
+        self.fetchUrl = fetchUrl
 class Project(object):
-  # These objects can be shared between several working trees.
+    # These objects can be shared between several working trees.
-  @property
+    @property
-  def shareable_dirs(self):
+    def shareable_dirs(self):
-    """Return the shareable directories"""
+        """Return the shareable directories"""
-    if self.UseAlternates:
+        if self.UseAlternates:
-      return ['hooks', 'rr-cache']
+            return ["hooks", "rr-cache"]
-    else:
+        else:
-      return ['hooks', 'objects', 'rr-cache']
+            return ["hooks", "objects", "rr-cache"]
-  def __init__(self,
+    def __init__(
-               manifest,
+        self,
-               name,
+        manifest,
-               remote,
+        name,
-               gitdir,
+        remote,
-               objdir,
+        gitdir,
-               worktree,
+        objdir,
-               relpath,
+        worktree,
-               revisionExpr,
+        relpath,
-               revisionId,
+        revisionExpr,
-               rebase=True,
+        revisionId,
-               groups=None,
+        rebase=True,
-               sync_c=False,
+        groups=None,
-               sync_s=False,
+        sync_c=False,
-               sync_tags=True,
+        sync_s=False,
-               clone_depth=None,
+        sync_tags=True,
-               upstream=None,
+        clone_depth=None,
-               parent=None,
+        upstream=None,
-               use_git_worktrees=False,
+        parent=None,
-               is_derived=False,
+        use_git_worktrees=False,
-               dest_branch=None,
+        is_derived=False,
-               optimized_fetch=False,
+        dest_branch=None,
-               retry_fetches=0,
+        optimized_fetch=False,
-               old_revision=None):
+        retry_fetches=0,
-    """Init a Project object.
+        old_revision=None,
+    ):
-    Args:
+        """Init a Project object.
-      manifest: The XmlManifest object.
-      name: The `name` attribute of manifest.xml's project element.
-      remote: RemoteSpec object specifying its remote's properties.
-      gitdir: Absolute path of git directory.
-      objdir: Absolute path of directory to store git objects.
-      worktree: Absolute path of git working tree.
-      relpath: Relative path of git working tree to repo's top directory.
-      revisionExpr: The `revision` attribute of manifest.xml's project element.
-      revisionId: git commit id for checking out.
-      rebase: The `rebase` attribute of manifest.xml's project element.
-      groups: The `groups` attribute of manifest.xml's project element.
-      sync_c: The `sync-c` attribute of manifest.xml's project element.
-      sync_s: The `sync-s` attribute of manifest.xml's project element.
-      sync_tags: The `sync-tags` attribute of manifest.xml's project element.
-      upstream: The `upstream` attribute of manifest.xml's project element.
-      parent: The parent Project object.
-      use_git_worktrees: Whether to use `git worktree` for this project.
-      is_derived: False if the project was explicitly defined in the manifest;
-                  True if the project is a discovered submodule.
-      dest_branch: The branch to which to push changes for review by default.
-      optimized_fetch: If True, when a project is set to a sha1 revision, only
-                       fetch from the remote if the sha1 is not present locally.
-      retry_fetches: Retry remote fetches n times upon receiving transient error
-                     with exponential backoff and jitter.
-      old_revision: saved git commit id for open GITC projects.
-    """
-    self.client = self.manifest = manifest
-    self.name = name
-    self.remote = remote
-    self.UpdatePaths(relpath, worktree, gitdir, objdir)
-    self.SetRevision(revisionExpr, revisionId=revisionId)
-    self.rebase = rebase
-    self.groups = groups
-    self.sync_c = sync_c
-    self.sync_s = sync_s
-    self.sync_tags = sync_tags
-    self.clone_depth = clone_depth
-    self.upstream = upstream
-    self.parent = parent
-    # NB: Do not use this setting in __init__ to change behavior so that the
-    # manifest.git checkout can inspect & change it after instantiating.  See
-    # the XmlManifest init code for more info.
-    self.use_git_worktrees = use_git_worktrees
-    self.is_derived = is_derived
-    self.optimized_fetch = optimized_fetch
-    self.retry_fetches = max(0, retry_fetches)
-    self.subprojects = []
-    self.snapshots = {}
-    self.copyfiles = []
-    self.linkfiles = []
-    self.annotations = []
-    self.dest_branch = dest_branch
-    self.old_revision = old_revision
-    # This will be filled in if a project is later identified to be the
-    # project containing repo hooks.
-    self.enabled_repo_hooks = []
-  def RelPath(self, local=True):
-    """Return the path for the project relative to a manifest.
-    Args:
-      local: a boolean, if True, the path is relative to the local
-             (sub)manifest.  If false, the path is relative to the
-             outermost manifest.
-    """
-    if local:
-      return self.relpath
-    return os.path.join(self.manifest.path_prefix, self.relpath)
-  def SetRevision(self, revisionExpr, revisionId=None):
-    """Set revisionId based on revision expression and id"""
-    self.revisionExpr = revisionExpr
-    if revisionId is None and revisionExpr and IsId(revisionExpr):
-      self.revisionId = self.revisionExpr
-    else:
-      self.revisionId = revisionId
-  def UpdatePaths(self, relpath, worktree, gitdir, objdir):
-    """Update paths used by this project"""
-    self.gitdir = gitdir.replace('\\', '/')
-    self.objdir = objdir.replace('\\', '/')
-    if worktree:
-      self.worktree = os.path.normpath(worktree).replace('\\', '/')
-    else:
-      self.worktree = None
-    self.relpath = relpath
-    self.config = GitConfig.ForRepository(gitdir=self.gitdir,
-                                          defaults=self.manifest.globalConfig)
-    if self.worktree:
-      self.work_git = self._GitGetByExec(self, bare=False, gitdir=self.gitdir)
-    else:
-      self.work_git = None
-    self.bare_git = self._GitGetByExec(self, bare=True, gitdir=self.gitdir)
-    self.bare_ref = GitRefs(self.gitdir)
-    self.bare_objdir = self._GitGetByExec(self, bare=True, gitdir=self.objdir)
-  @property
-  def UseAlternates(self):
-    """Whether git alternates are in use.
-    This will be removed once migration to alternates is complete.
-    """
-    return _ALTERNATES or self.manifest.is_multimanifest
-  @property
+        Args:
-  def Derived(self):
+            manifest: The XmlManifest object.
-    return self.is_derived
+            name: The `name` attribute of manifest.xml's project element.
+            remote: RemoteSpec object specifying its remote's properties.
+            gitdir: Absolute path of git directory.
+            objdir: Absolute path of directory to store git objects.
+            worktree: Absolute path of git working tree.
+            relpath: Relative path of git working tree to repo's top directory.
+            revisionExpr: The `revision` attribute of manifest.xml's project
+                element.
+            revisionId: git commit id for checking out.
+            rebase: The `rebase` attribute of manifest.xml's project element.
+            groups: The `groups` attribute of manifest.xml's project element.
+            sync_c: The `sync-c` attribute of manifest.xml's project element.
+            sync_s: The `sync-s` attribute of manifest.xml's project element.
+            sync_tags: The `sync-tags` attribute of manifest.xml's project
+                element.
+            upstream: The `upstream` attribute of manifest.xml's project
+                element.
+            parent: The parent Project object.
+            use_git_worktrees: Whether to use `git worktree` for this project.
+            is_derived: False if the project was explicitly defined in the
+                manifest; True if the project is a discovered submodule.
+            dest_branch: The branch to which to push changes for review by
+                default.
+            optimized_fetch: If True, when a project is set to a sha1 revision,
+                only fetch from the remote if the sha1 is not present locally.
+            retry_fetches: Retry remote fetches n times upon receiving transient
+                error with exponential backoff and jitter.
+            old_revision: saved git commit id for open GITC projects.
+        """
+        self.client = self.manifest = manifest
+        self.name = name
+        self.remote = remote
+        self.UpdatePaths(relpath, worktree, gitdir, objdir)
+        self.SetRevision(revisionExpr, revisionId=revisionId)
+        self.rebase = rebase
+        self.groups = groups
+        self.sync_c = sync_c
+        self.sync_s = sync_s
+        self.sync_tags = sync_tags
+        self.clone_depth = clone_depth
+        self.upstream = upstream
+        self.parent = parent
+        # NB: Do not use this setting in __init__ to change behavior so that the
+        # manifest.git checkout can inspect & change it after instantiating.
+        # See the XmlManifest init code for more info.
+        self.use_git_worktrees = use_git_worktrees
+        self.is_derived = is_derived
+        self.optimized_fetch = optimized_fetch
+        self.retry_fetches = max(0, retry_fetches)
+        self.subprojects = []
+        self.snapshots = {}
+        self.copyfiles = []
+        self.linkfiles = []
+        self.annotations = []
+        self.dest_branch = dest_branch
+        self.old_revision = old_revision
+        # This will be filled in if a project is later identified to be the
+        # project containing repo hooks.
+        self.enabled_repo_hooks = []
+    def RelPath(self, local=True):
+        """Return the path for the project relative to a manifest.
-  @property
+        Args:
-  def Exists(self):
+            local: a boolean, if True, the path is relative to the local
-    return platform_utils.isdir(self.gitdir) and platform_utils.isdir(self.objdir)
+                (sub)manifest.  If false, the path is relative to the outermost
+                manifest.
+        """
+        if local:
+            return self.relpath
+        return os.path.join(self.manifest.path_prefix, self.relpath)
+    def SetRevision(self, revisionExpr, revisionId=None):
+        """Set revisionId based on revision expression and id"""
+        self.revisionExpr = revisionExpr
+        if revisionId is None and revisionExpr and IsId(revisionExpr):
+            self.revisionId = self.revisionExpr
+        else:
+            self.revisionId = revisionId
+    def UpdatePaths(self, relpath, worktree, gitdir, objdir):
+        """Update paths used by this project"""
+        self.gitdir = gitdir.replace("\\", "/")
+        self.objdir = objdir.replace("\\", "/")
+        if worktree:
+            self.worktree = os.path.normpath(worktree).replace("\\", "/")
+        else:
+            self.worktree = None
+        self.relpath = relpath
-  @property
+        self.config = GitConfig.ForRepository(
-  def CurrentBranch(self):
+            gitdir=self.gitdir, defaults=self.manifest.globalConfig
-    """Obtain the name of the currently checked out branch.
+        )
-    The branch name omits the 'refs/heads/' prefix.
+        if self.worktree:
-    None is returned if the project is on a detached HEAD, or if the work_git is
+            self.work_git = self._GitGetByExec(
-    otheriwse inaccessible (e.g. an incomplete sync).
+                self, bare=False, gitdir=self.gitdir
-    """
+            )
-    try:
+        else:
-      b = self.work_git.GetHead()
+            self.work_git = None
-    except NoManifestException:
+        self.bare_git = self._GitGetByExec(self, bare=True, gitdir=self.gitdir)
-      # If the local checkout is in a bad state, don't barf.  Let the callers
+        self.bare_ref = GitRefs(self.gitdir)
-      # process this like the head is unreadable.
+        self.bare_objdir = self._GitGetByExec(
-      return None
+            self, bare=True, gitdir=self.objdir
-    if b.startswith(R_HEADS):
+        )
-      return b[len(R_HEADS):]
-    return None
-  def IsRebaseInProgress(self):
-    return (os.path.exists(self.work_git.GetDotgitPath('rebase-apply')) or
-            os.path.exists(self.work_git.GetDotgitPath('rebase-merge')) or
-            os.path.exists(os.path.join(self.worktree, '.dotest')))
-  def IsDirty(self, consider_untracked=True):
-    """Is the working directory modified in some way?
-    """
-    self.work_git.update_index('-q',
-                               '--unmerged',
-                               '--ignore-missing',
-                               '--refresh')
-    if self.work_git.DiffZ('diff-index', '-M', '--cached', HEAD):
-      return True
-    if self.work_git.DiffZ('diff-files'):
-      return True
-    if consider_untracked and self.UntrackedFiles():
-      return True
-    return False
-  _userident_name = None
-  _userident_email = None
-  @property
-  def UserName(self):
-    """Obtain the user's personal name.
-    """
-    if self._userident_name is None:
-      self._LoadUserIdentity()
-    return self._userident_name
-  @property
-  def UserEmail(self):
-    """Obtain the user's email address.  This is very likely
-       to be their Gerrit login.
-    """
-    if self._userident_email is None:
-      self._LoadUserIdentity()
-    return self._userident_email
-  def _LoadUserIdentity(self):
-    u = self.bare_git.var('GIT_COMMITTER_IDENT')
-    m = re.compile("^(.*) <([^>]*)> ").match(u)
-    if m:
-      self._userident_name = m.group(1)
-      self._userident_email = m.group(2)
-    else:
-      self._userident_name = ''
-      self._userident_email = ''
-  def GetRemote(self, name=None):
-    """Get the configuration for a single remote.
-    Defaults to the current project's remote.
-    """
-    if name is None:
-      name = self.remote.name
-    return self.config.GetRemote(name)
-  def GetBranch(self, name):
+    @property
-    """Get the configuration for a single branch.
+    def UseAlternates(self):
-    """
+        """Whether git alternates are in use.
-    return self.config.GetBranch(name)
+        This will be removed once migration to alternates is complete.
+        """
+        return _ALTERNATES or self.manifest.is_multimanifest
+    @property
+    def Derived(self):
+        return self.is_derived
+    @property
+    def Exists(self):
+        return platform_utils.isdir(self.gitdir) and platform_utils.isdir(
+            self.objdir
+        )
+    @property
+    def CurrentBranch(self):
+        """Obtain the name of the currently checked out branch.
+        The branch name omits the 'refs/heads/' prefix.
+        None is returned if the project is on a detached HEAD, or if the
+        work_git is otheriwse inaccessible (e.g. an incomplete sync).
+        """
+        try:
+            b = self.work_git.GetHead()
+        except NoManifestException:
+            # If the local checkout is in a bad state, don't barf.  Let the
+            # callers process this like the head is unreadable.
+            return None
+        if b.startswith(R_HEADS):
+            return b[len(R_HEADS) :]
+        return None
+    def IsRebaseInProgress(self):
+        return (
+            os.path.exists(self.work_git.GetDotgitPath("rebase-apply"))
+            or os.path.exists(self.work_git.GetDotgitPath("rebase-merge"))
+            or os.path.exists(os.path.join(self.worktree, ".dotest"))
+        )
+    def IsDirty(self, consider_untracked=True):
+        """Is the working directory modified in some way?"""
+        self.work_git.update_index(
+            "-q", "--unmerged", "--ignore-missing", "--refresh"
+        )
+        if self.work_git.DiffZ("diff-index", "-M", "--cached", HEAD):
+            return True
+        if self.work_git.DiffZ("diff-files"):
+            return True
+        if consider_untracked and self.UntrackedFiles():
+            return True
+        return False
+    _userident_name = None
+    _userident_email = None
+    @property
+    def UserName(self):
+        """Obtain the user's personal name."""
+        if self._userident_name is None:
+            self._LoadUserIdentity()
+        return self._userident_name
+    @property
+    def UserEmail(self):
+        """Obtain the user's email address.  This is very likely
+        to be their Gerrit login.
+        """
+        if self._userident_email is None:
+            self._LoadUserIdentity()
+        return self._userident_email
+    def _LoadUserIdentity(self):
+        u = self.bare_git.var("GIT_COMMITTER_IDENT")
+        m = re.compile("^(.*) <([^>]*)> ").match(u)
+        if m:
+            self._userident_name = m.group(1)
+            self._userident_email = m.group(2)
+        else:
+            self._userident_name = ""
+            self._userident_email = ""
+    def GetRemote(self, name=None):
+        """Get the configuration for a single remote.
+        Defaults to the current project's remote.
+        """
+        if name is None:
+            name = self.remote.name
+        return self.config.GetRemote(name)
+    def GetBranch(self, name):
+        """Get the configuration for a single branch."""
+        return self.config.GetBranch(name)
+    def GetBranches(self):
+        """Get all existing local branches."""
+        current = self.CurrentBranch
+        all_refs = self._allrefs
+        heads = {}
+        for name, ref_id in all_refs.items():
+            if name.startswith(R_HEADS):
+                name = name[len(R_HEADS) :]
+                b = self.GetBranch(name)
+                b.current = name == current
+                b.published = None
+                b.revision = ref_id
+                heads[name] = b
+        for name, ref_id in all_refs.items():
+            if name.startswith(R_PUB):
+                name = name[len(R_PUB) :]
+                b = heads.get(name)
+                if b:
+                    b.published = ref_id
+        return heads
+    def MatchesGroups(self, manifest_groups):
+        """Returns true if the manifest groups specified at init should cause
+        this project to be synced.
+        Prefixing a manifest group with "-" inverts the meaning of a group.
+        All projects are implicitly labelled with "all".
+        labels are resolved in order.  In the example case of
+        project_groups: "all,group1,group2"
+        manifest_groups: "-group1,group2"
+        the project will be matched.
+        The special manifest group "default" will match any project that
+        does not have the special project group "notdefault"
+        """
+        default_groups = self.manifest.default_groups or ["default"]
+        expanded_manifest_groups = manifest_groups or default_groups
+        expanded_project_groups = ["all"] + (self.groups or [])
+        if "notdefault" not in expanded_project_groups:
+            expanded_project_groups += ["default"]
-  def GetBranches(self):
-    """Get all existing local branches.
-    """
-    current = self.CurrentBranch
-    all_refs = self._allrefs
-    heads = {}
-    for name, ref_id in all_refs.items():
-      if name.startswith(R_HEADS):
-        name = name[len(R_HEADS):]
-        b = self.GetBranch(name)
-        b.current = name == current
-        b.published = None
-        b.revision = ref_id
-        heads[name] = b
-    for name, ref_id in all_refs.items():
-      if name.startswith(R_PUB):
-        name = name[len(R_PUB):]
-        b = heads.get(name)
-        if b:
-          b.published = ref_id
-    return heads
-  def MatchesGroups(self, manifest_groups):
-    """Returns true if the manifest groups specified at init should cause
-       this project to be synced.
-       Prefixing a manifest group with "-" inverts the meaning of a group.
-       All projects are implicitly labelled with "all".
-       labels are resolved in order.  In the example case of
-       project_groups: "all,group1,group2"
-       manifest_groups: "-group1,group2"
-       the project will be matched.
-       The special manifest group "default" will match any project that
-       does not have the special project group "notdefault"
-    """
-    default_groups = self.manifest.default_groups or ['default']
-    expanded_manifest_groups = manifest_groups or default_groups
-    expanded_project_groups = ['all'] + (self.groups or [])
-    if 'notdefault' not in expanded_project_groups:
-      expanded_project_groups += ['default']
-    matched = False
-    for group in expanded_manifest_groups:
-      if group.startswith('-') and group[1:] in expanded_project_groups:
        matched = False
-      elif group in expanded_project_groups:
+        for group in expanded_manifest_groups:
-        matched = True
+            if group.startswith("-") and group[1:] in expanded_project_groups:
+                matched = False
+            elif group in expanded_project_groups:
+                matched = True
-    return matched
+        return matched
-# Status Display ##
+    def UncommitedFiles(self, get_all=True):
-  def UncommitedFiles(self, get_all=True):
+        """Returns a list of strings, uncommitted files in the git tree.
-    """Returns a list of strings, uncommitted files in the git tree.
-    Args:
+        Args:
-      get_all: a boolean, if True - get information about all different
+            get_all: a boolean, if True - get information about all different
-               uncommitted files. If False - return as soon as any kind of
+                uncommitted files. If False - return as soon as any kind of
-               uncommitted files is detected.
+                uncommitted files is detected.
-    """
+        """
-    details = []
+        details = []
-    self.work_git.update_index('-q',
+        self.work_git.update_index(
-                               '--unmerged',
+            "-q", "--unmerged", "--ignore-missing", "--refresh"
-                               '--ignore-missing',
+        )
-                               '--refresh')
+        if self.IsRebaseInProgress():
-    if self.IsRebaseInProgress():
+            details.append("rebase in progress")
-      details.append("rebase in progress")
+            if not get_all:
-      if not get_all:
+                return details
-        return details
+        changes = self.work_git.DiffZ("diff-index", "--cached", HEAD).keys()
+        if changes:
+            details.extend(changes)
+            if not get_all:
+                return details
+        changes = self.work_git.DiffZ("diff-files").keys()
+        if changes:
+            details.extend(changes)
+            if not get_all:
+                return details
+        changes = self.UntrackedFiles()
+        if changes:
+            details.extend(changes)
-    changes = self.work_git.DiffZ('diff-index', '--cached', HEAD).keys()
-    if changes:
-      details.extend(changes)
-      if not get_all:
        return details
-    changes = self.work_git.DiffZ('diff-files').keys()
+    def UntrackedFiles(self):
-    if changes:
+        """Returns a list of strings, untracked files in the git tree."""
-      details.extend(changes)
+        return self.work_git.LsOthers()
-      if not get_all:
-        return details
-    changes = self.UntrackedFiles()
+    def HasChanges(self):
-    if changes:
+        """Returns true if there are uncommitted changes."""
-      details.extend(changes)
+        return bool(self.UncommitedFiles(get_all=False))
-    return details
+    def PrintWorkTreeStatus(self, output_redir=None, quiet=False, local=False):
+        """Prints the status of the repository to stdout.
-  def UntrackedFiles(self):
+        Args:
-    """Returns a list of strings, untracked files in the git tree."""
+            output_redir: If specified, redirect the output to this object.
-    return self.work_git.LsOthers()
+            quiet:  If True then only print the project name.  Do not print
+                the modified files, branch name, etc.
+            local: a boolean, if True, the path is relative to the local
+                (sub)manifest.  If false, the path is relative to the outermost
+                manifest.
+        """
+        if not platform_utils.isdir(self.worktree):
+            if output_redir is None:
+                output_redir = sys.stdout
+            print(file=output_redir)
+            print("project %s/" % self.RelPath(local), file=output_redir)
+            print('  missing (run "repo sync")', file=output_redir)
+            return
+        self.work_git.update_index(
+            "-q", "--unmerged", "--ignore-missing", "--refresh"
+        )
+        rb = self.IsRebaseInProgress()
+        di = self.work_git.DiffZ("diff-index", "-M", "--cached", HEAD)
+        df = self.work_git.DiffZ("diff-files")
+        do = self.work_git.LsOthers()
+        if not rb and not di and not df and not do and not self.CurrentBranch:
+            return "CLEAN"
+        out = StatusColoring(self.config)
+        if output_redir is not None:
+            out.redirect(output_redir)
+        out.project("project %-40s", self.RelPath(local) + "/ ")
+        if quiet:
+            out.nl()
+            return "DIRTY"
+        branch = self.CurrentBranch
+        if branch is None:
+            out.nobranch("(*** NO BRANCH ***)")
+        else:
+            out.branch("branch %s", branch)
+        out.nl()
-  def HasChanges(self):
+        if rb:
-    """Returns true if there are uncommitted changes.
+            out.important("prior sync failed; rebase still in progress")
-    """
+            out.nl()
-    return bool(self.UncommitedFiles(get_all=False))
-  def PrintWorkTreeStatus(self, output_redir=None, quiet=False, local=False):
-    """Prints the status of the repository to stdout.
-    Args:
-      output_redir: If specified, redirect the output to this object.
-      quiet:  If True then only print the project name.  Do not print
-              the modified files, branch name, etc.
-      local: a boolean, if True, the path is relative to the local
-             (sub)manifest.  If false, the path is relative to the
-             outermost manifest.
-    """
-    if not platform_utils.isdir(self.worktree):
-      if output_redir is None:
-        output_redir = sys.stdout
-      print(file=output_redir)
-      print('project %s/' % self.RelPath(local), file=output_redir)
-      print('  missing (run "repo sync")', file=output_redir)
-      return
-    self.work_git.update_index('-q',
-                               '--unmerged',
-                               '--ignore-missing',
-                               '--refresh')
-    rb = self.IsRebaseInProgress()
-    di = self.work_git.DiffZ('diff-index', '-M', '--cached', HEAD)
-    df = self.work_git.DiffZ('diff-files')
-    do = self.work_git.LsOthers()
-    if not rb and not di and not df and not do and not self.CurrentBranch:
-      return 'CLEAN'
-    out = StatusColoring(self.config)
-    if output_redir is not None:
-      out.redirect(output_redir)
-    out.project('project %-40s', self.RelPath(local) + '/ ')
-    if quiet:
-      out.nl()
-      return 'DIRTY'
-    branch = self.CurrentBranch
-    if branch is None:
-      out.nobranch('(*** NO BRANCH ***)')
-    else:
-      out.branch('branch %s', branch)
-    out.nl()
-    if rb:
-      out.important('prior sync failed; rebase still in progress')
-      out.nl()
-    paths = list()
-    paths.extend(di.keys())
-    paths.extend(df.keys())
-    paths.extend(do)
-    for p in sorted(set(paths)):
-      try:
-        i = di[p]
-      except KeyError:
-        i = None
-      try:
-        f = df[p]
-      except KeyError:
-        f = None
-      if i:
-        i_status = i.status.upper()
-      else:
-        i_status = '-'
-      if f:
-        f_status = f.status.lower()
-      else:
-        f_status = '-'
-      if i and i.src_path:
-        line = ' %s%s\t%s => %s (%s%%)' % (i_status, f_status,
-                                           i.src_path, p, i.level)
-      else:
-        line = ' %s%s\t%s' % (i_status, f_status, p)
-      if i and not f:
-        out.added('%s', line)
-      elif (i and f) or (not i and f):
-        out.changed('%s', line)
-      elif not i and not f:
-        out.untracked('%s', line)
-      else:
-        out.write('%s', line)
-      out.nl()
-    return 'DIRTY'
-  def PrintWorkTreeDiff(self, absolute_paths=False, output_redir=None,
-                        local=False):
-    """Prints the status of the repository to stdout.
-    """
-    out = DiffColoring(self.config)
-    if output_redir:
-      out.redirect(output_redir)
-    cmd = ['diff']
-    if out.is_on:
-      cmd.append('--color')
-    cmd.append(HEAD)
-    if absolute_paths:
-      cmd.append('--src-prefix=a/%s/' % self.RelPath(local))
-      cmd.append('--dst-prefix=b/%s/' % self.RelPath(local))
-    cmd.append('--')
-    try:
-      p = GitCommand(self,
-                     cmd,
-                     capture_stdout=True,
-                     capture_stderr=True)
-      p.Wait()
-    except GitError as e:
-      out.nl()
-      out.project('project %s/' % self.RelPath(local))
-      out.nl()
-      out.fail('%s', str(e))
-      out.nl()
-      return False
-    if p.stdout:
-      out.nl()
-      out.project('project %s/' % self.RelPath(local))
-      out.nl()
-      out.write('%s', p.stdout)
-    return p.Wait() == 0
-# Publish / Upload ##
-  def WasPublished(self, branch, all_refs=None):
-    """Was the branch published (uploaded) for code review?
-       If so, returns the SHA-1 hash of the last published
-       state for the branch.
-    """
-    key = R_PUB + branch
-    if all_refs is None:
-      try:
-        return self.bare_git.rev_parse(key)
-      except GitError:
-        return None
-    else:
-      try:
-        return all_refs[key]
-      except KeyError:
-        return None
-  def CleanPublishedCache(self, all_refs=None):
+        paths = list()
-    """Prunes any stale published refs.
+        paths.extend(di.keys())
-    """
+        paths.extend(df.keys())
-    if all_refs is None:
+        paths.extend(do)
-      all_refs = self._allrefs
-    heads = set()
-    canrm = {}
-    for name, ref_id in all_refs.items():
-      if name.startswith(R_HEADS):
-        heads.add(name)
-      elif name.startswith(R_PUB):
-        canrm[name] = ref_id
-    for name, ref_id in canrm.items():
-      n = name[len(R_PUB):]
-      if R_HEADS + n not in heads:
-        self.bare_git.DeleteRef(name, ref_id)
-  def GetUploadableBranches(self, selected_branch=None):
-    """List any branches which can be uploaded for review.
-    """
-    heads = {}
-    pubed = {}
-    for name, ref_id in self._allrefs.items():
-      if name.startswith(R_HEADS):
-        heads[name[len(R_HEADS):]] = ref_id
-      elif name.startswith(R_PUB):
-        pubed[name[len(R_PUB):]] = ref_id
-    ready = []
-    for branch, ref_id in heads.items():
-      if branch in pubed and pubed[branch] == ref_id:
-        continue
-      if selected_branch and branch != selected_branch:
-        continue
-      rb = self.GetUploadableBranch(branch)
-      if rb:
-        ready.append(rb)
-    return ready
-  def GetUploadableBranch(self, branch_name):
-    """Get a single uploadable branch, or None.
-    """
-    branch = self.GetBranch(branch_name)
-    base = branch.LocalMerge
-    if branch.LocalMerge:
-      rb = ReviewableBranch(self, branch, base)
-      if rb.commits:
-        return rb
-    return None
-  def UploadForReview(self, branch=None,
-                      people=([], []),
-                      dryrun=False,
-                      auto_topic=False,
-                      hashtags=(),
-                      labels=(),
-                      private=False,
-                      notify=None,
-                      wip=False,
-                      ready=False,
-                      dest_branch=None,
-                      validate_certs=True,
-                      push_options=None):
-    """Uploads the named branch for code review.
-    """
-    if branch is None:
-      branch = self.CurrentBranch
-    if branch is None:
-      raise GitError('not currently on a branch')
-    branch = self.GetBranch(branch)
-    if not branch.LocalMerge:
-      raise GitError('branch %s does not track a remote' % branch.name)
-    if not branch.remote.review:
-      raise GitError('remote %s has no review url' % branch.remote.name)
-    # Basic validity check on label syntax.
-    for label in labels:
-      if not re.match(r'^.+[+-][0-9]+$', label):
-        raise UploadError(
-            f'invalid label syntax "{label}": labels use forms like '
-            'CodeReview+1 or Verified-1')
-    if dest_branch is None:
-      dest_branch = self.dest_branch
-    if dest_branch is None:
-      dest_branch = branch.merge
-    if not dest_branch.startswith(R_HEADS):
-      dest_branch = R_HEADS + dest_branch
-    if not branch.remote.projectname:
-      branch.remote.projectname = self.name
-      branch.remote.Save()
-    url = branch.remote.ReviewUrl(self.UserEmail, validate_certs)
-    if url is None:
-      raise UploadError('review not configured')
-    cmd = ['push']
-    if dryrun:
-      cmd.append('-n')
-    if url.startswith('ssh://'):
-      cmd.append('--receive-pack=gerrit receive-pack')
-    for push_option in (push_options or []):
-      cmd.append('-o')
-      cmd.append(push_option)
-    cmd.append(url)
-    if dest_branch.startswith(R_HEADS):
-      dest_branch = dest_branch[len(R_HEADS):]
-    ref_spec = '%s:refs/for/%s' % (R_HEADS + branch.name, dest_branch)
-    opts = []
-    if auto_topic:
-      opts += ['topic=' + branch.name]
-    opts += ['t=%s' % p for p in hashtags]
-    # NB: No need to encode labels as they've been validated above.
-    opts += ['l=%s' % p for p in labels]
-    opts += ['r=%s' % p for p in people[0]]
-    opts += ['cc=%s' % p for p in people[1]]
-    if notify:
-      opts += ['notify=' + notify]
-    if private:
-      opts += ['private']
-    if wip:
-      opts += ['wip']
-    if ready:
-      opts += ['ready']
-    if opts:
-      ref_spec = ref_spec + '%' + ','.join(opts)
-    cmd.append(ref_spec)
-    if GitCommand(self, cmd, bare=True).Wait() != 0:
-      raise UploadError('Upload failed')
-    if not dryrun:
-      msg = "posted to %s for %s" % (branch.remote.review, dest_branch)
-      self.bare_git.UpdateRef(R_PUB + branch.name,
-                              R_HEADS + branch.name,
-                              message=msg)
-# Sync ##
-  def _ExtractArchive(self, tarpath, path=None):
-    """Extract the given tar on its current location
-    Args:
-        - tarpath: The path to the actual tar file
-    """
+        for p in sorted(set(paths)):
-    try:
+            try:
-      with tarfile.open(tarpath, 'r') as tar:
+                i = di[p]
-        tar.extractall(path=path)
+            except KeyError:
-        return True
+                i = None
-    except (IOError, tarfile.TarError) as e:
-      _error("Cannot extract archive %s: %s", tarpath, str(e))
-    return False
-  def Sync_NetworkHalf(self,
-                       quiet=False,
-                       verbose=False,
-                       output_redir=None,
-                       is_new=None,
-                       current_branch_only=None,
-                       force_sync=False,
-                       clone_bundle=True,
-                       tags=None,
-                       archive=False,
-                       optimized_fetch=False,
-                       retry_fetches=0,
-                       prune=False,
-                       submodules=False,
-                       ssh_proxy=None,
-                       clone_filter=None,
-                       partial_clone_exclude=set()):
-    """Perform only the network IO portion of the sync process.
-       Local working directory/branch state is not affected.
-    """
-    if archive and not isinstance(self, MetaProject):
-      if self.remote.url.startswith(('http://', 'https://')):
-        _error("%s: Cannot fetch archives from http/https remotes.", self.name)
-        return SyncNetworkHalfResult(False, False)
-      name = self.relpath.replace('\\', '/')
-      name = name.replace('/', '_')
-      tarpath = '%s.tar' % name
-      topdir = self.manifest.topdir
-      try:
-        self._FetchArchive(tarpath, cwd=topdir)
-      except GitError as e:
-        _error('%s', e)
-        return SyncNetworkHalfResult(False, False)
-      # From now on, we only need absolute tarpath
-      tarpath = os.path.join(topdir, tarpath)
-      if not self._ExtractArchive(tarpath, path=topdir):
-        return SyncNetworkHalfResult(False, True)
-      try:
-        platform_utils.remove(tarpath)
-      except OSError as e:
-        _warn("Cannot remove archive %s: %s", tarpath, str(e))
-      self._CopyAndLinkFiles()
-      return SyncNetworkHalfResult(True, True)
-    # If the shared object dir already exists, don't try to rebootstrap with a
-    # clone bundle download.  We should have the majority of objects already.
-    if clone_bundle and os.path.exists(self.objdir):
-      clone_bundle = False
-    if self.name in partial_clone_exclude:
-      clone_bundle = True
-      clone_filter = None
-    if is_new is None:
-      is_new = not self.Exists
-    if is_new:
-      self._InitGitDir(force_sync=force_sync, quiet=quiet)
-    else:
-      self._UpdateHooks(quiet=quiet)
-    self._InitRemote()
-    if self.UseAlternates:
-      # If gitdir/objects is a symlink, migrate it from the old layout.
-      gitdir_objects = os.path.join(self.gitdir, 'objects')
-      if platform_utils.islink(gitdir_objects):
-        platform_utils.remove(gitdir_objects, missing_ok=True)
-      gitdir_alt = os.path.join(self.gitdir, 'objects/info/alternates')
-      if not os.path.exists(gitdir_alt):
-        os.makedirs(os.path.dirname(gitdir_alt), exist_ok=True)
-        _lwrite(gitdir_alt, os.path.join(
-            os.path.relpath(self.objdir, gitdir_objects), 'objects') + '\n')
-    if is_new:
-      alt = os.path.join(self.objdir, 'objects/info/alternates')
-      try:
-        with open(alt) as fd:
-          # This works for both absolute and relative alternate directories.
-          alt_dir = os.path.join(self.objdir, 'objects', fd.readline().rstrip())
-      except IOError:
-        alt_dir = None
-    else:
-      alt_dir = None
-    if (clone_bundle
-            and alt_dir is None
-            and self._ApplyCloneBundle(initial=is_new, quiet=quiet, verbose=verbose)):
-      is_new = False
-    if current_branch_only is None:
-      if self.sync_c:
-        current_branch_only = True
-      elif not self.manifest._loaded:
-        # Manifest cannot check defaults until it syncs.
-        current_branch_only = False
-      elif self.manifest.default.sync_c:
-        current_branch_only = True
-    if tags is None:
-      tags = self.sync_tags
-    if self.clone_depth:
-      depth = self.clone_depth
-    else:
-      depth = self.manifest.manifestProject.depth
-    # See if we can skip the network fetch entirely.
-    remote_fetched = False
-    if not (optimized_fetch and
-            (ID_RE.match(self.revisionExpr) and
-             self._CheckForImmutableRevision())):
-      remote_fetched = True
-      if not self._RemoteFetch(
-              initial=is_new,
-              quiet=quiet, verbose=verbose, output_redir=output_redir,
-              alt_dir=alt_dir, current_branch_only=current_branch_only,
-              tags=tags, prune=prune, depth=depth,
-              submodules=submodules, force_sync=force_sync,
-              ssh_proxy=ssh_proxy,
-              clone_filter=clone_filter, retry_fetches=retry_fetches):
-        return SyncNetworkHalfResult(False, remote_fetched)
-    mp = self.manifest.manifestProject
-    dissociate = mp.dissociate
-    if dissociate:
-      alternates_file = os.path.join(self.objdir, 'objects/info/alternates')
-      if os.path.exists(alternates_file):
-        cmd = ['repack', '-a', '-d']
-        p = GitCommand(self, cmd, bare=True, capture_stdout=bool(output_redir),
-                       merge_output=bool(output_redir))
-        if p.stdout and output_redir:
-          output_redir.write(p.stdout)
-        if p.Wait() != 0:
-          return SyncNetworkHalfResult(False, remote_fetched)
-        platform_utils.remove(alternates_file)
-    if self.worktree:
-      self._InitMRef()
-    else:
-      self._InitMirrorHead()
-      platform_utils.remove(os.path.join(self.gitdir, 'FETCH_HEAD'),
-                            missing_ok=True)
-    return SyncNetworkHalfResult(True, remote_fetched)
-  def PostRepoUpgrade(self):
-    self._InitHooks()
-  def _CopyAndLinkFiles(self):
-    if self.client.isGitcClient:
-      return
-    for copyfile in self.copyfiles:
-      copyfile._Copy()
-    for linkfile in self.linkfiles:
-      linkfile._Link()
-  def GetCommitRevisionId(self):
-    """Get revisionId of a commit.
-    Use this method instead of GetRevisionId to get the id of the commit rather
-    than the id of the current git object (for example, a tag)
-    """
+            try:
-    if not self.revisionExpr.startswith(R_TAGS):
+                f = df[p]
-      return self.GetRevisionId(self._allrefs)
+            except KeyError:
+                f = None
+            if i:
+                i_status = i.status.upper()
+            else:
+                i_status = "-"
+            if f:
+                f_status = f.status.lower()
+            else:
+                f_status = "-"
+            if i and i.src_path:
+                line = " %s%s\t%s => %s (%s%%)" % (
+                    i_status,
+                    f_status,
+                    i.src_path,
+                    p,
+                    i.level,
+                )
+            else:
+                line = " %s%s\t%s" % (i_status, f_status, p)
+            if i and not f:
+                out.added("%s", line)
+            elif (i and f) or (not i and f):
+                out.changed("%s", line)
+            elif not i and not f:
+                out.untracked("%s", line)
+            else:
+                out.write("%s", line)
+            out.nl()
+        return "DIRTY"
+    def PrintWorkTreeDiff(
+        self, absolute_paths=False, output_redir=None, local=False
+    ):
+        """Prints the status of the repository to stdout."""
+        out = DiffColoring(self.config)
+        if output_redir:
+            out.redirect(output_redir)
+        cmd = ["diff"]
+        if out.is_on:
+            cmd.append("--color")
+        cmd.append(HEAD)
+        if absolute_paths:
+            cmd.append("--src-prefix=a/%s/" % self.RelPath(local))
+            cmd.append("--dst-prefix=b/%s/" % self.RelPath(local))
+        cmd.append("--")
+        try:
+            p = GitCommand(self, cmd, capture_stdout=True, capture_stderr=True)
+            p.Wait()
+        except GitError as e:
+            out.nl()
+            out.project("project %s/" % self.RelPath(local))
+            out.nl()
+            out.fail("%s", str(e))
+            out.nl()
+            return False
+        if p.stdout:
+            out.nl()
+            out.project("project %s/" % self.RelPath(local))
+            out.nl()
+            out.write("%s", p.stdout)
+        return p.Wait() == 0
+    def WasPublished(self, branch, all_refs=None):
+        """Was the branch published (uploaded) for code review?
+        If so, returns the SHA-1 hash of the last published
+        state for the branch.
+        """
+        key = R_PUB + branch
+        if all_refs is None:
+            try:
+                return self.bare_git.rev_parse(key)
+            except GitError:
+                return None
+        else:
+            try:
+                return all_refs[key]
+            except KeyError:
+                return None
+    def CleanPublishedCache(self, all_refs=None):
+        """Prunes any stale published refs."""
+        if all_refs is None:
+            all_refs = self._allrefs
+        heads = set()
+        canrm = {}
+        for name, ref_id in all_refs.items():
+            if name.startswith(R_HEADS):
+                heads.add(name)
+            elif name.startswith(R_PUB):
+                canrm[name] = ref_id
+        for name, ref_id in canrm.items():
+            n = name[len(R_PUB) :]
+            if R_HEADS + n not in heads:
+                self.bare_git.DeleteRef(name, ref_id)
+    def GetUploadableBranches(self, selected_branch=None):
+        """List any branches which can be uploaded for review."""
+        heads = {}
+        pubed = {}
+        for name, ref_id in self._allrefs.items():
+            if name.startswith(R_HEADS):
+                heads[name[len(R_HEADS) :]] = ref_id
+            elif name.startswith(R_PUB):
+                pubed[name[len(R_PUB) :]] = ref_id
+        ready = []
+        for branch, ref_id in heads.items():
+            if branch in pubed and pubed[branch] == ref_id:
+                continue
+            if selected_branch and branch != selected_branch:
+                continue
+            rb = self.GetUploadableBranch(branch)
+            if rb:
+                ready.append(rb)
+        return ready
+    def GetUploadableBranch(self, branch_name):
+        """Get a single uploadable branch, or None."""
+        branch = self.GetBranch(branch_name)
+        base = branch.LocalMerge
+        if branch.LocalMerge:
+            rb = ReviewableBranch(self, branch, base)
+            if rb.commits:
+                return rb
+        return None
-    try:
+    def UploadForReview(
-      return self.bare_git.rev_list(self.revisionExpr, '-1')[0]
+        self,
-    except GitError:
+        branch=None,
-      raise ManifestInvalidRevisionError('revision %s in %s not found' %
+        people=([], []),
-                                         (self.revisionExpr, self.name))
+        dryrun=False,
+        auto_topic=False,
+        hashtags=(),
+        labels=(),
+        private=False,
+        notify=None,
+        wip=False,
+        ready=False,
+        dest_branch=None,
+        validate_certs=True,
+        push_options=None,
+    ):
+        """Uploads the named branch for code review."""
+        if branch is None:
+            branch = self.CurrentBranch
+        if branch is None:
+            raise GitError("not currently on a branch")
-  def GetRevisionId(self, all_refs=None):
+        branch = self.GetBranch(branch)
-    if self.revisionId:
+        if not branch.LocalMerge:
-      return self.revisionId
+            raise GitError("branch %s does not track a remote" % branch.name)
+        if not branch.remote.review:
+            raise GitError("remote %s has no review url" % branch.remote.name)
+        # Basic validity check on label syntax.
+        for label in labels:
+            if not re.match(r"^.+[+-][0-9]+$", label):
+                raise UploadError(
+                    f'invalid label syntax "{label}": labels use forms like '
+                    "CodeReview+1 or Verified-1"
+                )
+        if dest_branch is None:
+            dest_branch = self.dest_branch
+        if dest_branch is None:
+            dest_branch = branch.merge
+        if not dest_branch.startswith(R_HEADS):
+            dest_branch = R_HEADS + dest_branch
+        if not branch.remote.projectname:
+            branch.remote.projectname = self.name
+            branch.remote.Save()
+        url = branch.remote.ReviewUrl(self.UserEmail, validate_certs)
+        if url is None:
+            raise UploadError("review not configured")
+        cmd = ["push"]
+        if dryrun:
+            cmd.append("-n")
+        if url.startswith("ssh://"):
+            cmd.append("--receive-pack=gerrit receive-pack")
+        for push_option in push_options or []:
+            cmd.append("-o")
+            cmd.append(push_option)
+        cmd.append(url)
+        if dest_branch.startswith(R_HEADS):
+            dest_branch = dest_branch[len(R_HEADS) :]
+        ref_spec = "%s:refs/for/%s" % (R_HEADS + branch.name, dest_branch)
+        opts = []
+        if auto_topic:
+            opts += ["topic=" + branch.name]
+        opts += ["t=%s" % p for p in hashtags]
+        # NB: No need to encode labels as they've been validated above.
+        opts += ["l=%s" % p for p in labels]
+        opts += ["r=%s" % p for p in people[0]]
+        opts += ["cc=%s" % p for p in people[1]]
+        if notify:
+            opts += ["notify=" + notify]
+        if private:
+            opts += ["private"]
+        if wip:
+            opts += ["wip"]
+        if ready:
+            opts += ["ready"]
+        if opts:
+            ref_spec = ref_spec + "%" + ",".join(opts)
+        cmd.append(ref_spec)
+        if GitCommand(self, cmd, bare=True).Wait() != 0:
+            raise UploadError("Upload failed")
+        if not dryrun:
+            msg = "posted to %s for %s" % (branch.remote.review, dest_branch)
+            self.bare_git.UpdateRef(
+                R_PUB + branch.name, R_HEADS + branch.name, message=msg
+            )
+    def _ExtractArchive(self, tarpath, path=None):
+        """Extract the given tar on its current location
-    rem = self.GetRemote()
+        Args:
-    rev = rem.ToLocal(self.revisionExpr)
+            tarpath: The path to the actual tar file
-    if all_refs is not None and rev in all_refs:
+        """
-      return all_refs[rev]
+        try:
+            with tarfile.open(tarpath, "r") as tar:
+                tar.extractall(path=path)
+                return True
+        except (IOError, tarfile.TarError) as e:
+            _error("Cannot extract archive %s: %s", tarpath, str(e))
+        return False
-    try:
+    def Sync_NetworkHalf(
-      return self.bare_git.rev_parse('--verify', '%s^0' % rev)
+        self,
-    except GitError:
+        quiet=False,
-      raise ManifestInvalidRevisionError('revision %s in %s not found' %
+        verbose=False,
-                                         (self.revisionExpr, self.name))
+        output_redir=None,
+        is_new=None,
+        current_branch_only=None,
+        force_sync=False,
+        clone_bundle=True,
+        tags=None,
+        archive=False,
+        optimized_fetch=False,
+        retry_fetches=0,
+        prune=False,
+        submodules=False,
+        ssh_proxy=None,
+        clone_filter=None,
+        partial_clone_exclude=set(),
+    ):
+        """Perform only the network IO portion of the sync process.
+        Local working directory/branch state is not affected.
+        """
+        if archive and not isinstance(self, MetaProject):
+            if self.remote.url.startswith(("http://", "https://")):
+                _error(
+                    "%s: Cannot fetch archives from http/https remotes.",
+                    self.name,
+                )
+                return SyncNetworkHalfResult(False, False)
+            name = self.relpath.replace("\\", "/")
+            name = name.replace("/", "_")
+            tarpath = "%s.tar" % name
+            topdir = self.manifest.topdir
-  def SetRevisionId(self, revisionId):
+            try:
-    if self.revisionExpr:
+                self._FetchArchive(tarpath, cwd=topdir)
-      self.upstream = self.revisionExpr
+            except GitError as e:
+                _error("%s", e)
+                return SyncNetworkHalfResult(False, False)
-    self.revisionId = revisionId
+            # From now on, we only need absolute tarpath.
+            tarpath = os.path.join(topdir, tarpath)
-  def Sync_LocalHalf(self, syncbuf, force_sync=False, submodules=False):
+            if not self._ExtractArchive(tarpath, path=topdir):
-    """Perform only the local IO portion of the sync process.
+                return SyncNetworkHalfResult(False, True)
-       Network access is not required.
+            try:
-    """
+                platform_utils.remove(tarpath)
-    if not os.path.exists(self.gitdir):
+            except OSError as e:
-      syncbuf.fail(self,
+                _warn("Cannot remove archive %s: %s", tarpath, str(e))
-                   'Cannot checkout %s due to missing network sync; Run '
+            self._CopyAndLinkFiles()
-                   '`repo sync -n %s` first.' %
+            return SyncNetworkHalfResult(True, True)
-                   (self.name, self.name))
-      return
+        # If the shared object dir already exists, don't try to rebootstrap with
+        # a clone bundle download.  We should have the majority of objects
-    self._InitWorkTree(force_sync=force_sync, submodules=submodules)
+        # already.
-    all_refs = self.bare_ref.all
+        if clone_bundle and os.path.exists(self.objdir):
-    self.CleanPublishedCache(all_refs)
+            clone_bundle = False
-    revid = self.GetRevisionId(all_refs)
+        if self.name in partial_clone_exclude:
-    # Special case the root of the repo client checkout.  Make sure it doesn't
+            clone_bundle = True
-    # contain files being checked out to dirs we don't allow.
+            clone_filter = None
-    if self.relpath == '.':
-      PROTECTED_PATHS = {'.repo'}
+        if is_new is None:
-      paths = set(self.work_git.ls_tree('-z', '--name-only', '--', revid).split('\0'))
+            is_new = not self.Exists
-      bad_paths = paths & PROTECTED_PATHS
+        if is_new:
-      if bad_paths:
+            self._InitGitDir(force_sync=force_sync, quiet=quiet)
-        syncbuf.fail(self,
+        else:
-                     'Refusing to checkout project that writes to protected '
+            self._UpdateHooks(quiet=quiet)
-                     'paths: %s' % (', '.join(bad_paths),))
+        self._InitRemote()
-        return
+        if self.UseAlternates:
-    def _doff():
+            # If gitdir/objects is a symlink, migrate it from the old layout.
-      self._FastForward(revid)
+            gitdir_objects = os.path.join(self.gitdir, "objects")
-      self._CopyAndLinkFiles()
+            if platform_utils.islink(gitdir_objects):
+                platform_utils.remove(gitdir_objects, missing_ok=True)
-    def _dosubmodules():
+            gitdir_alt = os.path.join(self.gitdir, "objects/info/alternates")
-      self._SyncSubmodules(quiet=True)
+            if not os.path.exists(gitdir_alt):
+                os.makedirs(os.path.dirname(gitdir_alt), exist_ok=True)
-    head = self.work_git.GetHead()
+                _lwrite(
-    if head.startswith(R_HEADS):
+                    gitdir_alt,
-      branch = head[len(R_HEADS):]
+                    os.path.join(
-      try:
+                        os.path.relpath(self.objdir, gitdir_objects), "objects"
-        head = all_refs[head]
+                    )
-      except KeyError:
+                    + "\n",
-        head = None
+                )
-    else:
-      branch = None
-    if branch is None or syncbuf.detach_head:
-      # Currently on a detached HEAD.  The user is assumed to
-      # not have any local modifications worth worrying about.
-      #
-      if self.IsRebaseInProgress():
-        syncbuf.fail(self, _PriorSyncFailedError())
-        return
-      if head == revid:
-        # No changes; don't do anything further.
-        # Except if the head needs to be detached
-        #
-        if not syncbuf.detach_head:
-          # The copy/linkfile config may have changed.
-          self._CopyAndLinkFiles()
-          return
-      else:
-        lost = self._revlist(not_rev(revid), HEAD)
-        if lost:
-          syncbuf.info(self, "discarding %d commits", len(lost))
-      try:
-        self._Checkout(revid, quiet=True)
-        if submodules:
-          self._SyncSubmodules(quiet=True)
-      except GitError as e:
-        syncbuf.fail(self, e)
-        return
-      self._CopyAndLinkFiles()
-      return
-    if head == revid:
-      # No changes; don't do anything further.
-      #
-      # The copy/linkfile config may have changed.
-      self._CopyAndLinkFiles()
-      return
-    branch = self.GetBranch(branch)
-    if not branch.LocalMerge:
-      # The current branch has no tracking configuration.
-      # Jump off it to a detached HEAD.
-      #
-      syncbuf.info(self,
-                   "leaving %s; does not track upstream",
-                   branch.name)
-      try:
-        self._Checkout(revid, quiet=True)
-        if submodules:
-          self._SyncSubmodules(quiet=True)
-      except GitError as e:
-        syncbuf.fail(self, e)
-        return
-      self._CopyAndLinkFiles()
-      return
-    upstream_gain = self._revlist(not_rev(HEAD), revid)
+        if is_new:
+            alt = os.path.join(self.objdir, "objects/info/alternates")
+            try:
+                with open(alt) as fd:
+                    # This works for both absolute and relative alternate
+                    # directories.
+                    alt_dir = os.path.join(
+                        self.objdir, "objects", fd.readline().rstrip()
+                    )
+            except IOError:
+                alt_dir = None
+        else:
+            alt_dir = None
-    # See if we can perform a fast forward merge.  This can happen if our
+        if (
-    # branch isn't in the exact same state as we last published.
+            clone_bundle
-    try:
+            and alt_dir is None
-      self.work_git.merge_base('--is-ancestor', HEAD, revid)
+            and self._ApplyCloneBundle(
-      # Skip the published logic.
+                initial=is_new, quiet=quiet, verbose=verbose
-      pub = False
+            )
-    except GitError:
+        ):
-      pub = self.WasPublished(branch.name, all_refs)
+            is_new = False
-    if pub:
+        if current_branch_only is None:
-      not_merged = self._revlist(not_rev(revid), pub)
+            if self.sync_c:
-      if not_merged:
+                current_branch_only = True
-        if upstream_gain:
+            elif not self.manifest._loaded:
-          # The user has published this branch and some of those
+                # Manifest cannot check defaults until it syncs.
-          # commits are not yet merged upstream.  We do not want
+                current_branch_only = False
-          # to rewrite the published commits so we punt.
+            elif self.manifest.default.sync_c:
-          #
+                current_branch_only = True
-          syncbuf.fail(self,
-                       "branch %s is published (but not merged) and is now "
+        if tags is None:
-                       "%d commits behind" % (branch.name, len(upstream_gain)))
+            tags = self.sync_tags
-        return
-      elif pub == head:
+        if self.clone_depth:
-        # All published commits are merged, and thus we are a
+            depth = self.clone_depth
-        # strict subset.  We can fast-forward safely.
+        else:
-        #
+            depth = self.manifest.manifestProject.depth
-        syncbuf.later1(self, _doff)
-        if submodules:
+        # See if we can skip the network fetch entirely.
-          syncbuf.later1(self, _dosubmodules)
+        remote_fetched = False
-        return
+        if not (
+            optimized_fetch
-    # Examine the local commits not in the remote.  Find the
+            and (
-    # last one attributed to this user, if any.
+                ID_RE.match(self.revisionExpr)
-    #
+                and self._CheckForImmutableRevision()
-    local_changes = self._revlist(not_rev(revid), HEAD, format='%H %ce')
+            )
-    last_mine = None
+        ):
-    cnt_mine = 0
+            remote_fetched = True
-    for commit in local_changes:
+            if not self._RemoteFetch(
-      commit_id, committer_email = commit.split(' ', 1)
+                initial=is_new,
-      if committer_email == self.UserEmail:
+                quiet=quiet,
-        last_mine = commit_id
+                verbose=verbose,
-        cnt_mine += 1
+                output_redir=output_redir,
+                alt_dir=alt_dir,
-    if not upstream_gain and cnt_mine == len(local_changes):
+                current_branch_only=current_branch_only,
-      # The copy/linkfile config may have changed.
+                tags=tags,
-      self._CopyAndLinkFiles()
+                prune=prune,
-      return
+                depth=depth,
+                submodules=submodules,
-    if self.IsDirty(consider_untracked=False):
+                force_sync=force_sync,
-      syncbuf.fail(self, _DirtyError())
+                ssh_proxy=ssh_proxy,
-      return
+                clone_filter=clone_filter,
+                retry_fetches=retry_fetches,
-    # If the upstream switched on us, warn the user.
+            ):
-    #
+                return SyncNetworkHalfResult(False, remote_fetched)
-    if branch.merge != self.revisionExpr:
-      if branch.merge and self.revisionExpr:
-        syncbuf.info(self,
-                     'manifest switched %s...%s',
-                     branch.merge,
-                     self.revisionExpr)
-      elif branch.merge:
-        syncbuf.info(self,
-                     'manifest no longer tracks %s',
-                     branch.merge)
-    if cnt_mine < len(local_changes):
-      # Upstream rebased.  Not everything in HEAD
-      # was created by this user.
-      #
-      syncbuf.info(self,
-                   "discarding %d commits removed from upstream",
-                   len(local_changes) - cnt_mine)
-    branch.remote = self.GetRemote()
-    if not ID_RE.match(self.revisionExpr):
-      # in case of manifest sync the revisionExpr might be a SHA1
-      branch.merge = self.revisionExpr
-      if not branch.merge.startswith('refs/'):
-        branch.merge = R_HEADS + branch.merge
-    branch.Save()
-    if cnt_mine > 0 and self.rebase:
-      def _docopyandlink():
-        self._CopyAndLinkFiles()
-      def _dorebase():
-        self._Rebase(upstream='%s^1' % last_mine, onto=revid)
-      syncbuf.later2(self, _dorebase)
-      if submodules:
-        syncbuf.later2(self, _dosubmodules)
-      syncbuf.later2(self, _docopyandlink)
-    elif local_changes:
-      try:
-        self._ResetHard(revid)
-        if submodules:
-          self._SyncSubmodules(quiet=True)
-        self._CopyAndLinkFiles()
-      except GitError as e:
-        syncbuf.fail(self, e)
-        return
-    else:
-      syncbuf.later1(self, _doff)
-      if submodules:
-        syncbuf.later1(self, _dosubmodules)
-  def AddCopyFile(self, src, dest, topdir):
-    """Mark |src| for copying to |dest| (relative to |topdir|).
-    No filesystem changes occur here.  Actual copying happens later on.
-    Paths should have basic validation run on them before being queued.
-    Further checking will be handled when the actual copy happens.
-    """
-    self.copyfiles.append(_CopyFile(self.worktree, src, topdir, dest))
-  def AddLinkFile(self, src, dest, topdir):
+        mp = self.manifest.manifestProject
-    """Mark |dest| to create a symlink (relative to |topdir|) pointing to |src|.
+        dissociate = mp.dissociate
+        if dissociate:
+            alternates_file = os.path.join(
+                self.objdir, "objects/info/alternates"
+            )
+            if os.path.exists(alternates_file):
+                cmd = ["repack", "-a", "-d"]
+                p = GitCommand(
+                    self,
+                    cmd,
+                    bare=True,
+                    capture_stdout=bool(output_redir),
+                    merge_output=bool(output_redir),
+                )
+                if p.stdout and output_redir:
+                    output_redir.write(p.stdout)
+                if p.Wait() != 0:
+                    return SyncNetworkHalfResult(False, remote_fetched)
+                platform_utils.remove(alternates_file)
+        if self.worktree:
+            self._InitMRef()
+        else:
+            self._InitMirrorHead()
+            platform_utils.remove(
+                os.path.join(self.gitdir, "FETCH_HEAD"), missing_ok=True
+            )
+        return SyncNetworkHalfResult(True, remote_fetched)
-    No filesystem changes occur here.  Actual linking happens later on.
+    def PostRepoUpgrade(self):
+        self._InitHooks()
-    Paths should have basic validation run on them before being queued.
+    def _CopyAndLinkFiles(self):
-    Further checking will be handled when the actual link happens.
+        if self.client.isGitcClient:
-    """
+            return
-    self.linkfiles.append(_LinkFile(self.worktree, src, topdir, dest))
+        for copyfile in self.copyfiles:
+            copyfile._Copy()
+        for linkfile in self.linkfiles:
+            linkfile._Link()
-  def AddAnnotation(self, name, value, keep):
+    def GetCommitRevisionId(self):
-    self.annotations.append(Annotation(name, value, keep))
+        """Get revisionId of a commit.
-  def DownloadPatchSet(self, change_id, patch_id):
+        Use this method instead of GetRevisionId to get the id of the commit
-    """Download a single patch set of a single change to FETCH_HEAD.
+        rather than the id of the current git object (for example, a tag)
-    """
-    remote = self.GetRemote()
-    cmd = ['fetch', remote.name]
-    cmd.append('refs/changes/%2.2d/%d/%d'
-               % (change_id % 100, change_id, patch_id))
-    if GitCommand(self, cmd, bare=True).Wait() != 0:
-      return None
-    return DownloadedChange(self,
-                            self.GetRevisionId(),
-                            change_id,
-                            patch_id,
-                            self.bare_git.rev_parse('FETCH_HEAD'))
-  def DeleteWorktree(self, quiet=False, force=False):
-    """Delete the source checkout and any other housekeeping tasks.
-    This currently leaves behind the internal .repo/ cache state.  This helps
-    when switching branches or manifest changes get reverted as we don't have
-    to redownload all the git objects.  But we should do some GC at some point.
-    Args:
-      quiet: Whether to hide normal messages.
-      force: Always delete tree even if dirty.
-    Returns:
+        """
-      True if the worktree was completely cleaned out.
+        if not self.revisionExpr.startswith(R_TAGS):
-    """
+            return self.GetRevisionId(self._allrefs)
-    if self.IsDirty():
-      if force:
-        print('warning: %s: Removing dirty project: uncommitted changes lost.' %
-              (self.RelPath(local=False),), file=sys.stderr)
-      else:
-        print('error: %s: Cannot remove project: uncommitted changes are '
-              'present.\n' % (self.RelPath(local=False),), file=sys.stderr)
-        return False
-    if not quiet:
-      print('%s: Deleting obsolete checkout.' % (self.RelPath(local=False),))
-    # Unlock and delink from the main worktree.  We don't use git's worktree
-    # remove because it will recursively delete projects -- we handle that
-    # ourselves below.  https://crbug.com/git/48
-    if self.use_git_worktrees:
-      needle = platform_utils.realpath(self.gitdir)
-      # Find the git worktree commondir under .repo/worktrees/.
-      output = self.bare_git.worktree('list', '--porcelain').splitlines()[0]
-      assert output.startswith('worktree '), output
-      commondir = output[9:]
-      # Walk each of the git worktrees to see where they point.
-      configs = os.path.join(commondir, 'worktrees')
-      for name in os.listdir(configs):
-        gitdir = os.path.join(configs, name, 'gitdir')
-        with open(gitdir) as fp:
-          relpath = fp.read().strip()
-        # Resolve the checkout path and see if it matches this project.
-        fullpath = platform_utils.realpath(os.path.join(configs, name, relpath))
-        if fullpath == needle:
-          platform_utils.rmtree(os.path.join(configs, name))
-    # Delete the .git directory first, so we're less likely to have a partially
-    # working git repository around. There shouldn't be any git projects here,
-    # so rmtree works.
-    # Try to remove plain files first in case of git worktrees.  If this fails
-    # for any reason, we'll fall back to rmtree, and that'll display errors if
-    # it can't remove things either.
-    try:
-      platform_utils.remove(self.gitdir)
-    except OSError:
-      pass
-    try:
-      platform_utils.rmtree(self.gitdir)
-    except OSError as e:
-      if e.errno != errno.ENOENT:
-        print('error: %s: %s' % (self.gitdir, e), file=sys.stderr)
-        print('error: %s: Failed to delete obsolete checkout; remove manually, '
-              'then run `repo sync -l`.' % (self.RelPath(local=False),),
-              file=sys.stderr)
-        return False
-    # Delete everything under the worktree, except for directories that contain
-    # another git project.
-    dirs_to_remove = []
-    failed = False
-    for root, dirs, files in platform_utils.walk(self.worktree):
-      for f in files:
-        path = os.path.join(root, f)
-        try:
-          platform_utils.remove(path)
-        except OSError as e:
-          if e.errno != errno.ENOENT:
-            print('error: %s: Failed to remove: %s' % (path, e), file=sys.stderr)
-            failed = True
-      dirs[:] = [d for d in dirs
-                 if not os.path.lexists(os.path.join(root, d, '.git'))]
-      dirs_to_remove += [os.path.join(root, d) for d in dirs
-                         if os.path.join(root, d) not in dirs_to_remove]
-    for d in reversed(dirs_to_remove):
-      if platform_utils.islink(d):
        try:
-          platform_utils.remove(d)
+            return self.bare_git.rev_list(self.revisionExpr, "-1")[0]
-        except OSError as e:
+        except GitError:
-          if e.errno != errno.ENOENT:
+            raise ManifestInvalidRevisionError(
-            print('error: %s: Failed to remove: %s' % (d, e), file=sys.stderr)
+                "revision %s in %s not found" % (self.revisionExpr, self.name)
-            failed = True
+            )
-      elif not platform_utils.listdir(d):
-        try:
-          platform_utils.rmdir(d)
-        except OSError as e:
-          if e.errno != errno.ENOENT:
-            print('error: %s: Failed to remove: %s' % (d, e), file=sys.stderr)
-            failed = True
-    if failed:
-      print('error: %s: Failed to delete obsolete checkout.' % (self.RelPath(local=False),),
-            file=sys.stderr)
-      print('       Remove manually, then run `repo sync -l`.', file=sys.stderr)
-      return False
-    # Try deleting parent dirs if they are empty.
-    path = self.worktree
-    while path != self.manifest.topdir:
-      try:
-        platform_utils.rmdir(path)
-      except OSError as e:
-        if e.errno != errno.ENOENT:
-          break
-      path = os.path.dirname(path)
-    return True
-# Branch Management ##
-  def StartBranch(self, name, branch_merge='', revision=None):
-    """Create a new branch off the manifest's revision.
-    """
-    if not branch_merge:
-      branch_merge = self.revisionExpr
-    head = self.work_git.GetHead()
-    if head == (R_HEADS + name):
-      return True
-    all_refs = self.bare_ref.all
-    if R_HEADS + name in all_refs:
-      return GitCommand(self, ['checkout', '-q', name, '--']).Wait() == 0
-    branch = self.GetBranch(name)
-    branch.remote = self.GetRemote()
-    branch.merge = branch_merge
-    if not branch.merge.startswith('refs/') and not ID_RE.match(branch_merge):
-      branch.merge = R_HEADS + branch_merge
-    if revision is None:
-      revid = self.GetRevisionId(all_refs)
-    else:
-      revid = self.work_git.rev_parse(revision)
-    if head.startswith(R_HEADS):
-      try:
-        head = all_refs[head]
-      except KeyError:
-        head = None
-    if revid and head and revid == head:
-      ref = R_HEADS + name
-      self.work_git.update_ref(ref, revid)
-      self.work_git.symbolic_ref(HEAD, ref)
-      branch.Save()
-      return True
-    if GitCommand(self, ['checkout', '-q', '-b', branch.name, revid]).Wait() == 0:
-      branch.Save()
-      return True
-    return False
-  def CheckoutBranch(self, name):
-    """Checkout a local topic branch.
-        Args:
+    def GetRevisionId(self, all_refs=None):
-          name: The name of the branch to checkout.
+        if self.revisionId:
+            return self.revisionId
-        Returns:
+        rem = self.GetRemote()
-          True if the checkout succeeded; False if it didn't; None if the branch
+        rev = rem.ToLocal(self.revisionExpr)
-          didn't exist.
-    """
-    rev = R_HEADS + name
-    head = self.work_git.GetHead()
-    if head == rev:
-      # Already on the branch
-      #
-      return True
-    all_refs = self.bare_ref.all
-    try:
-      revid = all_refs[rev]
-    except KeyError:
-      # Branch does not exist in this project
-      #
-      return None
-    if head.startswith(R_HEADS):
-      try:
-        head = all_refs[head]
-      except KeyError:
-        head = None
-    if head == revid:
-      # Same revision; just update HEAD to point to the new
-      # target branch, but otherwise take no other action.
-      #
-      _lwrite(self.work_git.GetDotgitPath(subpath=HEAD),
-              'ref: %s%s\n' % (R_HEADS, name))
-      return True
-    return GitCommand(self,
-                      ['checkout', name, '--'],
-                      capture_stdout=True,
-                      capture_stderr=True).Wait() == 0
-  def AbandonBranch(self, name):
-    """Destroy a local topic branch.
-    Args:
-      name: The name of the branch to abandon.
-    Returns:
+        if all_refs is not None and rev in all_refs:
-      True if the abandon succeeded; False if it didn't; None if the branch
+            return all_refs[rev]
-      didn't exist.
-    """
-    rev = R_HEADS + name
-    all_refs = self.bare_ref.all
-    if rev not in all_refs:
-      # Doesn't exist
-      return None
-    head = self.work_git.GetHead()
-    if head == rev:
-      # We can't destroy the branch while we are sitting
-      # on it.  Switch to a detached HEAD.
-      #
-      head = all_refs[head]
-      revid = self.GetRevisionId(all_refs)
-      if head == revid:
-        _lwrite(self.work_git.GetDotgitPath(subpath=HEAD), '%s\n' % revid)
-      else:
-        self._Checkout(revid, quiet=True)
-    return GitCommand(self,
-                      ['branch', '-D', name],
-                      capture_stdout=True,
-                      capture_stderr=True).Wait() == 0
-  def PruneHeads(self):
-    """Prune any topic branches already merged into upstream.
-    """
-    cb = self.CurrentBranch
-    kill = []
-    left = self._allrefs
-    for name in left.keys():
-      if name.startswith(R_HEADS):
-        name = name[len(R_HEADS):]
-        if cb is None or name != cb:
-          kill.append(name)
-    # Minor optimization: If there's nothing to prune, then don't try to read
-    # any project state.
-    if not kill and not cb:
-      return []
-    rev = self.GetRevisionId(left)
-    if cb is not None \
-       and not self._revlist(HEAD + '...' + rev) \
-       and not self.IsDirty(consider_untracked=False):
-      self.work_git.DetachHead(HEAD)
-      kill.append(cb)
-    if kill:
-      old = self.bare_git.GetHead()
-      try:
-        self.bare_git.DetachHead(rev)
-        b = ['branch', '-d']
-        b.extend(kill)
-        b = GitCommand(self, b, bare=True,
-                       capture_stdout=True,
-                       capture_stderr=True)
-        b.Wait()
-      finally:
-        if ID_RE.match(old):
-          self.bare_git.DetachHead(old)
-        else:
-          self.bare_git.SetHead(old)
-        left = self._allrefs
-      for branch in kill:
+        try:
-        if (R_HEADS + branch) not in left:
+            return self.bare_git.rev_parse("--verify", "%s^0" % rev)
-          self.CleanPublishedCache()
+        except GitError:
-          break
+            raise ManifestInvalidRevisionError(
+                "revision %s in %s not found" % (self.revisionExpr, self.name)
+            )
+    def SetRevisionId(self, revisionId):
+        if self.revisionExpr:
+            self.upstream = self.revisionExpr
+        self.revisionId = revisionId
+    def Sync_LocalHalf(self, syncbuf, force_sync=False, submodules=False):
+        """Perform only the local IO portion of the sync process.
+        Network access is not required.
+        """
+        if not os.path.exists(self.gitdir):
+            syncbuf.fail(
+                self,
+                "Cannot checkout %s due to missing network sync; Run "
+                "`repo sync -n %s` first." % (self.name, self.name),
+            )
+            return
+        self._InitWorkTree(force_sync=force_sync, submodules=submodules)
+        all_refs = self.bare_ref.all
+        self.CleanPublishedCache(all_refs)
+        revid = self.GetRevisionId(all_refs)
+        # Special case the root of the repo client checkout.  Make sure it
+        # doesn't contain files being checked out to dirs we don't allow.
+        if self.relpath == ".":
+            PROTECTED_PATHS = {".repo"}
+            paths = set(
+                self.work_git.ls_tree("-z", "--name-only", "--", revid).split(
+                    "\0"
+                )
+            )
+            bad_paths = paths & PROTECTED_PATHS
+            if bad_paths:
+                syncbuf.fail(
+                    self,
+                    "Refusing to checkout project that writes to protected "
+                    "paths: %s" % (", ".join(bad_paths),),
+                )
+                return
+        def _doff():
+            self._FastForward(revid)
+            self._CopyAndLinkFiles()
+        def _dosubmodules():
+            self._SyncSubmodules(quiet=True)
+        head = self.work_git.GetHead()
+        if head.startswith(R_HEADS):
+            branch = head[len(R_HEADS) :]
+            try:
+                head = all_refs[head]
+            except KeyError:
+                head = None
+        else:
+            branch = None
+        if branch is None or syncbuf.detach_head:
+            # Currently on a detached HEAD.  The user is assumed to
+            # not have any local modifications worth worrying about.
+            if self.IsRebaseInProgress():
+                syncbuf.fail(self, _PriorSyncFailedError())
+                return
+            if head == revid:
+                # No changes; don't do anything further.
+                # Except if the head needs to be detached.
+                if not syncbuf.detach_head:
+                    # The copy/linkfile config may have changed.
+                    self._CopyAndLinkFiles()
+                    return
+            else:
+                lost = self._revlist(not_rev(revid), HEAD)
+                if lost:
+                    syncbuf.info(self, "discarding %d commits", len(lost))
-    if cb and cb not in kill:
+            try:
-      kill.append(cb)
+                self._Checkout(revid, quiet=True)
-    kill.sort()
+                if submodules:
+                    self._SyncSubmodules(quiet=True)
+            except GitError as e:
+                syncbuf.fail(self, e)
+                return
+            self._CopyAndLinkFiles()
+            return
+        if head == revid:
+            # No changes; don't do anything further.
+            #
+            # The copy/linkfile config may have changed.
+            self._CopyAndLinkFiles()
+            return
-    kept = []
-    for branch in kill:
-      if R_HEADS + branch in left:
        branch = self.GetBranch(branch)
-        base = branch.LocalMerge
-        if not base:
+        if not branch.LocalMerge:
-          base = rev
+            # The current branch has no tracking configuration.
-        kept.append(ReviewableBranch(self, branch, base))
+            # Jump off it to a detached HEAD.
-    return kept
+            syncbuf.info(
+                self, "leaving %s; does not track upstream", branch.name
-# Submodule Management ##
+            )
-  def GetRegisteredSubprojects(self):
+            try:
-    result = []
+                self._Checkout(revid, quiet=True)
+                if submodules:
-    def rec(subprojects):
+                    self._SyncSubmodules(quiet=True)
-      if not subprojects:
+            except GitError as e:
-        return
+                syncbuf.fail(self, e)
-      result.extend(subprojects)
+                return
-      for p in subprojects:
+            self._CopyAndLinkFiles()
-        rec(p.subprojects)
+            return
-    rec(self.subprojects)
-    return result
+        upstream_gain = self._revlist(not_rev(HEAD), revid)
-  def _GetSubmodules(self):
+        # See if we can perform a fast forward merge.  This can happen if our
-    # Unfortunately we cannot call `git submodule status --recursive` here
+        # branch isn't in the exact same state as we last published.
-    # because the working tree might not exist yet, and it cannot be used
-    # without a working tree in its current implementation.
-    def get_submodules(gitdir, rev):
-      # Parse .gitmodules for submodule sub_paths and sub_urls
-      sub_paths, sub_urls = parse_gitmodules(gitdir, rev)
-      if not sub_paths:
-        return []
-      # Run `git ls-tree` to read SHAs of submodule object, which happen to be
-      # revision of submodule repository
-      sub_revs = git_ls_tree(gitdir, rev, sub_paths)
-      submodules = []
-      for sub_path, sub_url in zip(sub_paths, sub_urls):
        try:
-          sub_rev = sub_revs[sub_path]
+            self.work_git.merge_base("--is-ancestor", HEAD, revid)
-        except KeyError:
+            # Skip the published logic.
-          # Ignore non-exist submodules
+            pub = False
-          continue
+        except GitError:
-        submodules.append((sub_rev, sub_path, sub_url))
+            pub = self.WasPublished(branch.name, all_refs)
-      return submodules
+        if pub:
-    re_path = re.compile(r'^submodule\.(.+)\.path=(.*)$')
+            not_merged = self._revlist(not_rev(revid), pub)
-    re_url = re.compile(r'^submodule\.(.+)\.url=(.*)$')
+            if not_merged:
+                if upstream_gain:
-    def parse_gitmodules(gitdir, rev):
+                    # The user has published this branch and some of those
-      cmd = ['cat-file', 'blob', '%s:.gitmodules' % rev]
+                    # commits are not yet merged upstream.  We do not want
-      try:
+                    # to rewrite the published commits so we punt.
-        p = GitCommand(None, cmd, capture_stdout=True, capture_stderr=True,
+                    syncbuf.fail(
-                       bare=True, gitdir=gitdir)
+                        self,
-      except GitError:
+                        "branch %s is published (but not merged) and is now "
-        return [], []
+                        "%d commits behind" % (branch.name, len(upstream_gain)),
-      if p.Wait() != 0:
+                    )
-        return [], []
+                return
+            elif pub == head:
-      gitmodules_lines = []
+                # All published commits are merged, and thus we are a
-      fd, temp_gitmodules_path = tempfile.mkstemp()
+                # strict subset.  We can fast-forward safely.
-      try:
+                syncbuf.later1(self, _doff)
-        os.write(fd, p.stdout.encode('utf-8'))
+                if submodules:
-        os.close(fd)
+                    syncbuf.later1(self, _dosubmodules)
-        cmd = ['config', '--file', temp_gitmodules_path, '--list']
+                return
-        p = GitCommand(None, cmd, capture_stdout=True, capture_stderr=True,
-                       bare=True, gitdir=gitdir)
+        # Examine the local commits not in the remote.  Find the
-        if p.Wait() != 0:
+        # last one attributed to this user, if any.
-          return [], []
+        local_changes = self._revlist(not_rev(revid), HEAD, format="%H %ce")
-        gitmodules_lines = p.stdout.split('\n')
+        last_mine = None
-      except GitError:
+        cnt_mine = 0
-        return [], []
+        for commit in local_changes:
-      finally:
+            commit_id, committer_email = commit.split(" ", 1)
-        platform_utils.remove(temp_gitmodules_path)
+            if committer_email == self.UserEmail:
+                last_mine = commit_id
-      names = set()
+                cnt_mine += 1
-      paths = {}
-      urls = {}
+        if not upstream_gain and cnt_mine == len(local_changes):
-      for line in gitmodules_lines:
+            # The copy/linkfile config may have changed.
-        if not line:
+            self._CopyAndLinkFiles()
-          continue
+            return
-        m = re_path.match(line)
-        if m:
+        if self.IsDirty(consider_untracked=False):
-          names.add(m.group(1))
+            syncbuf.fail(self, _DirtyError())
-          paths[m.group(1)] = m.group(2)
+            return
-          continue
-        m = re_url.match(line)
+        # If the upstream switched on us, warn the user.
-        if m:
+        if branch.merge != self.revisionExpr:
-          names.add(m.group(1))
+            if branch.merge and self.revisionExpr:
-          urls[m.group(1)] = m.group(2)
+                syncbuf.info(
-          continue
+                    self,
-      names = sorted(names)
+                    "manifest switched %s...%s",
-      return ([paths.get(name, '') for name in names],
+                    branch.merge,
-              [urls.get(name, '') for name in names])
+                    self.revisionExpr,
+                )
-    def git_ls_tree(gitdir, rev, paths):
+            elif branch.merge:
-      cmd = ['ls-tree', rev, '--']
+                syncbuf.info(self, "manifest no longer tracks %s", branch.merge)
-      cmd.extend(paths)
-      try:
+        if cnt_mine < len(local_changes):
-        p = GitCommand(None, cmd, capture_stdout=True, capture_stderr=True,
+            # Upstream rebased. Not everything in HEAD was created by this user.
-                       bare=True, gitdir=gitdir)
+            syncbuf.info(
-      except GitError:
+                self,
-        return []
+                "discarding %d commits removed from upstream",
-      if p.Wait() != 0:
+                len(local_changes) - cnt_mine,
-        return []
+            )
-      objects = {}
-      for line in p.stdout.split('\n'):
+        branch.remote = self.GetRemote()
-        if not line.strip():
+        if not ID_RE.match(self.revisionExpr):
-          continue
+            # In case of manifest sync the revisionExpr might be a SHA1.
-        object_rev, object_path = line.split()[2:4]
+            branch.merge = self.revisionExpr
-        objects[object_path] = object_rev
+            if not branch.merge.startswith("refs/"):
-      return objects
+                branch.merge = R_HEADS + branch.merge
+        branch.Save()
+        if cnt_mine > 0 and self.rebase:
+            def _docopyandlink():
+                self._CopyAndLinkFiles()
+            def _dorebase():
+                self._Rebase(upstream="%s^1" % last_mine, onto=revid)
+            syncbuf.later2(self, _dorebase)
+            if submodules:
+                syncbuf.later2(self, _dosubmodules)
+            syncbuf.later2(self, _docopyandlink)
+        elif local_changes:
+            try:
+                self._ResetHard(revid)
+                if submodules:
+                    self._SyncSubmodules(quiet=True)
+                self._CopyAndLinkFiles()
+            except GitError as e:
+                syncbuf.fail(self, e)
+                return
+        else:
+            syncbuf.later1(self, _doff)
+            if submodules:
+                syncbuf.later1(self, _dosubmodules)
-    try:
+    def AddCopyFile(self, src, dest, topdir):
-      rev = self.GetRevisionId()
+        """Mark |src| for copying to |dest| (relative to |topdir|).
-    except GitError:
-      return []
-    return get_submodules(self.gitdir, rev)
-  def GetDerivedSubprojects(self):
-    result = []
-    if not self.Exists:
-      # If git repo does not exist yet, querying its submodules will
-      # mess up its states; so return here.
-      return result
-    for rev, path, url in self._GetSubmodules():
-      name = self.manifest.GetSubprojectName(self, path)
-      relpath, worktree, gitdir, objdir = \
-          self.manifest.GetSubprojectPaths(self, name, path)
-      project = self.manifest.paths.get(relpath)
-      if project:
-        result.extend(project.GetDerivedSubprojects())
-        continue
-      if url.startswith('..'):
-        url = urllib.parse.urljoin("%s/" % self.remote.url, url)
-      remote = RemoteSpec(self.remote.name,
-                          url=url,
-                          pushUrl=self.remote.pushUrl,
-                          review=self.remote.review,
-                          revision=self.remote.revision)
-      subproject = Project(manifest=self.manifest,
-                           name=name,
-                           remote=remote,
-                           gitdir=gitdir,
-                           objdir=objdir,
-                           worktree=worktree,
-                           relpath=relpath,
-                           revisionExpr=rev,
-                           revisionId=rev,
-                           rebase=self.rebase,
-                           groups=self.groups,
-                           sync_c=self.sync_c,
-                           sync_s=self.sync_s,
-                           sync_tags=self.sync_tags,
-                           parent=self,
-                           is_derived=True)
-      result.append(subproject)
-      result.extend(subproject.GetDerivedSubprojects())
-    return result
-# Direct Git Commands ##
-  def EnableRepositoryExtension(self, key, value='true', version=1):
-    """Enable git repository extension |key| with |value|.
-    Args:
-      key: The extension to enabled.  Omit the "extensions." prefix.
-      value: The value to use for the extension.
-      version: The minimum git repository version needed.
-    """
-    # Make sure the git repo version is new enough already.
-    found_version = self.config.GetInt('core.repositoryFormatVersion')
-    if found_version is None:
-      found_version = 0
-    if found_version < version:
-      self.config.SetString('core.repositoryFormatVersion', str(version))
-    # Enable the extension!
+        No filesystem changes occur here.  Actual copying happens later on.
-    self.config.SetString('extensions.%s' % (key,), value)
-  def ResolveRemoteHead(self, name=None):
+        Paths should have basic validation run on them before being queued.
-    """Find out what the default branch (HEAD) points to.
+        Further checking will be handled when the actual copy happens.
+        """
+        self.copyfiles.append(_CopyFile(self.worktree, src, topdir, dest))
-    Normally this points to refs/heads/master, but projects are moving to main.
+    def AddLinkFile(self, src, dest, topdir):
-    Support whatever the server uses rather than hardcoding "master" ourselves.
+        """Mark |dest| to create a symlink (relative to |topdir|) pointing to
-    """
+        |src|.
-    if name is None:
-      name = self.remote.name
-    # The output will look like (NB: tabs are separators):
+        No filesystem changes occur here.  Actual linking happens later on.
-    # ref: refs/heads/master    HEAD
-    # 5f6803b100bb3cd0f534e96e88c91373e8ed1c44  HEAD
-    output = self.bare_git.ls_remote('-q', '--symref', '--exit-code', name, 'HEAD')
-    for line in output.splitlines():
+        Paths should have basic validation run on them before being queued.
-      lhs, rhs = line.split('\t', 1)
+        Further checking will be handled when the actual link happens.
-      if rhs == 'HEAD' and lhs.startswith('ref:'):
+        """
-        return lhs[4:].strip()
+        self.linkfiles.append(_LinkFile(self.worktree, src, topdir, dest))
-    return None
+    def AddAnnotation(self, name, value, keep):
+        self.annotations.append(Annotation(name, value, keep))
-  def _CheckForImmutableRevision(self):
+    def DownloadPatchSet(self, change_id, patch_id):
-    try:
+        """Download a single patch set of a single change to FETCH_HEAD."""
-      # if revision (sha or tag) is not present then following function
+        remote = self.GetRemote()
-      # throws an error.
-      self.bare_git.rev_list('-1', '--missing=allow-any',
-                             '%s^0' % self.revisionExpr, '--')
-      if self.upstream:
-        rev = self.GetRemote().ToLocal(self.upstream)
-        self.bare_git.rev_list('-1', '--missing=allow-any',
-                               '%s^0' % rev, '--')
-        self.bare_git.merge_base('--is-ancestor', self.revisionExpr, rev)
-      return True
-    except GitError:
-      # There is no such persistent revision. We have to fetch it.
-      return False
-  def _FetchArchive(self, tarpath, cwd=None):
-    cmd = ['archive', '-v', '-o', tarpath]
-    cmd.append('--remote=%s' % self.remote.url)
-    cmd.append('--prefix=%s/' % self.RelPath(local=False))
-    cmd.append(self.revisionExpr)
-    command = GitCommand(self, cmd, cwd=cwd,
-                         capture_stdout=True,
-                         capture_stderr=True)
-    if command.Wait() != 0:
-      raise GitError('git archive %s: %s' % (self.name, command.stderr))
-  def _RemoteFetch(self, name=None,
-                   current_branch_only=False,
-                   initial=False,
-                   quiet=False,
-                   verbose=False,
-                   output_redir=None,
-                   alt_dir=None,
-                   tags=True,
-                   prune=False,
-                   depth=None,
-                   submodules=False,
-                   ssh_proxy=None,
-                   force_sync=False,
-                   clone_filter=None,
-                   retry_fetches=2,
-                   retry_sleep_initial_sec=4.0,
-                   retry_exp_factor=2.0):
-    is_sha1 = False
-    tag_name = None
-    # The depth should not be used when fetching to a mirror because
-    # it will result in a shallow repository that cannot be cloned or
-    # fetched from.
-    # The repo project should also never be synced with partial depth.
-    if self.manifest.IsMirror or self.relpath == '.repo/repo':
-      depth = None
-    if depth:
-      current_branch_only = True
-    if ID_RE.match(self.revisionExpr) is not None:
-      is_sha1 = True
-    if current_branch_only:
-      if self.revisionExpr.startswith(R_TAGS):
-        # This is a tag and its commit id should never change.
-        tag_name = self.revisionExpr[len(R_TAGS):]
-      elif self.upstream and self.upstream.startswith(R_TAGS):
-        # This is a tag and its commit id should never change.
-        tag_name = self.upstream[len(R_TAGS):]
-      if is_sha1 or tag_name is not None:
-        if self._CheckForImmutableRevision():
-          if verbose:
-            print('Skipped fetching project %s (already have persistent ref)'
-                  % self.name)
-          return True
-      if is_sha1 and not depth:
-        # When syncing a specific commit and --depth is not set:
-        # * if upstream is explicitly specified and is not a sha1, fetch only
-        #   upstream as users expect only upstream to be fetch.
-        #   Note: The commit might not be in upstream in which case the sync
-        #   will fail.
-        # * otherwise, fetch all branches to make sure we end up with the
-        #   specific commit.
-        if self.upstream:
-          current_branch_only = not ID_RE.match(self.upstream)
-        else:
-          current_branch_only = False
-    if not name:
+        cmd = ["fetch", remote.name]
-      name = self.remote.name
+        cmd.append(
+            "refs/changes/%2.2d/%d/%d" % (change_id % 100, change_id, patch_id)
+        )
+        if GitCommand(self, cmd, bare=True).Wait() != 0:
+            return None
+        return DownloadedChange(
+            self,
+            self.GetRevisionId(),
+            change_id,
+            patch_id,
+            self.bare_git.rev_parse("FETCH_HEAD"),
+        )
-    remote = self.GetRemote(name)
+    def DeleteWorktree(self, quiet=False, force=False):
-    if not remote.PreConnectFetch(ssh_proxy):
+        """Delete the source checkout and any other housekeeping tasks.
-      ssh_proxy = None
-    if initial:
+        This currently leaves behind the internal .repo/ cache state.  This
-      if alt_dir and 'objects' == os.path.basename(alt_dir):
+        helps when switching branches or manifest changes get reverted as we
-        ref_dir = os.path.dirname(alt_dir)
+        don't have to redownload all the git objects.  But we should do some GC
-        packed_refs = os.path.join(self.gitdir, 'packed-refs')
+        at some point.
-        all_refs = self.bare_ref.all
+        Args:
-        ids = set(all_refs.values())
+            quiet: Whether to hide normal messages.
-        tmp = set()
+            force: Always delete tree even if dirty.
-        for r, ref_id in GitRefs(ref_dir).all.items():
+        Returns:
-          if r not in all_refs:
+            True if the worktree was completely cleaned out.
-            if r.startswith(R_TAGS) or remote.WritesTo(r):
+        """
-              all_refs[r] = ref_id
+        if self.IsDirty():
-              ids.add(ref_id)
+            if force:
-              continue
+                print(
+                    "warning: %s: Removing dirty project: uncommitted changes "
-          if ref_id in ids:
+                    "lost." % (self.RelPath(local=False),),
-            continue
+                    file=sys.stderr,
+                )
-          r = 'refs/_alt/%s' % ref_id
+            else:
-          all_refs[r] = ref_id
+                print(
-          ids.add(ref_id)
+                    "error: %s: Cannot remove project: uncommitted changes are "
-          tmp.add(r)
+                    "present.\n" % (self.RelPath(local=False),),
+                    file=sys.stderr,
-        tmp_packed_lines = []
+                )
-        old_packed_lines = []
+                return False
-        for r in sorted(all_refs):
+        if not quiet:
-          line = '%s %s\n' % (all_refs[r], r)
+            print(
-          tmp_packed_lines.append(line)
+                "%s: Deleting obsolete checkout." % (self.RelPath(local=False),)
-          if r not in tmp:
+            )
-            old_packed_lines.append(line)
+        # Unlock and delink from the main worktree.  We don't use git's worktree
-        tmp_packed = ''.join(tmp_packed_lines)
+        # remove because it will recursively delete projects -- we handle that
-        old_packed = ''.join(old_packed_lines)
+        # ourselves below.  https://crbug.com/git/48
-        _lwrite(packed_refs, tmp_packed)
+        if self.use_git_worktrees:
-      else:
+            needle = platform_utils.realpath(self.gitdir)
-        alt_dir = None
+            # Find the git worktree commondir under .repo/worktrees/.
+            output = self.bare_git.worktree("list", "--porcelain").splitlines()[
-    cmd = ['fetch']
+                0
+            ]
-    if clone_filter:
+            assert output.startswith("worktree "), output
-      git_require((2, 19, 0), fail=True, msg='partial clones')
+            commondir = output[9:]
-      cmd.append('--filter=%s' % clone_filter)
+            # Walk each of the git worktrees to see where they point.
-      self.EnableRepositoryExtension('partialclone', self.remote.name)
+            configs = os.path.join(commondir, "worktrees")
+            for name in os.listdir(configs):
-    if depth:
+                gitdir = os.path.join(configs, name, "gitdir")
-      cmd.append('--depth=%s' % depth)
+                with open(gitdir) as fp:
-    else:
+                    relpath = fp.read().strip()
-      # If this repo has shallow objects, then we don't know which refs have
+                # Resolve the checkout path and see if it matches this project.
-      # shallow objects or not. Tell git to unshallow all fetched refs.  Don't
+                fullpath = platform_utils.realpath(
-      # do this with projects that don't have shallow objects, since it is less
+                    os.path.join(configs, name, relpath)
-      # efficient.
+                )
-      if os.path.exists(os.path.join(self.gitdir, 'shallow')):
+                if fullpath == needle:
-        cmd.append('--depth=2147483647')
+                    platform_utils.rmtree(os.path.join(configs, name))
-    if not verbose:
+        # Delete the .git directory first, so we're less likely to have a
-      cmd.append('--quiet')
+        # partially working git repository around. There shouldn't be any git
-    if not quiet and sys.stdout.isatty():
+        # projects here, so rmtree works.
-      cmd.append('--progress')
-    if not self.worktree:
+        # Try to remove plain files first in case of git worktrees.  If this
-      cmd.append('--update-head-ok')
+        # fails for any reason, we'll fall back to rmtree, and that'll display
-    cmd.append(name)
+        # errors if it can't remove things either.
-    if force_sync:
-      cmd.append('--force')
-    if prune:
-      cmd.append('--prune')
-    # Always pass something for --recurse-submodules, git with GIT_DIR behaves
-    # incorrectly when not given `--recurse-submodules=no`. (b/218891912)
-    cmd.append(f'--recurse-submodules={"on-demand" if submodules else "no"}')
-    spec = []
-    if not current_branch_only:
-      # Fetch whole repo
-      spec.append(str((u'+refs/heads/*:') + remote.ToLocal('refs/heads/*')))
-    elif tag_name is not None:
-      spec.append('tag')
-      spec.append(tag_name)
-    if self.manifest.IsMirror and not current_branch_only:
-      branch = None
-    else:
-      branch = self.revisionExpr
-    if (not self.manifest.IsMirror and is_sha1 and depth
-            and git_require((1, 8, 3))):
-      # Shallow checkout of a specific commit, fetch from that commit and not
-      # the heads only as the commit might be deeper in the history.
-      spec.append(branch)
-      if self.upstream:
-        spec.append(self.upstream)
-    else:
-      if is_sha1:
-        branch = self.upstream
-      if branch is not None and branch.strip():
-        if not branch.startswith('refs/'):
-          branch = R_HEADS + branch
-        spec.append(str((u'+%s:' % branch) + remote.ToLocal(branch)))
-    # If mirroring repo and we cannot deduce the tag or branch to fetch, fetch
-    # whole repo.
-    if self.manifest.IsMirror and not spec:
-      spec.append(str((u'+refs/heads/*:') + remote.ToLocal('refs/heads/*')))
-    # If using depth then we should not get all the tags since they may
-    # be outside of the depth.
-    if not tags or depth:
-      cmd.append('--no-tags')
-    else:
-      cmd.append('--tags')
-      spec.append(str((u'+refs/tags/*:') + remote.ToLocal('refs/tags/*')))
-    cmd.extend(spec)
-    # At least one retry minimum due to git remote prune.
-    retry_fetches = max(retry_fetches, 2)
-    retry_cur_sleep = retry_sleep_initial_sec
-    ok = prune_tried = False
-    for try_n in range(retry_fetches):
-      gitcmd = GitCommand(
-          self, cmd, bare=True, objdir=os.path.join(self.objdir, 'objects'),
-          ssh_proxy=ssh_proxy,
-          merge_output=True, capture_stdout=quiet or bool(output_redir))
-      if gitcmd.stdout and not quiet and output_redir:
-        output_redir.write(gitcmd.stdout)
-      ret = gitcmd.Wait()
-      if ret == 0:
-        ok = True
-        break
-      # Retry later due to HTTP 429 Too Many Requests.
-      elif (gitcmd.stdout and
-            'error:' in gitcmd.stdout and
-            'HTTP 429' in gitcmd.stdout):
-        # Fallthru to sleep+retry logic at the bottom.
-        pass
-      # Try to prune remote branches once in case there are conflicts.
-      # For example, if the remote had refs/heads/upstream, but deleted that and
-      # now has refs/heads/upstream/foo.
-      elif (gitcmd.stdout and
-            'error:' in gitcmd.stdout and
-            'git remote prune' in gitcmd.stdout and
-            not prune_tried):
-        prune_tried = True
-        prunecmd = GitCommand(self, ['remote', 'prune', name], bare=True,
-                              ssh_proxy=ssh_proxy)
-        ret = prunecmd.Wait()
-        if ret:
-          break
-        print('retrying fetch after pruning remote branches', file=output_redir)
-        # Continue right away so we don't sleep as we shouldn't need to.
-        continue
-      elif current_branch_only and is_sha1 and ret == 128:
-        # Exit code 128 means "couldn't find the ref you asked for"; if we're
-        # in sha1 mode, we just tried sync'ing from the upstream field; it
-        # doesn't exist, thus abort the optimization attempt and do a full sync.
-        break
-      elif ret < 0:
-        # Git died with a signal, exit immediately
-        break
-      # Figure out how long to sleep before the next attempt, if there is one.
-      if not verbose and gitcmd.stdout:
-        print('\n%s:\n%s' % (self.name, gitcmd.stdout), end='', file=output_redir)
-      if try_n < retry_fetches - 1:
-        print('%s: sleeping %s seconds before retrying' % (self.name, retry_cur_sleep),
-              file=output_redir)
-        time.sleep(retry_cur_sleep)
-        retry_cur_sleep = min(retry_exp_factor * retry_cur_sleep,
-                              MAXIMUM_RETRY_SLEEP_SEC)
-        retry_cur_sleep *= (1 - random.uniform(-RETRY_JITTER_PERCENT,
-                                               RETRY_JITTER_PERCENT))
-    if initial:
-      if alt_dir:
-        if old_packed != '':
-          _lwrite(packed_refs, old_packed)
-        else:
-          platform_utils.remove(packed_refs)
-      self.bare_git.pack_refs('--all', '--prune')
-    if is_sha1 and current_branch_only:
-      # We just synced the upstream given branch; verify we
-      # got what we wanted, else trigger a second run of all
-      # refs.
-      if not self._CheckForImmutableRevision():
-        # Sync the current branch only with depth set to None.
-        # We always pass depth=None down to avoid infinite recursion.
-        return self._RemoteFetch(
-            name=name, quiet=quiet, verbose=verbose, output_redir=output_redir,
-            current_branch_only=current_branch_only and depth,
-            initial=False, alt_dir=alt_dir,
-            depth=None, ssh_proxy=ssh_proxy, clone_filter=clone_filter)
-    return ok
-  def _ApplyCloneBundle(self, initial=False, quiet=False, verbose=False):
-    if initial and (self.manifest.manifestProject.depth or self.clone_depth):
-      return False
-    remote = self.GetRemote()
-    bundle_url = remote.url + '/clone.bundle'
-    bundle_url = GitConfig.ForUser().UrlInsteadOf(bundle_url)
-    if GetSchemeFromUrl(bundle_url) not in ('http', 'https',
-                                            'persistent-http',
-                                            'persistent-https'):
-      return False
-    bundle_dst = os.path.join(self.gitdir, 'clone.bundle')
-    bundle_tmp = os.path.join(self.gitdir, 'clone.bundle.tmp')
-    exist_dst = os.path.exists(bundle_dst)
-    exist_tmp = os.path.exists(bundle_tmp)
-    if not initial and not exist_dst and not exist_tmp:
-      return False
-    if not exist_dst:
-      exist_dst = self._FetchBundle(bundle_url, bundle_tmp, bundle_dst, quiet,
-                                    verbose)
-    if not exist_dst:
-      return False
-    cmd = ['fetch']
-    if not verbose:
-      cmd.append('--quiet')
-    if not quiet and sys.stdout.isatty():
-      cmd.append('--progress')
-    if not self.worktree:
-      cmd.append('--update-head-ok')
-    cmd.append(bundle_dst)
-    for f in remote.fetch:
-      cmd.append(str(f))
-    cmd.append('+refs/tags/*:refs/tags/*')
-    ok = GitCommand(
-        self, cmd, bare=True, objdir=os.path.join(self.objdir, 'objects')).Wait() == 0
-    platform_utils.remove(bundle_dst, missing_ok=True)
-    platform_utils.remove(bundle_tmp, missing_ok=True)
-    return ok
-  def _FetchBundle(self, srcUrl, tmpPath, dstPath, quiet, verbose):
-    platform_utils.remove(dstPath, missing_ok=True)
-    cmd = ['curl', '--fail', '--output', tmpPath, '--netrc', '--location']
-    if quiet:
-      cmd += ['--silent', '--show-error']
-    if os.path.exists(tmpPath):
-      size = os.stat(tmpPath).st_size
-      if size >= 1024:
-        cmd += ['--continue-at', '%d' % (size,)]
-      else:
-        platform_utils.remove(tmpPath)
-    with GetUrlCookieFile(srcUrl, quiet) as (cookiefile, proxy):
-      if cookiefile:
-        cmd += ['--cookie', cookiefile]
-      if proxy:
-        cmd += ['--proxy', proxy]
-      elif 'http_proxy' in os.environ and 'darwin' == sys.platform:
-        cmd += ['--proxy', os.environ['http_proxy']]
-      if srcUrl.startswith('persistent-https'):
-        srcUrl = 'http' + srcUrl[len('persistent-https'):]
-      elif srcUrl.startswith('persistent-http'):
-        srcUrl = 'http' + srcUrl[len('persistent-http'):]
-      cmd += [srcUrl]
-      proc = None
-      with Trace('Fetching bundle: %s', ' '.join(cmd)):
-        if verbose:
-          print('%s: Downloading bundle: %s' % (self.name, srcUrl))
-        stdout = None if verbose else subprocess.PIPE
-        stderr = None if verbose else subprocess.STDOUT
        try:
-          proc = subprocess.Popen(cmd, stdout=stdout, stderr=stderr)
+            platform_utils.remove(self.gitdir)
        except OSError:
-          return False
+            pass
+        try:
-      (output, _) = proc.communicate()
+            platform_utils.rmtree(self.gitdir)
-      curlret = proc.returncode
+        except OSError as e:
+            if e.errno != errno.ENOENT:
-      if curlret == 22:
+                print("error: %s: %s" % (self.gitdir, e), file=sys.stderr)
-        # From curl man page:
+                print(
-        # 22: HTTP page not retrieved. The requested url was not found or
+                    "error: %s: Failed to delete obsolete checkout; remove "
-        # returned another error with the HTTP error code being 400 or above.
+                    "manually, then run `repo sync -l`."
-        # This return code only appears if -f, --fail is used.
+                    % (self.RelPath(local=False),),
-        if verbose:
+                    file=sys.stderr,
-          print('%s: Unable to retrieve clone.bundle; ignoring.' % self.name)
+                )
-          if output:
+                return False
-            print('Curl output:\n%s' % output)
-        return False
+        # Delete everything under the worktree, except for directories that
-      elif curlret and not verbose and output:
+        # contain another git project.
-        print('%s' % output, file=sys.stderr)
+        dirs_to_remove = []
+        failed = False
+        for root, dirs, files in platform_utils.walk(self.worktree):
+            for f in files:
+                path = os.path.join(root, f)
+                try:
+                    platform_utils.remove(path)
+                except OSError as e:
+                    if e.errno != errno.ENOENT:
+                        print(
+                            "error: %s: Failed to remove: %s" % (path, e),
+                            file=sys.stderr,
+                        )
+                        failed = True
+            dirs[:] = [
+                d
+                for d in dirs
+                if not os.path.lexists(os.path.join(root, d, ".git"))
+            ]
+            dirs_to_remove += [
+                os.path.join(root, d)
+                for d in dirs
+                if os.path.join(root, d) not in dirs_to_remove
+            ]
+        for d in reversed(dirs_to_remove):
+            if platform_utils.islink(d):
+                try:
+                    platform_utils.remove(d)
+                except OSError as e:
+                    if e.errno != errno.ENOENT:
+                        print(
+                            "error: %s: Failed to remove: %s" % (d, e),
+                            file=sys.stderr,
+                        )
+                        failed = True
+            elif not platform_utils.listdir(d):
+                try:
+                    platform_utils.rmdir(d)
+                except OSError as e:
+                    if e.errno != errno.ENOENT:
+                        print(
+                            "error: %s: Failed to remove: %s" % (d, e),
+                            file=sys.stderr,
+                        )
+                        failed = True
+        if failed:
+            print(
+                "error: %s: Failed to delete obsolete checkout."
+                % (self.RelPath(local=False),),
+                file=sys.stderr,
+            )
+            print(
+                "       Remove manually, then run `repo sync -l`.",
+                file=sys.stderr,
+            )
+            return False
+        # Try deleting parent dirs if they are empty.
+        path = self.worktree
+        while path != self.manifest.topdir:
+            try:
+                platform_utils.rmdir(path)
+            except OSError as e:
+                if e.errno != errno.ENOENT:
+                    break
+            path = os.path.dirname(path)
-    if os.path.exists(tmpPath):
-      if curlret == 0 and self._IsValidBundle(tmpPath, quiet):
-        platform_utils.rename(tmpPath, dstPath)
        return True
-      else:
-        platform_utils.remove(tmpPath)
-        return False
-    else:
-      return False
-  def _IsValidBundle(self, path, quiet):
+    def StartBranch(self, name, branch_merge="", revision=None):
-    try:
+        """Create a new branch off the manifest's revision."""
-      with open(path, 'rb') as f:
+        if not branch_merge:
-        if f.read(16) == b'# v2 git bundle\n':
+            branch_merge = self.revisionExpr
-          return True
+        head = self.work_git.GetHead()
+        if head == (R_HEADS + name):
+            return True
+        all_refs = self.bare_ref.all
+        if R_HEADS + name in all_refs:
+            return GitCommand(self, ["checkout", "-q", name, "--"]).Wait() == 0
+        branch = self.GetBranch(name)
+        branch.remote = self.GetRemote()
+        branch.merge = branch_merge
+        if not branch.merge.startswith("refs/") and not ID_RE.match(
+            branch_merge
+        ):
+            branch.merge = R_HEADS + branch_merge
+        if revision is None:
+            revid = self.GetRevisionId(all_refs)
        else:
-          if not quiet:
+            revid = self.work_git.rev_parse(revision)
-            print("Invalid clone.bundle file; ignoring.", file=sys.stderr)
-          return False
+        if head.startswith(R_HEADS):
-    except OSError:
+            try:
-      return False
+                head = all_refs[head]
+            except KeyError:
-  def _Checkout(self, rev, quiet=False):
+                head = None
-    cmd = ['checkout']
+        if revid and head and revid == head:
-    if quiet:
+            ref = R_HEADS + name
-      cmd.append('-q')
+            self.work_git.update_ref(ref, revid)
-    cmd.append(rev)
+            self.work_git.symbolic_ref(HEAD, ref)
-    cmd.append('--')
+            branch.Save()
-    if GitCommand(self, cmd).Wait() != 0:
+            return True
-      if self._allrefs:
-        raise GitError('%s checkout %s ' % (self.name, rev))
+        if (
+            GitCommand(
-  def _CherryPick(self, rev, ffonly=False, record_origin=False):
+                self, ["checkout", "-q", "-b", branch.name, revid]
-    cmd = ['cherry-pick']
+            ).Wait()
-    if ffonly:
+            == 0
-      cmd.append('--ff')
+        ):
-    if record_origin:
+            branch.Save()
-      cmd.append('-x')
+            return True
-    cmd.append(rev)
+        return False
-    cmd.append('--')
-    if GitCommand(self, cmd).Wait() != 0:
-      if self._allrefs:
-        raise GitError('%s cherry-pick %s ' % (self.name, rev))
-  def _LsRemote(self, refs):
-    cmd = ['ls-remote', self.remote.name, refs]
-    p = GitCommand(self, cmd, capture_stdout=True)
-    if p.Wait() == 0:
-      return p.stdout
-    return None
-  def _Revert(self, rev):
-    cmd = ['revert']
-    cmd.append('--no-edit')
-    cmd.append(rev)
-    cmd.append('--')
-    if GitCommand(self, cmd).Wait() != 0:
-      if self._allrefs:
-        raise GitError('%s revert %s ' % (self.name, rev))
-  def _ResetHard(self, rev, quiet=True):
-    cmd = ['reset', '--hard']
-    if quiet:
-      cmd.append('-q')
-    cmd.append(rev)
-    if GitCommand(self, cmd).Wait() != 0:
-      raise GitError('%s reset --hard %s ' % (self.name, rev))
-  def _SyncSubmodules(self, quiet=True):
-    cmd = ['submodule', 'update', '--init', '--recursive']
-    if quiet:
-      cmd.append('-q')
-    if GitCommand(self, cmd).Wait() != 0:
-      raise GitError('%s submodule update --init --recursive ' % self.name)
-  def _Rebase(self, upstream, onto=None):
-    cmd = ['rebase']
-    if onto is not None:
-      cmd.extend(['--onto', onto])
-    cmd.append(upstream)
-    if GitCommand(self, cmd).Wait() != 0:
-      raise GitError('%s rebase %s ' % (self.name, upstream))
-  def _FastForward(self, head, ffonly=False):
-    cmd = ['merge', '--no-stat', head]
-    if ffonly:
-      cmd.append("--ff-only")
-    if GitCommand(self, cmd).Wait() != 0:
-      raise GitError('%s merge %s ' % (self.name, head))
-  def _InitGitDir(self, mirror_git=None, force_sync=False, quiet=False):
-    init_git_dir = not os.path.exists(self.gitdir)
-    init_obj_dir = not os.path.exists(self.objdir)
-    try:
-      # Initialize the bare repository, which contains all of the objects.
-      if init_obj_dir:
-        os.makedirs(self.objdir)
-        self.bare_objdir.init()
-        self._UpdateHooks(quiet=quiet)
+    def CheckoutBranch(self, name):
+        """Checkout a local topic branch.
-        if self.use_git_worktrees:
+        Args:
-          # Enable per-worktree config file support if possible.  This is more a
+            name: The name of the branch to checkout.
-          # nice-to-have feature for users rather than a hard requirement.
-          if git_require((2, 20, 0)):
+        Returns:
-            self.EnableRepositoryExtension('worktreeConfig')
+            True if the checkout succeeded; False if it didn't; None if the
+            branch didn't exist.
-      # If we have a separate directory to hold refs, initialize it as well.
+        """
-      if self.objdir != self.gitdir:
+        rev = R_HEADS + name
-        if init_git_dir:
+        head = self.work_git.GetHead()
-          os.makedirs(self.gitdir)
+        if head == rev:
+            # Already on the branch.
-        if init_obj_dir or init_git_dir:
+            return True
-          self._ReferenceGitDir(self.objdir, self.gitdir, copy_all=True)
+        all_refs = self.bare_ref.all
        try:
-          self._CheckDirReference(self.objdir, self.gitdir)
+            revid = all_refs[rev]
-        except GitError as e:
+        except KeyError:
-          if force_sync:
+            # Branch does not exist in this project.
-            print("Retrying clone after deleting %s" %
+            return None
-                  self.gitdir, file=sys.stderr)
+        if head.startswith(R_HEADS):
            try:
-              platform_utils.rmtree(platform_utils.realpath(self.gitdir))
+                head = all_refs[head]
-              if self.worktree and os.path.exists(platform_utils.realpath
+            except KeyError:
-                                                  (self.worktree)):
+                head = None
-                platform_utils.rmtree(platform_utils.realpath(self.worktree))
-              return self._InitGitDir(mirror_git=mirror_git, force_sync=False,
+        if head == revid:
-                                      quiet=quiet)
+            # Same revision; just update HEAD to point to the new
-            except Exception:
+            # target branch, but otherwise take no other action.
-              raise e
+            _lwrite(
-          raise e
+                self.work_git.GetDotgitPath(subpath=HEAD),
+                "ref: %s%s\n" % (R_HEADS, name),
-      if init_git_dir:
+            )
-        mp = self.manifest.manifestProject
+            return True
-        ref_dir = mp.reference or ''
+        return (
-        def _expanded_ref_dirs():
+            GitCommand(
-          """Iterate through the possible git reference directory paths."""
+                self,
-          name = self.name + '.git'
+                ["checkout", name, "--"],
-          yield mirror_git or os.path.join(ref_dir, name)
+                capture_stdout=True,
-          for prefix in '', self.remote.name:
+                capture_stderr=True,
-            yield os.path.join(ref_dir, '.repo', 'project-objects', prefix, name)
+            ).Wait()
-            yield os.path.join(ref_dir, '.repo', 'worktrees', prefix, name)
+            == 0
+        )
-        if ref_dir or mirror_git:
-          found_ref_dir = None
-          for path in _expanded_ref_dirs():
-            if os.path.exists(path):
-              found_ref_dir = path
-              break
-          ref_dir = found_ref_dir
-          if ref_dir:
-            if not os.path.isabs(ref_dir):
-              # The alternate directory is relative to the object database.
-              ref_dir = os.path.relpath(ref_dir,
-                                        os.path.join(self.objdir, 'objects'))
-            _lwrite(os.path.join(self.objdir, 'objects/info/alternates'),
-                    os.path.join(ref_dir, 'objects') + '\n')
-        m = self.manifest.manifestProject.config
-        for key in ['user.name', 'user.email']:
-          if m.Has(key, include_defaults=False):
-            self.config.SetString(key, m.GetString(key))
-        if not self.manifest.EnableGitLfs:
-          self.config.SetString('filter.lfs.smudge', 'git-lfs smudge --skip -- %f')
-          self.config.SetString('filter.lfs.process', 'git-lfs filter-process --skip')
-        self.config.SetBoolean('core.bare', True if self.manifest.IsMirror else None)
-    except Exception:
-      if init_obj_dir and os.path.exists(self.objdir):
-        platform_utils.rmtree(self.objdir)
-      if init_git_dir and os.path.exists(self.gitdir):
-        platform_utils.rmtree(self.gitdir)
-      raise
-  def _UpdateHooks(self, quiet=False):
-    if os.path.exists(self.objdir):
-      self._InitHooks(quiet=quiet)
-  def _InitHooks(self, quiet=False):
-    hooks = platform_utils.realpath(os.path.join(self.objdir, 'hooks'))
-    if not os.path.exists(hooks):
-      os.makedirs(hooks)
-    # Delete sample hooks.  They're noise.
-    for hook in glob.glob(os.path.join(hooks, '*.sample')):
-      try:
-        platform_utils.remove(hook, missing_ok=True)
-      except PermissionError:
-        pass
-    for stock_hook in _ProjectHooks():
-      name = os.path.basename(stock_hook)
-      if name in ('commit-msg',) and not self.remote.review \
-              and self is not self.manifest.manifestProject:
-        # Don't install a Gerrit Code Review hook if this
-        # project does not appear to use it for reviews.
-        #
-        # Since the manifest project is one of those, but also
-        # managed through gerrit, it's excluded
-        continue
-      dst = os.path.join(hooks, name)
-      if platform_utils.islink(dst):
-        continue
-      if os.path.exists(dst):
-        # If the files are the same, we'll leave it alone.  We create symlinks
-        # below by default but fallback to hardlinks if the OS blocks them.
-        # So if we're here, it's probably because we made a hardlink below.
-        if not filecmp.cmp(stock_hook, dst, shallow=False):
-          if not quiet:
-            _warn("%s: Not replacing locally modified %s hook",
-                  self.RelPath(local=False), name)
-        continue
-      try:
-        platform_utils.symlink(
-            os.path.relpath(stock_hook, os.path.dirname(dst)), dst)
-      except OSError as e:
-        if e.errno == errno.EPERM:
-          try:
-            os.link(stock_hook, dst)
-          except OSError:
-            raise GitError(self._get_symlink_error_message())
-        else:
-          raise
-  def _InitRemote(self):
-    if self.remote.url:
-      remote = self.GetRemote()
-      remote.url = self.remote.url
-      remote.pushUrl = self.remote.pushUrl
-      remote.review = self.remote.review
-      remote.projectname = self.name
-      if self.worktree:
-        remote.ResetFetch(mirror=False)
-      else:
-        remote.ResetFetch(mirror=True)
-      remote.Save()
-  def _InitMRef(self):
-    """Initialize the pseudo m/<manifest branch> ref."""
-    if self.manifest.branch:
-      if self.use_git_worktrees:
-        # Set up the m/ space to point to the worktree-specific ref space.
-        # We'll update the worktree-specific ref space on each checkout.
-        ref = R_M + self.manifest.branch
-        if not self.bare_ref.symref(ref):
-          self.bare_git.symbolic_ref(
-              '-m', 'redirecting to worktree scope',
-              ref, R_WORKTREE_M + self.manifest.branch)
-        # We can't update this ref with git worktrees until it exists.
-        # We'll wait until the initial checkout to set it.
-        if not os.path.exists(self.worktree):
-          return
-        base = R_WORKTREE_M
-        active_git = self.work_git
-        self._InitAnyMRef(HEAD, self.bare_git, detach=True)
-      else:
-        base = R_M
-        active_git = self.bare_git
-      self._InitAnyMRef(base + self.manifest.branch, active_git)
-  def _InitMirrorHead(self):
-    self._InitAnyMRef(HEAD, self.bare_git)
-  def _InitAnyMRef(self, ref, active_git, detach=False):
-    """Initialize |ref| in |active_git| to the value in the manifest.
-    This points |ref| to the <project> setting in the manifest.
-    Args:
-      ref: The branch to update.
-      active_git: The git repository to make updates in.
-      detach: Whether to update target of symbolic refs, or overwrite the ref
-        directly (and thus make it non-symbolic).
-    """
-    cur = self.bare_ref.symref(ref)
-    if self.revisionId:
-      if cur != '' or self.bare_ref.get(ref) != self.revisionId:
-        msg = 'manifest set to %s' % self.revisionId
-        dst = self.revisionId + '^0'
-        active_git.UpdateRef(ref, dst, message=msg, detach=True)
-    else:
-      remote = self.GetRemote()
-      dst = remote.ToLocal(self.revisionExpr)
-      if cur != dst:
-        msg = 'manifest set to %s' % self.revisionExpr
-        if detach:
-          active_git.UpdateRef(ref, dst, message=msg, detach=True)
-        else:
-          active_git.symbolic_ref('-m', msg, ref, dst)
-  def _CheckDirReference(self, srcdir, destdir):
-    # Git worktrees don't use symlinks to share at all.
-    if self.use_git_worktrees:
-      return
-    for name in self.shareable_dirs:
-      # Try to self-heal a bit in simple cases.
-      dst_path = os.path.join(destdir, name)
-      src_path = os.path.join(srcdir, name)
-      dst = platform_utils.realpath(dst_path)
-      if os.path.lexists(dst):
-        src = platform_utils.realpath(src_path)
-        # Fail if the links are pointing to the wrong place
-        if src != dst:
-          _error('%s is different in %s vs %s', name, destdir, srcdir)
-          raise GitError('--force-sync not enabled; cannot overwrite a local '
-                         'work tree. If you\'re comfortable with the '
-                         'possibility of losing the work tree\'s git metadata,'
-                         ' use `repo sync --force-sync {0}` to '
-                         'proceed.'.format(self.RelPath(local=False)))
-  def _ReferenceGitDir(self, gitdir, dotgit, copy_all):
-    """Update |dotgit| to reference |gitdir|, using symlinks where possible.
-    Args:
-      gitdir: The bare git repository. Must already be initialized.
-      dotgit: The repository you would like to initialize.
-      copy_all: If true, copy all remaining files from |gitdir| -> |dotgit|.
-          This saves you the effort of initializing |dotgit| yourself.
-    """
-    symlink_dirs = self.shareable_dirs[:]
-    to_symlink = symlink_dirs
-    to_copy = []
-    if copy_all:
-      to_copy = platform_utils.listdir(gitdir)
-    dotgit = platform_utils.realpath(dotgit)
-    for name in set(to_copy).union(to_symlink):
-      try:
-        src = platform_utils.realpath(os.path.join(gitdir, name))
-        dst = os.path.join(dotgit, name)
-        if os.path.lexists(dst):
-          continue
-        # If the source dir doesn't exist, create an empty dir.
-        if name in symlink_dirs and not os.path.lexists(src):
-          os.makedirs(src)
-        if name in to_symlink:
-          platform_utils.symlink(
-              os.path.relpath(src, os.path.dirname(dst)), dst)
-        elif copy_all and not platform_utils.islink(dst):
-          if platform_utils.isdir(src):
-            shutil.copytree(src, dst)
-          elif os.path.isfile(src):
-            shutil.copy(src, dst)
-      except OSError as e:
-        if e.errno == errno.EPERM:
-          raise DownloadError(self._get_symlink_error_message())
-        else:
-          raise
-  def _InitGitWorktree(self):
-    """Init the project using git worktrees."""
-    self.bare_git.worktree('prune')
-    self.bare_git.worktree('add', '-ff', '--checkout', '--detach', '--lock',
-                           self.worktree, self.GetRevisionId())
-    # Rewrite the internal state files to use relative paths between the
-    # checkouts & worktrees.
-    dotgit = os.path.join(self.worktree, '.git')
-    with open(dotgit, 'r') as fp:
-      # Figure out the checkout->worktree path.
-      setting = fp.read()
-      assert setting.startswith('gitdir:')
-      git_worktree_path = setting.split(':', 1)[1].strip()
-    # Some platforms (e.g. Windows) won't let us update dotgit in situ because
-    # of file permissions.  Delete it and recreate it from scratch to avoid.
-    platform_utils.remove(dotgit)
-    # Use relative path from checkout->worktree & maintain Unix line endings
-    # on all OS's to match git behavior.
-    with open(dotgit, 'w', newline='\n') as fp:
-      print('gitdir:', os.path.relpath(git_worktree_path, self.worktree),
-            file=fp)
-    # Use relative path from worktree->checkout & maintain Unix line endings
-    # on all OS's to match git behavior.
-    with open(os.path.join(git_worktree_path, 'gitdir'), 'w', newline='\n') as fp:
-      print(os.path.relpath(dotgit, git_worktree_path), file=fp)
-    self._InitMRef()
-  def _InitWorkTree(self, force_sync=False, submodules=False):
-    """Setup the worktree .git path.
-    This is the user-visible path like src/foo/.git/.
-    With non-git-worktrees, this will be a symlink to the .repo/projects/ path.
-    With git-worktrees, this will be a .git file using "gitdir: ..." syntax.
-    Older checkouts had .git/ directories.  If we see that, migrate it.
-    This also handles changes in the manifest.  Maybe this project was backed
-    by "foo/bar" on the server, but now it's "new/foo/bar".  We have to update
-    the path we point to under .repo/projects/ to match.
-    """
-    dotgit = os.path.join(self.worktree, '.git')
-    # If using an old layout style (a directory), migrate it.
-    if not platform_utils.islink(dotgit) and platform_utils.isdir(dotgit):
-      self._MigrateOldWorkTreeGitDir(dotgit)
-    init_dotgit = not os.path.exists(dotgit)
-    if self.use_git_worktrees:
-      if init_dotgit:
-        self._InitGitWorktree()
-        self._CopyAndLinkFiles()
-    else:
-      if not init_dotgit:
-        # See if the project has changed.
-        if platform_utils.realpath(self.gitdir) != platform_utils.realpath(dotgit):
-          platform_utils.remove(dotgit)
-      if init_dotgit or not os.path.exists(dotgit):
-        os.makedirs(self.worktree, exist_ok=True)
-        platform_utils.symlink(os.path.relpath(self.gitdir, self.worktree), dotgit)
-      if init_dotgit:
-        _lwrite(os.path.join(dotgit, HEAD), '%s\n' % self.GetRevisionId())
-        # Finish checking out the worktree.
-        cmd = ['read-tree', '--reset', '-u', '-v', HEAD]
-        if GitCommand(self, cmd).Wait() != 0:
-          raise GitError('Cannot initialize work tree for ' + self.name)
-        if submodules:
+    def AbandonBranch(self, name):
-          self._SyncSubmodules(quiet=True)
+        """Destroy a local topic branch.
-        self._CopyAndLinkFiles()
-  @classmethod
+        Args:
-  def _MigrateOldWorkTreeGitDir(cls, dotgit):
+            name: The name of the branch to abandon.
-    """Migrate the old worktree .git/ dir style to a symlink.
-    This logic specifically only uses state from |dotgit| to figure out where to
+        Returns:
-    move content and not |self|.  This way if the backing project also changed
+            True if the abandon succeeded; False if it didn't; None if the
-    places, we only do the .git/ dir to .git symlink migration here.  The path
+            branch didn't exist.
-    updates will happen independently.
+        """
-    """
+        rev = R_HEADS + name
-    # Figure out where in .repo/projects/ it's pointing to.
+        all_refs = self.bare_ref.all
-    if not os.path.islink(os.path.join(dotgit, 'refs')):
+        if rev not in all_refs:
-      raise GitError(f'{dotgit}: unsupported checkout state')
+            # Doesn't exist
-    gitdir = os.path.dirname(os.path.realpath(os.path.join(dotgit, 'refs')))
+            return None
-    # Remove known symlink paths that exist in .repo/projects/.
+        head = self.work_git.GetHead()
-    KNOWN_LINKS = {
+        if head == rev:
-        'config', 'description', 'hooks', 'info', 'logs', 'objects',
+            # We can't destroy the branch while we are sitting
-        'packed-refs', 'refs', 'rr-cache', 'shallow', 'svn',
+            # on it.  Switch to a detached HEAD.
-    }
+            head = all_refs[head]
-    # Paths that we know will be in both, but are safe to clobber in .repo/projects/.
-    SAFE_TO_CLOBBER = {
+            revid = self.GetRevisionId(all_refs)
-        'COMMIT_EDITMSG', 'FETCH_HEAD', 'HEAD', 'gc.log', 'gitk.cache', 'index',
+            if head == revid:
-        'ORIG_HEAD',
+                _lwrite(
-    }
+                    self.work_git.GetDotgitPath(subpath=HEAD), "%s\n" % revid
+                )
-    # First see if we'd succeed before starting the migration.
+            else:
-    unknown_paths = []
+                self._Checkout(revid, quiet=True)
-    for name in platform_utils.listdir(dotgit):
-      # Ignore all temporary/backup names.  These are common with vim & emacs.
+        return (
-      if name.endswith('~') or (name[0] == '#' and name[-1] == '#'):
+            GitCommand(
-        continue
+                self,
+                ["branch", "-D", name],
-      dotgit_path = os.path.join(dotgit, name)
+                capture_stdout=True,
-      if name in KNOWN_LINKS:
+                capture_stderr=True,
-        if not platform_utils.islink(dotgit_path):
+            ).Wait()
-          unknown_paths.append(f'{dotgit_path}: should be a symlink')
+            == 0
-      else:
+        )
-        gitdir_path = os.path.join(gitdir, name)
-        if name not in SAFE_TO_CLOBBER and os.path.exists(gitdir_path):
-          unknown_paths.append(f'{dotgit_path}: unknown file; please file a bug')
-    if unknown_paths:
-      raise GitError('Aborting migration: ' + '\n'.join(unknown_paths))
-    # Now walk the paths and sync the .git/ to .repo/projects/.
-    for name in platform_utils.listdir(dotgit):
-      dotgit_path = os.path.join(dotgit, name)
-      # Ignore all temporary/backup names.  These are common with vim & emacs.
-      if name.endswith('~') or (name[0] == '#' and name[-1] == '#'):
-        platform_utils.remove(dotgit_path)
-      elif name in KNOWN_LINKS:
-        platform_utils.remove(dotgit_path)
-      else:
-        gitdir_path = os.path.join(gitdir, name)
-        platform_utils.remove(gitdir_path, missing_ok=True)
-        platform_utils.rename(dotgit_path, gitdir_path)
-    # Now that the dir should be empty, clear it out, and symlink it over.
-    platform_utils.rmdir(dotgit)
-    platform_utils.symlink(os.path.relpath(gitdir, os.path.dirname(dotgit)), dotgit)
-  def _get_symlink_error_message(self):
-    if platform_utils.isWindows():
-      return ('Unable to create symbolic link. Please re-run the command as '
-              'Administrator, or see '
-              'https://github.com/git-for-windows/git/wiki/Symbolic-Links '
-              'for other options.')
-    return 'filesystem must support symlinks'
-  def _revlist(self, *args, **kw):
-    a = []
-    a.extend(args)
-    a.append('--')
-    return self.work_git.rev_list(*a, **kw)
-  @property
-  def _allrefs(self):
-    return self.bare_ref.all
-  def _getLogs(self, rev1, rev2, oneline=False, color=True, pretty_format=None):
-    """Get logs between two revisions of this project."""
-    comp = '..'
-    if rev1:
-      revs = [rev1]
-      if rev2:
-        revs.extend([comp, rev2])
-      cmd = ['log', ''.join(revs)]
-      out = DiffColoring(self.config)
-      if out.is_on and color:
-        cmd.append('--color')
-      if pretty_format is not None:
-        cmd.append('--pretty=format:%s' % pretty_format)
-      if oneline:
-        cmd.append('--oneline')
-      try:
-        log = GitCommand(self, cmd, capture_stdout=True, capture_stderr=True)
-        if log.Wait() == 0:
-          return log.stdout
-      except GitError:
-        # worktree may not exist if groups changed for example. In that case,
-        # try in gitdir instead.
-        if not os.path.exists(self.worktree):
-          return self.bare_git.log(*cmd[1:])
-        else:
-          raise
-    return None
-  def getAddedAndRemovedLogs(self, toProject, oneline=False, color=True,
-                             pretty_format=None):
-    """Get the list of logs from this revision to given revisionId"""
-    logs = {}
-    selfId = self.GetRevisionId(self._allrefs)
-    toId = toProject.GetRevisionId(toProject._allrefs)
-    logs['added'] = self._getLogs(selfId, toId, oneline=oneline, color=color,
-                                  pretty_format=pretty_format)
-    logs['removed'] = self._getLogs(toId, selfId, oneline=oneline, color=color,
-                                    pretty_format=pretty_format)
-    return logs
-  class _GitGetByExec(object):
-    def __init__(self, project, bare, gitdir):
-      self._project = project
-      self._bare = bare
-      self._gitdir = gitdir
-    # __getstate__ and __setstate__ are required for pickling because __getattr__ exists.
-    def __getstate__(self):
-      return (self._project, self._bare, self._gitdir)
-    def __setstate__(self, state):
-      self._project, self._bare, self._gitdir = state
-    def LsOthers(self):
-      p = GitCommand(self._project,
-                     ['ls-files',
-                      '-z',
-                      '--others',
-                      '--exclude-standard'],
-                     bare=False,
-                     gitdir=self._gitdir,
-                     capture_stdout=True,
-                     capture_stderr=True)
-      if p.Wait() == 0:
-        out = p.stdout
-        if out:
-          # Backslash is not anomalous
-          return out[:-1].split('\0')
-      return []
-    def DiffZ(self, name, *args):
-      cmd = [name]
-      cmd.append('-z')
-      cmd.append('--ignore-submodules')
-      cmd.extend(args)
-      p = GitCommand(self._project,
-                     cmd,
-                     gitdir=self._gitdir,
-                     bare=False,
-                     capture_stdout=True,
-                     capture_stderr=True)
-      p.Wait()
-      r = {}
-      out = p.stdout
-      if out:
-        out = iter(out[:-1].split('\0'))
-        while out:
-          try:
-            info = next(out)
-            path = next(out)
-          except StopIteration:
-            break
-          class _Info(object):
-            def __init__(self, path, omode, nmode, oid, nid, state):
-              self.path = path
-              self.src_path = None
-              self.old_mode = omode
-              self.new_mode = nmode
-              self.old_id = oid
-              self.new_id = nid
-              if len(state) == 1:
-                self.status = state
-                self.level = None
-              else:
-                self.status = state[:1]
-                self.level = state[1:]
-                while self.level.startswith('0'):
-                  self.level = self.level[1:]
-          info = info[1:].split(' ')
-          info = _Info(path, *info)
-          if info.status in ('R', 'C'):
-            info.src_path = info.path
-            info.path = next(out)
-          r[info.path] = info
-      return r
-    def GetDotgitPath(self, subpath=None):
-      """Return the full path to the .git dir.
-      As a convenience, append |subpath| if provided.
-      """
-      if self._bare:
-        dotgit = self._gitdir
-      else:
-        dotgit = os.path.join(self._project.worktree, '.git')
-        if os.path.isfile(dotgit):
-          # Git worktrees use a "gitdir:" syntax to point to the scratch space.
-          with open(dotgit) as fp:
-            setting = fp.read()
-          assert setting.startswith('gitdir:')
-          gitdir = setting.split(':', 1)[1].strip()
-          dotgit = os.path.normpath(os.path.join(self._project.worktree, gitdir))
-      return dotgit if subpath is None else os.path.join(dotgit, subpath)
-    def GetHead(self):
-      """Return the ref that HEAD points to."""
-      path = self.GetDotgitPath(subpath=HEAD)
-      try:
-        with open(path) as fd:
-          line = fd.readline()
-      except IOError as e:
-        raise NoManifestException(path, str(e))
-      try:
-        line = line.decode()
-      except AttributeError:
-        pass
-      if line.startswith('ref: '):
-        return line[5:-1]
-      return line[:-1]
-    def SetHead(self, ref, message=None):
-      cmdv = []
-      if message is not None:
-        cmdv.extend(['-m', message])
-      cmdv.append(HEAD)
-      cmdv.append(ref)
-      self.symbolic_ref(*cmdv)
-    def DetachHead(self, new, message=None):
-      cmdv = ['--no-deref']
-      if message is not None:
-        cmdv.extend(['-m', message])
-      cmdv.append(HEAD)
-      cmdv.append(new)
-      self.update_ref(*cmdv)
-    def UpdateRef(self, name, new, old=None,
-                  message=None,
-                  detach=False):
-      cmdv = []
-      if message is not None:
-        cmdv.extend(['-m', message])
-      if detach:
-        cmdv.append('--no-deref')
-      cmdv.append(name)
-      cmdv.append(new)
-      if old is not None:
-        cmdv.append(old)
-      self.update_ref(*cmdv)
-    def DeleteRef(self, name, old=None):
-      if not old:
-        old = self.rev_parse(name)
-      self.update_ref('-d', name, old)
-      self._project.bare_ref.deleted(name)
-    def rev_list(self, *args, **kw):
-      if 'format' in kw:
-        cmdv = ['log', '--pretty=format:%s' % kw['format']]
-      else:
-        cmdv = ['rev-list']
-      cmdv.extend(args)
-      p = GitCommand(self._project,
-                     cmdv,
-                     bare=self._bare,
-                     gitdir=self._gitdir,
-                     capture_stdout=True,
-                     capture_stderr=True)
-      if p.Wait() != 0:
-        raise GitError('%s rev-list %s: %s' %
-                       (self._project.name, str(args), p.stderr))
-      return p.stdout.splitlines()
-    def __getattr__(self, name):
-      """Allow arbitrary git commands using pythonic syntax.
-      This allows you to do things like:
-        git_obj.rev_parse('HEAD')
-      Since we don't have a 'rev_parse' method defined, the __getattr__ will
-      run.  We'll replace the '_' with a '-' and try to run a git command.
-      Any other positional arguments will be passed to the git command, and the
-      following keyword arguments are supported:
-        config: An optional dict of git config options to be passed with '-c'.
-      Args:
-        name: The name of the git command to call.  Any '_' characters will
-            be replaced with '-'.
-      Returns:
-        A callable object that will try to call git with the named command.
-      """
-      name = name.replace('_', '-')
-      def runner(*args, **kwargs):
-        cmdv = []
-        config = kwargs.pop('config', None)
-        for k in kwargs:
-          raise TypeError('%s() got an unexpected keyword argument %r'
-                          % (name, k))
-        if config is not None:
-          for k, v in config.items():
-            cmdv.append('-c')
-            cmdv.append('%s=%s' % (k, v))
-        cmdv.append(name)
-        cmdv.extend(args)
-        p = GitCommand(self._project,
-                       cmdv,
-                       bare=self._bare,
-                       gitdir=self._gitdir,
-                       capture_stdout=True,
-                       capture_stderr=True)
-        if p.Wait() != 0:
-          raise GitError('%s %s: %s' %
-                         (self._project.name, name, p.stderr))
-        r = p.stdout
-        if r.endswith('\n') and r.index('\n') == len(r) - 1:
-          return r[:-1]
-        return r
-      return runner
+    def PruneHeads(self):
+        """Prune any topic branches already merged into upstream."""
+        cb = self.CurrentBranch
+        kill = []
+        left = self._allrefs
+        for name in left.keys():
+            if name.startswith(R_HEADS):
+                name = name[len(R_HEADS) :]
+                if cb is None or name != cb:
+                    kill.append(name)
+        # Minor optimization: If there's nothing to prune, then don't try to
+        # read any project state.
+        if not kill and not cb:
+            return []
+        rev = self.GetRevisionId(left)
+        if (
+            cb is not None
+            and not self._revlist(HEAD + "..." + rev)
+            and not self.IsDirty(consider_untracked=False)
+        ):
+            self.work_git.DetachHead(HEAD)
+            kill.append(cb)
+        if kill:
+            old = self.bare_git.GetHead()
-class _PriorSyncFailedError(Exception):
+            try:
+                self.bare_git.DetachHead(rev)
+                b = ["branch", "-d"]
+                b.extend(kill)
+                b = GitCommand(
+                    self, b, bare=True, capture_stdout=True, capture_stderr=True
+                )
+                b.Wait()
+            finally:
+                if ID_RE.match(old):
+                    self.bare_git.DetachHead(old)
+                else:
+                    self.bare_git.SetHead(old)
+                left = self._allrefs
+            for branch in kill:
+                if (R_HEADS + branch) not in left:
+                    self.CleanPublishedCache()
+                    break
+        if cb and cb not in kill:
+            kill.append(cb)
+        kill.sort()
+        kept = []
+        for branch in kill:
+            if R_HEADS + branch in left:
+                branch = self.GetBranch(branch)
+                base = branch.LocalMerge
+                if not base:
+                    base = rev
+                kept.append(ReviewableBranch(self, branch, base))
+        return kept
+    def GetRegisteredSubprojects(self):
+        result = []
+        def rec(subprojects):
+            if not subprojects:
+                return
+            result.extend(subprojects)
+            for p in subprojects:
+                rec(p.subprojects)
+        rec(self.subprojects)
+        return result
+    def _GetSubmodules(self):
+        # Unfortunately we cannot call `git submodule status --recursive` here
+        # because the working tree might not exist yet, and it cannot be used
+        # without a working tree in its current implementation.
+        def get_submodules(gitdir, rev):
+            # Parse .gitmodules for submodule sub_paths and sub_urls.
+            sub_paths, sub_urls = parse_gitmodules(gitdir, rev)
+            if not sub_paths:
+                return []
+            # Run `git ls-tree` to read SHAs of submodule object, which happen
+            # to be revision of submodule repository.
+            sub_revs = git_ls_tree(gitdir, rev, sub_paths)
+            submodules = []
+            for sub_path, sub_url in zip(sub_paths, sub_urls):
+                try:
+                    sub_rev = sub_revs[sub_path]
+                except KeyError:
+                    # Ignore non-exist submodules.
+                    continue
+                submodules.append((sub_rev, sub_path, sub_url))
+            return submodules
+        re_path = re.compile(r"^submodule\.(.+)\.path=(.*)$")
+        re_url = re.compile(r"^submodule\.(.+)\.url=(.*)$")
+        def parse_gitmodules(gitdir, rev):
+            cmd = ["cat-file", "blob", "%s:.gitmodules" % rev]
+            try:
+                p = GitCommand(
+                    None,
+                    cmd,
+                    capture_stdout=True,
+                    capture_stderr=True,
+                    bare=True,
+                    gitdir=gitdir,
+                )
+            except GitError:
+                return [], []
+            if p.Wait() != 0:
+                return [], []
+            gitmodules_lines = []
+            fd, temp_gitmodules_path = tempfile.mkstemp()
+            try:
+                os.write(fd, p.stdout.encode("utf-8"))
+                os.close(fd)
+                cmd = ["config", "--file", temp_gitmodules_path, "--list"]
+                p = GitCommand(
+                    None,
+                    cmd,
+                    capture_stdout=True,
+                    capture_stderr=True,
+                    bare=True,
+                    gitdir=gitdir,
+                )
+                if p.Wait() != 0:
+                    return [], []
+                gitmodules_lines = p.stdout.split("\n")
+            except GitError:
+                return [], []
+            finally:
+                platform_utils.remove(temp_gitmodules_path)
+            names = set()
+            paths = {}
+            urls = {}
+            for line in gitmodules_lines:
+                if not line:
+                    continue
+                m = re_path.match(line)
+                if m:
+                    names.add(m.group(1))
+                    paths[m.group(1)] = m.group(2)
+                    continue
+                m = re_url.match(line)
+                if m:
+                    names.add(m.group(1))
+                    urls[m.group(1)] = m.group(2)
+                    continue
+            names = sorted(names)
+            return (
+                [paths.get(name, "") for name in names],
+                [urls.get(name, "") for name in names],
+            )
+        def git_ls_tree(gitdir, rev, paths):
+            cmd = ["ls-tree", rev, "--"]
+            cmd.extend(paths)
+            try:
+                p = GitCommand(
+                    None,
+                    cmd,
+                    capture_stdout=True,
+                    capture_stderr=True,
+                    bare=True,
+                    gitdir=gitdir,
+                )
+            except GitError:
+                return []
+            if p.Wait() != 0:
+                return []
+            objects = {}
+            for line in p.stdout.split("\n"):
+                if not line.strip():
+                    continue
+                object_rev, object_path = line.split()[2:4]
+                objects[object_path] = object_rev
+            return objects
-  def __str__(self):
+        try:
-    return 'prior sync failed; rebase still in progress'
+            rev = self.GetRevisionId()
+        except GitError:
+            return []
+        return get_submodules(self.gitdir, rev)
+    def GetDerivedSubprojects(self):
+        result = []
+        if not self.Exists:
+            # If git repo does not exist yet, querying its submodules will
+            # mess up its states; so return here.
+            return result
+        for rev, path, url in self._GetSubmodules():
+            name = self.manifest.GetSubprojectName(self, path)
+            (
+                relpath,
+                worktree,
+                gitdir,
+                objdir,
+            ) = self.manifest.GetSubprojectPaths(self, name, path)
+            project = self.manifest.paths.get(relpath)
+            if project:
+                result.extend(project.GetDerivedSubprojects())
+                continue
+            if url.startswith(".."):
+                url = urllib.parse.urljoin("%s/" % self.remote.url, url)
+            remote = RemoteSpec(
+                self.remote.name,
+                url=url,
+                pushUrl=self.remote.pushUrl,
+                review=self.remote.review,
+                revision=self.remote.revision,
+            )
+            subproject = Project(
+                manifest=self.manifest,
+                name=name,
+                remote=remote,
+                gitdir=gitdir,
+                objdir=objdir,
+                worktree=worktree,
+                relpath=relpath,
+                revisionExpr=rev,
+                revisionId=rev,
+                rebase=self.rebase,
+                groups=self.groups,
+                sync_c=self.sync_c,
+                sync_s=self.sync_s,
+                sync_tags=self.sync_tags,
+                parent=self,
+                is_derived=True,
+            )
+            result.append(subproject)
+            result.extend(subproject.GetDerivedSubprojects())
+        return result
+    def EnableRepositoryExtension(self, key, value="true", version=1):
+        """Enable git repository extension |key| with |value|.
+        Args:
+            key: The extension to enabled.  Omit the "extensions." prefix.
+            value: The value to use for the extension.
+            version: The minimum git repository version needed.
+        """
+        # Make sure the git repo version is new enough already.
+        found_version = self.config.GetInt("core.repositoryFormatVersion")
+        if found_version is None:
+            found_version = 0
+        if found_version < version:
+            self.config.SetString("core.repositoryFormatVersion", str(version))
+        # Enable the extension!
+        self.config.SetString("extensions.%s" % (key,), value)
+    def ResolveRemoteHead(self, name=None):
+        """Find out what the default branch (HEAD) points to.
+        Normally this points to refs/heads/master, but projects are moving to
+        main. Support whatever the server uses rather than hardcoding "master"
+        ourselves.
+        """
+        if name is None:
+            name = self.remote.name
+        # The output will look like (NB: tabs are separators):
+        # ref: refs/heads/master        HEAD
+        # 5f6803b100bb3cd0f534e96e88c91373e8ed1c44      HEAD
+        output = self.bare_git.ls_remote(
+            "-q", "--symref", "--exit-code", name, "HEAD"
+        )
-class _DirtyError(Exception):
+        for line in output.splitlines():
+            lhs, rhs = line.split("\t", 1)
+            if rhs == "HEAD" and lhs.startswith("ref:"):
+                return lhs[4:].strip()
-  def __str__(self):
+        return None
-    return 'contains uncommitted changes'
+    def _CheckForImmutableRevision(self):
+        try:
+            # if revision (sha or tag) is not present then following function
+            # throws an error.
+            self.bare_git.rev_list(
+                "-1", "--missing=allow-any", "%s^0" % self.revisionExpr, "--"
+            )
+            if self.upstream:
+                rev = self.GetRemote().ToLocal(self.upstream)
+                self.bare_git.rev_list(
+                    "-1", "--missing=allow-any", "%s^0" % rev, "--"
+                )
+                self.bare_git.merge_base(
+                    "--is-ancestor", self.revisionExpr, rev
+                )
+            return True
+        except GitError:
+            # There is no such persistent revision. We have to fetch it.
+            return False
-class _InfoMessage(object):
+    def _FetchArchive(self, tarpath, cwd=None):
+        cmd = ["archive", "-v", "-o", tarpath]
+        cmd.append("--remote=%s" % self.remote.url)
+        cmd.append("--prefix=%s/" % self.RelPath(local=False))
+        cmd.append(self.revisionExpr)
-  def __init__(self, project, text):
+        command = GitCommand(
-    self.project = project
+            self, cmd, cwd=cwd, capture_stdout=True, capture_stderr=True
-    self.text = text
+        )
-  def Print(self, syncbuf):
+        if command.Wait() != 0:
-    syncbuf.out.info('%s/: %s', self.project.RelPath(local=False), self.text)
+            raise GitError("git archive %s: %s" % (self.name, command.stderr))
-    syncbuf.out.nl()
+    def _RemoteFetch(
+        self,
+        name=None,
+        current_branch_only=False,
+        initial=False,
+        quiet=False,
+        verbose=False,
+        output_redir=None,
+        alt_dir=None,
+        tags=True,
+        prune=False,
+        depth=None,
+        submodules=False,
+        ssh_proxy=None,
+        force_sync=False,
+        clone_filter=None,
+        retry_fetches=2,
+        retry_sleep_initial_sec=4.0,
+        retry_exp_factor=2.0,
+    ):
+        is_sha1 = False
+        tag_name = None
+        # The depth should not be used when fetching to a mirror because
+        # it will result in a shallow repository that cannot be cloned or
+        # fetched from.
+        # The repo project should also never be synced with partial depth.
+        if self.manifest.IsMirror or self.relpath == ".repo/repo":
+            depth = None
+        if depth:
+            current_branch_only = True
+        if ID_RE.match(self.revisionExpr) is not None:
+            is_sha1 = True
+        if current_branch_only:
+            if self.revisionExpr.startswith(R_TAGS):
+                # This is a tag and its commit id should never change.
+                tag_name = self.revisionExpr[len(R_TAGS) :]
+            elif self.upstream and self.upstream.startswith(R_TAGS):
+                # This is a tag and its commit id should never change.
+                tag_name = self.upstream[len(R_TAGS) :]
+            if is_sha1 or tag_name is not None:
+                if self._CheckForImmutableRevision():
+                    if verbose:
+                        print(
+                            "Skipped fetching project %s (already have "
+                            "persistent ref)" % self.name
+                        )
+                    return True
+            if is_sha1 and not depth:
+                # When syncing a specific commit and --depth is not set:
+                # * if upstream is explicitly specified and is not a sha1, fetch
+                #   only upstream as users expect only upstream to be fetch.
+                #   Note: The commit might not be in upstream in which case the
+                #   sync will fail.
+                # * otherwise, fetch all branches to make sure we end up with
+                #   the specific commit.
+                if self.upstream:
+                    current_branch_only = not ID_RE.match(self.upstream)
+                else:
+                    current_branch_only = False
+        if not name:
+            name = self.remote.name
+        remote = self.GetRemote(name)
+        if not remote.PreConnectFetch(ssh_proxy):
+            ssh_proxy = None
+        if initial:
+            if alt_dir and "objects" == os.path.basename(alt_dir):
+                ref_dir = os.path.dirname(alt_dir)
+                packed_refs = os.path.join(self.gitdir, "packed-refs")
+                all_refs = self.bare_ref.all
+                ids = set(all_refs.values())
+                tmp = set()
+                for r, ref_id in GitRefs(ref_dir).all.items():
+                    if r not in all_refs:
+                        if r.startswith(R_TAGS) or remote.WritesTo(r):
+                            all_refs[r] = ref_id
+                            ids.add(ref_id)
+                            continue
+                    if ref_id in ids:
+                        continue
+                    r = "refs/_alt/%s" % ref_id
+                    all_refs[r] = ref_id
+                    ids.add(ref_id)
+                    tmp.add(r)
+                tmp_packed_lines = []
+                old_packed_lines = []
+                for r in sorted(all_refs):
+                    line = "%s %s\n" % (all_refs[r], r)
+                    tmp_packed_lines.append(line)
+                    if r not in tmp:
+                        old_packed_lines.append(line)
+                tmp_packed = "".join(tmp_packed_lines)
+                old_packed = "".join(old_packed_lines)
+                _lwrite(packed_refs, tmp_packed)
+            else:
+                alt_dir = None
+        cmd = ["fetch"]
+        if clone_filter:
+            git_require((2, 19, 0), fail=True, msg="partial clones")
+            cmd.append("--filter=%s" % clone_filter)
+            self.EnableRepositoryExtension("partialclone", self.remote.name)
+        if depth:
+            cmd.append("--depth=%s" % depth)
+        else:
+            # If this repo has shallow objects, then we don't know which refs
+            # have shallow objects or not. Tell git to unshallow all fetched
+            # refs.  Don't do this with projects that don't have shallow
+            # objects, since it is less efficient.
+            if os.path.exists(os.path.join(self.gitdir, "shallow")):
+                cmd.append("--depth=2147483647")
+        if not verbose:
+            cmd.append("--quiet")
+        if not quiet and sys.stdout.isatty():
+            cmd.append("--progress")
+        if not self.worktree:
+            cmd.append("--update-head-ok")
+        cmd.append(name)
+        if force_sync:
+            cmd.append("--force")
+        if prune:
+            cmd.append("--prune")
+        # Always pass something for --recurse-submodules, git with GIT_DIR
+        # behaves incorrectly when not given `--recurse-submodules=no`.
+        # (b/218891912)
+        cmd.append(
+            f'--recurse-submodules={"on-demand" if submodules else "no"}'
+        )
+        spec = []
+        if not current_branch_only:
+            # Fetch whole repo.
+            spec.append(
+                str(("+refs/heads/*:") + remote.ToLocal("refs/heads/*"))
+            )
+        elif tag_name is not None:
+            spec.append("tag")
+            spec.append(tag_name)
+        if self.manifest.IsMirror and not current_branch_only:
+            branch = None
+        else:
+            branch = self.revisionExpr
+        if (
+            not self.manifest.IsMirror
+            and is_sha1
+            and depth
+            and git_require((1, 8, 3))
+        ):
+            # Shallow checkout of a specific commit, fetch from that commit and
+            # not the heads only as the commit might be deeper in the history.
+            spec.append(branch)
+            if self.upstream:
+                spec.append(self.upstream)
+        else:
+            if is_sha1:
+                branch = self.upstream
+            if branch is not None and branch.strip():
+                if not branch.startswith("refs/"):
+                    branch = R_HEADS + branch
+                spec.append(str(("+%s:" % branch) + remote.ToLocal(branch)))
+        # If mirroring repo and we cannot deduce the tag or branch to fetch,
+        # fetch whole repo.
+        if self.manifest.IsMirror and not spec:
+            spec.append(
+                str(("+refs/heads/*:") + remote.ToLocal("refs/heads/*"))
+            )
+        # If using depth then we should not get all the tags since they may
+        # be outside of the depth.
+        if not tags or depth:
+            cmd.append("--no-tags")
+        else:
+            cmd.append("--tags")
+            spec.append(str(("+refs/tags/*:") + remote.ToLocal("refs/tags/*")))
+        cmd.extend(spec)
+        # At least one retry minimum due to git remote prune.
+        retry_fetches = max(retry_fetches, 2)
+        retry_cur_sleep = retry_sleep_initial_sec
+        ok = prune_tried = False
+        for try_n in range(retry_fetches):
+            gitcmd = GitCommand(
+                self,
+                cmd,
+                bare=True,
+                objdir=os.path.join(self.objdir, "objects"),
+                ssh_proxy=ssh_proxy,
+                merge_output=True,
+                capture_stdout=quiet or bool(output_redir),
+            )
+            if gitcmd.stdout and not quiet and output_redir:
+                output_redir.write(gitcmd.stdout)
+            ret = gitcmd.Wait()
+            if ret == 0:
+                ok = True
+                break
+            # Retry later due to HTTP 429 Too Many Requests.
+            elif (
+                gitcmd.stdout
+                and "error:" in gitcmd.stdout
+                and "HTTP 429" in gitcmd.stdout
+            ):
+                # Fallthru to sleep+retry logic at the bottom.
+                pass
+            # Try to prune remote branches once in case there are conflicts.
+            # For example, if the remote had refs/heads/upstream, but deleted
+            # that and now has refs/heads/upstream/foo.
+            elif (
+                gitcmd.stdout
+                and "error:" in gitcmd.stdout
+                and "git remote prune" in gitcmd.stdout
+                and not prune_tried
+            ):
+                prune_tried = True
+                prunecmd = GitCommand(
+                    self,
+                    ["remote", "prune", name],
+                    bare=True,
+                    ssh_proxy=ssh_proxy,
+                )
+                ret = prunecmd.Wait()
+                if ret:
+                    break
+                print(
+                    "retrying fetch after pruning remote branches",
+                    file=output_redir,
+                )
+                # Continue right away so we don't sleep as we shouldn't need to.
+                continue
+            elif current_branch_only and is_sha1 and ret == 128:
+                # Exit code 128 means "couldn't find the ref you asked for"; if
+                # we're in sha1 mode, we just tried sync'ing from the upstream
+                # field; it doesn't exist, thus abort the optimization attempt
+                # and do a full sync.
+                break
+            elif ret < 0:
+                # Git died with a signal, exit immediately.
+                break
+            # Figure out how long to sleep before the next attempt, if there is
+            # one.
+            if not verbose and gitcmd.stdout:
+                print(
+                    "\n%s:\n%s" % (self.name, gitcmd.stdout),
+                    end="",
+                    file=output_redir,
+                )
+            if try_n < retry_fetches - 1:
+                print(
+                    "%s: sleeping %s seconds before retrying"
+                    % (self.name, retry_cur_sleep),
+                    file=output_redir,
+                )
+                time.sleep(retry_cur_sleep)
+                retry_cur_sleep = min(
+                    retry_exp_factor * retry_cur_sleep, MAXIMUM_RETRY_SLEEP_SEC
+                )
+                retry_cur_sleep *= 1 - random.uniform(
+                    -RETRY_JITTER_PERCENT, RETRY_JITTER_PERCENT
+                )
+        if initial:
+            if alt_dir:
+                if old_packed != "":
+                    _lwrite(packed_refs, old_packed)
+                else:
+                    platform_utils.remove(packed_refs)
+            self.bare_git.pack_refs("--all", "--prune")
+        if is_sha1 and current_branch_only:
+            # We just synced the upstream given branch; verify we
+            # got what we wanted, else trigger a second run of all
+            # refs.
+            if not self._CheckForImmutableRevision():
+                # Sync the current branch only with depth set to None.
+                # We always pass depth=None down to avoid infinite recursion.
+                return self._RemoteFetch(
+                    name=name,
+                    quiet=quiet,
+                    verbose=verbose,
+                    output_redir=output_redir,
+                    current_branch_only=current_branch_only and depth,
+                    initial=False,
+                    alt_dir=alt_dir,
+                    depth=None,
+                    ssh_proxy=ssh_proxy,
+                    clone_filter=clone_filter,
+                )
+        return ok
+    def _ApplyCloneBundle(self, initial=False, quiet=False, verbose=False):
+        if initial and (
+            self.manifest.manifestProject.depth or self.clone_depth
+        ):
+            return False
-class _Failure(object):
+        remote = self.GetRemote()
+        bundle_url = remote.url + "/clone.bundle"
+        bundle_url = GitConfig.ForUser().UrlInsteadOf(bundle_url)
+        if GetSchemeFromUrl(bundle_url) not in (
+            "http",
+            "https",
+            "persistent-http",
+            "persistent-https",
+        ):
+            return False
-  def __init__(self, project, why):
+        bundle_dst = os.path.join(self.gitdir, "clone.bundle")
-    self.project = project
+        bundle_tmp = os.path.join(self.gitdir, "clone.bundle.tmp")
-    self.why = why
-  def Print(self, syncbuf):
+        exist_dst = os.path.exists(bundle_dst)
-    syncbuf.out.fail('error: %s/: %s',
+        exist_tmp = os.path.exists(bundle_tmp)
-                     self.project.RelPath(local=False),
-                     str(self.why))
-    syncbuf.out.nl()
+        if not initial and not exist_dst and not exist_tmp:
+            return False
-class _Later(object):
+        if not exist_dst:
+            exist_dst = self._FetchBundle(
+                bundle_url, bundle_tmp, bundle_dst, quiet, verbose
+            )
+        if not exist_dst:
+            return False
-  def __init__(self, project, action):
+        cmd = ["fetch"]
-    self.project = project
+        if not verbose:
-    self.action = action
+            cmd.append("--quiet")
+        if not quiet and sys.stdout.isatty():
+            cmd.append("--progress")
+        if not self.worktree:
+            cmd.append("--update-head-ok")
+        cmd.append(bundle_dst)
+        for f in remote.fetch:
+            cmd.append(str(f))
+        cmd.append("+refs/tags/*:refs/tags/*")
+        ok = (
+            GitCommand(
+                self,
+                cmd,
+                bare=True,
+                objdir=os.path.join(self.objdir, "objects"),
+            ).Wait()
+            == 0
+        )
+        platform_utils.remove(bundle_dst, missing_ok=True)
+        platform_utils.remove(bundle_tmp, missing_ok=True)
+        return ok
+    def _FetchBundle(self, srcUrl, tmpPath, dstPath, quiet, verbose):
+        platform_utils.remove(dstPath, missing_ok=True)
+        cmd = ["curl", "--fail", "--output", tmpPath, "--netrc", "--location"]
+        if quiet:
+            cmd += ["--silent", "--show-error"]
+        if os.path.exists(tmpPath):
+            size = os.stat(tmpPath).st_size
+            if size >= 1024:
+                cmd += ["--continue-at", "%d" % (size,)]
+            else:
+                platform_utils.remove(tmpPath)
+        with GetUrlCookieFile(srcUrl, quiet) as (cookiefile, proxy):
+            if cookiefile:
+                cmd += ["--cookie", cookiefile]
+            if proxy:
+                cmd += ["--proxy", proxy]
+            elif "http_proxy" in os.environ and "darwin" == sys.platform:
+                cmd += ["--proxy", os.environ["http_proxy"]]
+            if srcUrl.startswith("persistent-https"):
+                srcUrl = "http" + srcUrl[len("persistent-https") :]
+            elif srcUrl.startswith("persistent-http"):
+                srcUrl = "http" + srcUrl[len("persistent-http") :]
+            cmd += [srcUrl]
+            proc = None
+            with Trace("Fetching bundle: %s", " ".join(cmd)):
+                if verbose:
+                    print("%s: Downloading bundle: %s" % (self.name, srcUrl))
+                stdout = None if verbose else subprocess.PIPE
+                stderr = None if verbose else subprocess.STDOUT
+                try:
+                    proc = subprocess.Popen(cmd, stdout=stdout, stderr=stderr)
+                except OSError:
+                    return False
+            (output, _) = proc.communicate()
+            curlret = proc.returncode
+            if curlret == 22:
+                # From curl man page:
+                # 22: HTTP page not retrieved. The requested url was not found
+                # or returned another error with the HTTP error code being 400
+                # or above. This return code only appears if -f, --fail is used.
+                if verbose:
+                    print(
+                        "%s: Unable to retrieve clone.bundle; ignoring."
+                        % self.name
+                    )
+                    if output:
+                        print("Curl output:\n%s" % output)
+                return False
+            elif curlret and not verbose and output:
+                print("%s" % output, file=sys.stderr)
+        if os.path.exists(tmpPath):
+            if curlret == 0 and self._IsValidBundle(tmpPath, quiet):
+                platform_utils.rename(tmpPath, dstPath)
+                return True
+            else:
+                platform_utils.remove(tmpPath)
+                return False
+        else:
+            return False
-  def Run(self, syncbuf):
+    def _IsValidBundle(self, path, quiet):
-    out = syncbuf.out
+        try:
-    out.project('project %s/', self.project.RelPath(local=False))
+            with open(path, "rb") as f:
-    out.nl()
+                if f.read(16) == b"# v2 git bundle\n":
-    try:
+                    return True
-      self.action()
+                else:
-      out.nl()
+                    if not quiet:
-      return True
+                        print(
-    except GitError:
+                            "Invalid clone.bundle file; ignoring.",
-      out.nl()
+                            file=sys.stderr,
-      return False
+                        )
+                    return False
+        except OSError:
+            return False
+    def _Checkout(self, rev, quiet=False):
+        cmd = ["checkout"]
+        if quiet:
+            cmd.append("-q")
+        cmd.append(rev)
+        cmd.append("--")
+        if GitCommand(self, cmd).Wait() != 0:
+            if self._allrefs:
+                raise GitError("%s checkout %s " % (self.name, rev))
+    def _CherryPick(self, rev, ffonly=False, record_origin=False):
+        cmd = ["cherry-pick"]
+        if ffonly:
+            cmd.append("--ff")
+        if record_origin:
+            cmd.append("-x")
+        cmd.append(rev)
+        cmd.append("--")
+        if GitCommand(self, cmd).Wait() != 0:
+            if self._allrefs:
+                raise GitError("%s cherry-pick %s " % (self.name, rev))
+    def _LsRemote(self, refs):
+        cmd = ["ls-remote", self.remote.name, refs]
+        p = GitCommand(self, cmd, capture_stdout=True)
+        if p.Wait() == 0:
+            return p.stdout
+        return None
-class _SyncColoring(Coloring):
+    def _Revert(self, rev):
+        cmd = ["revert"]
+        cmd.append("--no-edit")
+        cmd.append(rev)
+        cmd.append("--")
+        if GitCommand(self, cmd).Wait() != 0:
+            if self._allrefs:
+                raise GitError("%s revert %s " % (self.name, rev))
+    def _ResetHard(self, rev, quiet=True):
+        cmd = ["reset", "--hard"]
+        if quiet:
+            cmd.append("-q")
+        cmd.append(rev)
+        if GitCommand(self, cmd).Wait() != 0:
+            raise GitError("%s reset --hard %s " % (self.name, rev))
-  def __init__(self, config):
+    def _SyncSubmodules(self, quiet=True):
-    super().__init__(config, 'reposync')
+        cmd = ["submodule", "update", "--init", "--recursive"]
-    self.project = self.printer('header', attr='bold')
+        if quiet:
-    self.info = self.printer('info')
+            cmd.append("-q")
-    self.fail = self.printer('fail', fg='red')
+        if GitCommand(self, cmd).Wait() != 0:
+            raise GitError(
+                "%s submodule update --init --recursive " % self.name
+            )
+    def _Rebase(self, upstream, onto=None):
+        cmd = ["rebase"]
+        if onto is not None:
+            cmd.extend(["--onto", onto])
+        cmd.append(upstream)
+        if GitCommand(self, cmd).Wait() != 0:
+            raise GitError("%s rebase %s " % (self.name, upstream))
+    def _FastForward(self, head, ffonly=False):
+        cmd = ["merge", "--no-stat", head]
+        if ffonly:
+            cmd.append("--ff-only")
+        if GitCommand(self, cmd).Wait() != 0:
+            raise GitError("%s merge %s " % (self.name, head))
-class SyncBuffer(object):
+    def _InitGitDir(self, mirror_git=None, force_sync=False, quiet=False):
+        init_git_dir = not os.path.exists(self.gitdir)
+        init_obj_dir = not os.path.exists(self.objdir)
+        try:
+            # Initialize the bare repository, which contains all of the objects.
+            if init_obj_dir:
+                os.makedirs(self.objdir)
+                self.bare_objdir.init()
+                self._UpdateHooks(quiet=quiet)
+                if self.use_git_worktrees:
+                    # Enable per-worktree config file support if possible.  This
+                    # is more a nice-to-have feature for users rather than a
+                    # hard requirement.
+                    if git_require((2, 20, 0)):
+                        self.EnableRepositoryExtension("worktreeConfig")
+            # If we have a separate directory to hold refs, initialize it as
+            # well.
+            if self.objdir != self.gitdir:
+                if init_git_dir:
+                    os.makedirs(self.gitdir)
+                if init_obj_dir or init_git_dir:
+                    self._ReferenceGitDir(
+                        self.objdir, self.gitdir, copy_all=True
+                    )
+                try:
+                    self._CheckDirReference(self.objdir, self.gitdir)
+                except GitError as e:
+                    if force_sync:
+                        print(
+                            "Retrying clone after deleting %s" % self.gitdir,
+                            file=sys.stderr,
+                        )
+                        try:
+                            platform_utils.rmtree(
+                                platform_utils.realpath(self.gitdir)
+                            )
+                            if self.worktree and os.path.exists(
+                                platform_utils.realpath(self.worktree)
+                            ):
+                                platform_utils.rmtree(
+                                    platform_utils.realpath(self.worktree)
+                                )
+                            return self._InitGitDir(
+                                mirror_git=mirror_git,
+                                force_sync=False,
+                                quiet=quiet,
+                            )
+                        except Exception:
+                            raise e
+                    raise e
+            if init_git_dir:
+                mp = self.manifest.manifestProject
+                ref_dir = mp.reference or ""
+                def _expanded_ref_dirs():
+                    """Iterate through possible git reference dir paths."""
+                    name = self.name + ".git"
+                    yield mirror_git or os.path.join(ref_dir, name)
+                    for prefix in "", self.remote.name:
+                        yield os.path.join(
+                            ref_dir, ".repo", "project-objects", prefix, name
+                        )
+                        yield os.path.join(
+                            ref_dir, ".repo", "worktrees", prefix, name
+                        )
+                if ref_dir or mirror_git:
+                    found_ref_dir = None
+                    for path in _expanded_ref_dirs():
+                        if os.path.exists(path):
+                            found_ref_dir = path
+                            break
+                    ref_dir = found_ref_dir
+                    if ref_dir:
+                        if not os.path.isabs(ref_dir):
+                            # The alternate directory is relative to the object
+                            # database.
+                            ref_dir = os.path.relpath(
+                                ref_dir, os.path.join(self.objdir, "objects")
+                            )
+                        _lwrite(
+                            os.path.join(
+                                self.objdir, "objects/info/alternates"
+                            ),
+                            os.path.join(ref_dir, "objects") + "\n",
+                        )
+                m = self.manifest.manifestProject.config
+                for key in ["user.name", "user.email"]:
+                    if m.Has(key, include_defaults=False):
+                        self.config.SetString(key, m.GetString(key))
+                if not self.manifest.EnableGitLfs:
+                    self.config.SetString(
+                        "filter.lfs.smudge", "git-lfs smudge --skip -- %f"
+                    )
+                    self.config.SetString(
+                        "filter.lfs.process", "git-lfs filter-process --skip"
+                    )
+                self.config.SetBoolean(
+                    "core.bare", True if self.manifest.IsMirror else None
+                )
+        except Exception:
+            if init_obj_dir and os.path.exists(self.objdir):
+                platform_utils.rmtree(self.objdir)
+            if init_git_dir and os.path.exists(self.gitdir):
+                platform_utils.rmtree(self.gitdir)
+            raise
+    def _UpdateHooks(self, quiet=False):
+        if os.path.exists(self.objdir):
+            self._InitHooks(quiet=quiet)
+    def _InitHooks(self, quiet=False):
+        hooks = platform_utils.realpath(os.path.join(self.objdir, "hooks"))
+        if not os.path.exists(hooks):
+            os.makedirs(hooks)
+        # Delete sample hooks.  They're noise.
+        for hook in glob.glob(os.path.join(hooks, "*.sample")):
+            try:
+                platform_utils.remove(hook, missing_ok=True)
+            except PermissionError:
+                pass
+        for stock_hook in _ProjectHooks():
+            name = os.path.basename(stock_hook)
+            if (
+                name in ("commit-msg",)
+                and not self.remote.review
+                and self is not self.manifest.manifestProject
+            ):
+                # Don't install a Gerrit Code Review hook if this
+                # project does not appear to use it for reviews.
+                #
+                # Since the manifest project is one of those, but also
+                # managed through gerrit, it's excluded.
+                continue
+            dst = os.path.join(hooks, name)
+            if platform_utils.islink(dst):
+                continue
+            if os.path.exists(dst):
+                # If the files are the same, we'll leave it alone.  We create
+                # symlinks below by default but fallback to hardlinks if the OS
+                # blocks them. So if we're here, it's probably because we made a
+                # hardlink below.
+                if not filecmp.cmp(stock_hook, dst, shallow=False):
+                    if not quiet:
+                        _warn(
+                            "%s: Not replacing locally modified %s hook",
+                            self.RelPath(local=False),
+                            name,
+                        )
+                continue
+            try:
+                platform_utils.symlink(
+                    os.path.relpath(stock_hook, os.path.dirname(dst)), dst
+                )
+            except OSError as e:
+                if e.errno == errno.EPERM:
+                    try:
+                        os.link(stock_hook, dst)
+                    except OSError:
+                        raise GitError(self._get_symlink_error_message())
+                else:
+                    raise
+    def _InitRemote(self):
+        if self.remote.url:
+            remote = self.GetRemote()
+            remote.url = self.remote.url
+            remote.pushUrl = self.remote.pushUrl
+            remote.review = self.remote.review
+            remote.projectname = self.name
+            if self.worktree:
+                remote.ResetFetch(mirror=False)
+            else:
+                remote.ResetFetch(mirror=True)
+            remote.Save()
+    def _InitMRef(self):
+        """Initialize the pseudo m/<manifest branch> ref."""
+        if self.manifest.branch:
+            if self.use_git_worktrees:
+                # Set up the m/ space to point to the worktree-specific ref
+                # space. We'll update the worktree-specific ref space on each
+                # checkout.
+                ref = R_M + self.manifest.branch
+                if not self.bare_ref.symref(ref):
+                    self.bare_git.symbolic_ref(
+                        "-m",
+                        "redirecting to worktree scope",
+                        ref,
+                        R_WORKTREE_M + self.manifest.branch,
+                    )
+                # We can't update this ref with git worktrees until it exists.
+                # We'll wait until the initial checkout to set it.
+                if not os.path.exists(self.worktree):
+                    return
+                base = R_WORKTREE_M
+                active_git = self.work_git
+                self._InitAnyMRef(HEAD, self.bare_git, detach=True)
+            else:
+                base = R_M
+                active_git = self.bare_git
+            self._InitAnyMRef(base + self.manifest.branch, active_git)
+    def _InitMirrorHead(self):
+        self._InitAnyMRef(HEAD, self.bare_git)
+    def _InitAnyMRef(self, ref, active_git, detach=False):
+        """Initialize |ref| in |active_git| to the value in the manifest.
+        This points |ref| to the <project> setting in the manifest.
+        Args:
+            ref: The branch to update.
+            active_git: The git repository to make updates in.
+            detach: Whether to update target of symbolic refs, or overwrite the
+                ref directly (and thus make it non-symbolic).
+        """
+        cur = self.bare_ref.symref(ref)
+        if self.revisionId:
+            if cur != "" or self.bare_ref.get(ref) != self.revisionId:
+                msg = "manifest set to %s" % self.revisionId
+                dst = self.revisionId + "^0"
+                active_git.UpdateRef(ref, dst, message=msg, detach=True)
+        else:
+            remote = self.GetRemote()
+            dst = remote.ToLocal(self.revisionExpr)
+            if cur != dst:
+                msg = "manifest set to %s" % self.revisionExpr
+                if detach:
+                    active_git.UpdateRef(ref, dst, message=msg, detach=True)
+                else:
+                    active_git.symbolic_ref("-m", msg, ref, dst)
+    def _CheckDirReference(self, srcdir, destdir):
+        # Git worktrees don't use symlinks to share at all.
+        if self.use_git_worktrees:
+            return
+        for name in self.shareable_dirs:
+            # Try to self-heal a bit in simple cases.
+            dst_path = os.path.join(destdir, name)
+            src_path = os.path.join(srcdir, name)
+            dst = platform_utils.realpath(dst_path)
+            if os.path.lexists(dst):
+                src = platform_utils.realpath(src_path)
+                # Fail if the links are pointing to the wrong place.
+                if src != dst:
+                    _error("%s is different in %s vs %s", name, destdir, srcdir)
+                    raise GitError(
+                        "--force-sync not enabled; cannot overwrite a local "
+                        "work tree. If you're comfortable with the "
+                        "possibility of losing the work tree's git metadata,"
+                        " use `repo sync --force-sync {0}` to "
+                        "proceed.".format(self.RelPath(local=False))
+                    )
+    def _ReferenceGitDir(self, gitdir, dotgit, copy_all):
+        """Update |dotgit| to reference |gitdir|, using symlinks where possible.
+        Args:
+            gitdir: The bare git repository. Must already be initialized.
+            dotgit: The repository you would like to initialize.
+            copy_all: If true, copy all remaining files from |gitdir| ->
+                |dotgit|. This saves you the effort of initializing |dotgit|
+                yourself.
+        """
+        symlink_dirs = self.shareable_dirs[:]
+        to_symlink = symlink_dirs
+        to_copy = []
+        if copy_all:
+            to_copy = platform_utils.listdir(gitdir)
+        dotgit = platform_utils.realpath(dotgit)
+        for name in set(to_copy).union(to_symlink):
+            try:
+                src = platform_utils.realpath(os.path.join(gitdir, name))
+                dst = os.path.join(dotgit, name)
+                if os.path.lexists(dst):
+                    continue
+                # If the source dir doesn't exist, create an empty dir.
+                if name in symlink_dirs and not os.path.lexists(src):
+                    os.makedirs(src)
+                if name in to_symlink:
+                    platform_utils.symlink(
+                        os.path.relpath(src, os.path.dirname(dst)), dst
+                    )
+                elif copy_all and not platform_utils.islink(dst):
+                    if platform_utils.isdir(src):
+                        shutil.copytree(src, dst)
+                    elif os.path.isfile(src):
+                        shutil.copy(src, dst)
+            except OSError as e:
+                if e.errno == errno.EPERM:
+                    raise DownloadError(self._get_symlink_error_message())
+                else:
+                    raise
+    def _InitGitWorktree(self):
+        """Init the project using git worktrees."""
+        self.bare_git.worktree("prune")
+        self.bare_git.worktree(
+            "add",
+            "-ff",
+            "--checkout",
+            "--detach",
+            "--lock",
+            self.worktree,
+            self.GetRevisionId(),
+        )
-  def __init__(self, config, detach_head=False):
+        # Rewrite the internal state files to use relative paths between the
-    self._messages = []
+        # checkouts & worktrees.
-    self._failures = []
+        dotgit = os.path.join(self.worktree, ".git")
-    self._later_queue1 = []
+        with open(dotgit, "r") as fp:
-    self._later_queue2 = []
+            # Figure out the checkout->worktree path.
+            setting = fp.read()
+            assert setting.startswith("gitdir:")
+            git_worktree_path = setting.split(":", 1)[1].strip()
+        # Some platforms (e.g. Windows) won't let us update dotgit in situ
+        # because of file permissions.  Delete it and recreate it from scratch
+        # to avoid.
+        platform_utils.remove(dotgit)
+        # Use relative path from checkout->worktree & maintain Unix line endings
+        # on all OS's to match git behavior.
+        with open(dotgit, "w", newline="\n") as fp:
+            print(
+                "gitdir:",
+                os.path.relpath(git_worktree_path, self.worktree),
+                file=fp,
+            )
+        # Use relative path from worktree->checkout & maintain Unix line endings
+        # on all OS's to match git behavior.
+        with open(
+            os.path.join(git_worktree_path, "gitdir"), "w", newline="\n"
+        ) as fp:
+            print(os.path.relpath(dotgit, git_worktree_path), file=fp)
+        self._InitMRef()
+    def _InitWorkTree(self, force_sync=False, submodules=False):
+        """Setup the worktree .git path.
+        This is the user-visible path like src/foo/.git/.
+        With non-git-worktrees, this will be a symlink to the .repo/projects/
+        path. With git-worktrees, this will be a .git file using "gitdir: ..."
+        syntax.
+        Older checkouts had .git/ directories.  If we see that, migrate it.
+        This also handles changes in the manifest.  Maybe this project was
+        backed by "foo/bar" on the server, but now it's "new/foo/bar".  We have
+        to update the path we point to under .repo/projects/ to match.
+        """
+        dotgit = os.path.join(self.worktree, ".git")
+        # If using an old layout style (a directory), migrate it.
+        if not platform_utils.islink(dotgit) and platform_utils.isdir(dotgit):
+            self._MigrateOldWorkTreeGitDir(dotgit)
+        init_dotgit = not os.path.exists(dotgit)
+        if self.use_git_worktrees:
+            if init_dotgit:
+                self._InitGitWorktree()
+                self._CopyAndLinkFiles()
+        else:
+            if not init_dotgit:
+                # See if the project has changed.
+                if platform_utils.realpath(
+                    self.gitdir
+                ) != platform_utils.realpath(dotgit):
+                    platform_utils.remove(dotgit)
+            if init_dotgit or not os.path.exists(dotgit):
+                os.makedirs(self.worktree, exist_ok=True)
+                platform_utils.symlink(
+                    os.path.relpath(self.gitdir, self.worktree), dotgit
+                )
+            if init_dotgit:
+                _lwrite(
+                    os.path.join(dotgit, HEAD), "%s\n" % self.GetRevisionId()
+                )
+                # Finish checking out the worktree.
+                cmd = ["read-tree", "--reset", "-u", "-v", HEAD]
+                if GitCommand(self, cmd).Wait() != 0:
+                    raise GitError(
+                        "Cannot initialize work tree for " + self.name
+                    )
+                if submodules:
+                    self._SyncSubmodules(quiet=True)
+                self._CopyAndLinkFiles()
+    @classmethod
+    def _MigrateOldWorkTreeGitDir(cls, dotgit):
+        """Migrate the old worktree .git/ dir style to a symlink.
+        This logic specifically only uses state from |dotgit| to figure out
+        where to move content and not |self|.  This way if the backing project
+        also changed places, we only do the .git/ dir to .git symlink migration
+        here.  The path updates will happen independently.
+        """
+        # Figure out where in .repo/projects/ it's pointing to.
+        if not os.path.islink(os.path.join(dotgit, "refs")):
+            raise GitError(f"{dotgit}: unsupported checkout state")
+        gitdir = os.path.dirname(os.path.realpath(os.path.join(dotgit, "refs")))
+        # Remove known symlink paths that exist in .repo/projects/.
+        KNOWN_LINKS = {
+            "config",
+            "description",
+            "hooks",
+            "info",
+            "logs",
+            "objects",
+            "packed-refs",
+            "refs",
+            "rr-cache",
+            "shallow",
+            "svn",
+        }
+        # Paths that we know will be in both, but are safe to clobber in
+        # .repo/projects/.
+        SAFE_TO_CLOBBER = {
+            "COMMIT_EDITMSG",
+            "FETCH_HEAD",
+            "HEAD",
+            "gc.log",
+            "gitk.cache",
+            "index",
+            "ORIG_HEAD",
+        }
+        # First see if we'd succeed before starting the migration.
+        unknown_paths = []
+        for name in platform_utils.listdir(dotgit):
+            # Ignore all temporary/backup names.  These are common with vim &
+            # emacs.
+            if name.endswith("~") or (name[0] == "#" and name[-1] == "#"):
+                continue
+            dotgit_path = os.path.join(dotgit, name)
+            if name in KNOWN_LINKS:
+                if not platform_utils.islink(dotgit_path):
+                    unknown_paths.append(f"{dotgit_path}: should be a symlink")
+            else:
+                gitdir_path = os.path.join(gitdir, name)
+                if name not in SAFE_TO_CLOBBER and os.path.exists(gitdir_path):
+                    unknown_paths.append(
+                        f"{dotgit_path}: unknown file; please file a bug"
+                    )
+        if unknown_paths:
+            raise GitError("Aborting migration: " + "\n".join(unknown_paths))
+        # Now walk the paths and sync the .git/ to .repo/projects/.
+        for name in platform_utils.listdir(dotgit):
+            dotgit_path = os.path.join(dotgit, name)
+            # Ignore all temporary/backup names.  These are common with vim &
+            # emacs.
+            if name.endswith("~") or (name[0] == "#" and name[-1] == "#"):
+                platform_utils.remove(dotgit_path)
+            elif name in KNOWN_LINKS:
+                platform_utils.remove(dotgit_path)
+            else:
+                gitdir_path = os.path.join(gitdir, name)
+                platform_utils.remove(gitdir_path, missing_ok=True)
+                platform_utils.rename(dotgit_path, gitdir_path)
+        # Now that the dir should be empty, clear it out, and symlink it over.
+        platform_utils.rmdir(dotgit)
+        platform_utils.symlink(
+            os.path.relpath(gitdir, os.path.dirname(dotgit)), dotgit
+        )
-    self.out = _SyncColoring(config)
+    def _get_symlink_error_message(self):
-    self.out.redirect(sys.stderr)
+        if platform_utils.isWindows():
+            return (
+                "Unable to create symbolic link. Please re-run the command as "
+                "Administrator, or see "
+                "https://github.com/git-for-windows/git/wiki/Symbolic-Links "
+                "for other options."
+            )
+        return "filesystem must support symlinks"
+    def _revlist(self, *args, **kw):
+        a = []
+        a.extend(args)
+        a.append("--")
+        return self.work_git.rev_list(*a, **kw)
+    @property
+    def _allrefs(self):
+        return self.bare_ref.all
+    def _getLogs(
+        self, rev1, rev2, oneline=False, color=True, pretty_format=None
+    ):
+        """Get logs between two revisions of this project."""
+        comp = ".."
+        if rev1:
+            revs = [rev1]
+            if rev2:
+                revs.extend([comp, rev2])
+            cmd = ["log", "".join(revs)]
+            out = DiffColoring(self.config)
+            if out.is_on and color:
+                cmd.append("--color")
+            if pretty_format is not None:
+                cmd.append("--pretty=format:%s" % pretty_format)
+            if oneline:
+                cmd.append("--oneline")
-    self.detach_head = detach_head
+            try:
-    self.clean = True
+                log = GitCommand(
-    self.recent_clean = True
+                    self, cmd, capture_stdout=True, capture_stderr=True
+                )
+                if log.Wait() == 0:
+                    return log.stdout
+            except GitError:
+                # worktree may not exist if groups changed for example. In that
+                # case, try in gitdir instead.
+                if not os.path.exists(self.worktree):
+                    return self.bare_git.log(*cmd[1:])
+                else:
+                    raise
+        return None
-  def info(self, project, fmt, *args):
+    def getAddedAndRemovedLogs(
-    self._messages.append(_InfoMessage(project, fmt % args))
+        self, toProject, oneline=False, color=True, pretty_format=None
+    ):
+        """Get the list of logs from this revision to given revisionId"""
+        logs = {}
+        selfId = self.GetRevisionId(self._allrefs)
+        toId = toProject.GetRevisionId(toProject._allrefs)
+        logs["added"] = self._getLogs(
+            selfId,
+            toId,
+            oneline=oneline,
+            color=color,
+            pretty_format=pretty_format,
+        )
+        logs["removed"] = self._getLogs(
+            toId,
+            selfId,
+            oneline=oneline,
+            color=color,
+            pretty_format=pretty_format,
+        )
+        return logs
+    class _GitGetByExec(object):
+        def __init__(self, project, bare, gitdir):
+            self._project = project
+            self._bare = bare
+            self._gitdir = gitdir
+        # __getstate__ and __setstate__ are required for pickling because
+        # __getattr__ exists.
+        def __getstate__(self):
+            return (self._project, self._bare, self._gitdir)
+        def __setstate__(self, state):
+            self._project, self._bare, self._gitdir = state
+        def LsOthers(self):
+            p = GitCommand(
+                self._project,
+                ["ls-files", "-z", "--others", "--exclude-standard"],
+                bare=False,
+                gitdir=self._gitdir,
+                capture_stdout=True,
+                capture_stderr=True,
+            )
+            if p.Wait() == 0:
+                out = p.stdout
+                if out:
+                    # Backslash is not anomalous.
+                    return out[:-1].split("\0")
+            return []
+        def DiffZ(self, name, *args):
+            cmd = [name]
+            cmd.append("-z")
+            cmd.append("--ignore-submodules")
+            cmd.extend(args)
+            p = GitCommand(
+                self._project,
+                cmd,
+                gitdir=self._gitdir,
+                bare=False,
+                capture_stdout=True,
+                capture_stderr=True,
+            )
+            p.Wait()
+            r = {}
+            out = p.stdout
+            if out:
+                out = iter(out[:-1].split("\0"))
+                while out:
+                    try:
+                        info = next(out)
+                        path = next(out)
+                    except StopIteration:
+                        break
+                    class _Info(object):
+                        def __init__(self, path, omode, nmode, oid, nid, state):
+                            self.path = path
+                            self.src_path = None
+                            self.old_mode = omode
+                            self.new_mode = nmode
+                            self.old_id = oid
+                            self.new_id = nid
+                            if len(state) == 1:
+                                self.status = state
+                                self.level = None
+                            else:
+                                self.status = state[:1]
+                                self.level = state[1:]
+                                while self.level.startswith("0"):
+                                    self.level = self.level[1:]
+                    info = info[1:].split(" ")
+                    info = _Info(path, *info)
+                    if info.status in ("R", "C"):
+                        info.src_path = info.path
+                        info.path = next(out)
+                    r[info.path] = info
+            return r
+        def GetDotgitPath(self, subpath=None):
+            """Return the full path to the .git dir.
+            As a convenience, append |subpath| if provided.
+            """
+            if self._bare:
+                dotgit = self._gitdir
+            else:
+                dotgit = os.path.join(self._project.worktree, ".git")
+                if os.path.isfile(dotgit):
+                    # Git worktrees use a "gitdir:" syntax to point to the
+                    # scratch space.
+                    with open(dotgit) as fp:
+                        setting = fp.read()
+                    assert setting.startswith("gitdir:")
+                    gitdir = setting.split(":", 1)[1].strip()
+                    dotgit = os.path.normpath(
+                        os.path.join(self._project.worktree, gitdir)
+                    )
+            return dotgit if subpath is None else os.path.join(dotgit, subpath)
+        def GetHead(self):
+            """Return the ref that HEAD points to."""
+            path = self.GetDotgitPath(subpath=HEAD)
+            try:
+                with open(path) as fd:
+                    line = fd.readline()
+            except IOError as e:
+                raise NoManifestException(path, str(e))
+            try:
+                line = line.decode()
+            except AttributeError:
+                pass
+            if line.startswith("ref: "):
+                return line[5:-1]
+            return line[:-1]
+        def SetHead(self, ref, message=None):
+            cmdv = []
+            if message is not None:
+                cmdv.extend(["-m", message])
+            cmdv.append(HEAD)
+            cmdv.append(ref)
+            self.symbolic_ref(*cmdv)
+        def DetachHead(self, new, message=None):
+            cmdv = ["--no-deref"]
+            if message is not None:
+                cmdv.extend(["-m", message])
+            cmdv.append(HEAD)
+            cmdv.append(new)
+            self.update_ref(*cmdv)
+        def UpdateRef(self, name, new, old=None, message=None, detach=False):
+            cmdv = []
+            if message is not None:
+                cmdv.extend(["-m", message])
+            if detach:
+                cmdv.append("--no-deref")
+            cmdv.append(name)
+            cmdv.append(new)
+            if old is not None:
+                cmdv.append(old)
+            self.update_ref(*cmdv)
+        def DeleteRef(self, name, old=None):
+            if not old:
+                old = self.rev_parse(name)
+            self.update_ref("-d", name, old)
+            self._project.bare_ref.deleted(name)
+        def rev_list(self, *args, **kw):
+            if "format" in kw:
+                cmdv = ["log", "--pretty=format:%s" % kw["format"]]
+            else:
+                cmdv = ["rev-list"]
+            cmdv.extend(args)
+            p = GitCommand(
+                self._project,
+                cmdv,
+                bare=self._bare,
+                gitdir=self._gitdir,
+                capture_stdout=True,
+                capture_stderr=True,
+            )
+            if p.Wait() != 0:
+                raise GitError(
+                    "%s rev-list %s: %s"
+                    % (self._project.name, str(args), p.stderr)
+                )
+            return p.stdout.splitlines()
+        def __getattr__(self, name):
+            """Allow arbitrary git commands using pythonic syntax.
+            This allows you to do things like:
+                git_obj.rev_parse('HEAD')
+            Since we don't have a 'rev_parse' method defined, the __getattr__
+            will run.  We'll replace the '_' with a '-' and try to run a git
+            command. Any other positional arguments will be passed to the git
+            command, and the following keyword arguments are supported:
+                config: An optional dict of git config options to be passed with
+                    '-c'.
+            Args:
+                name: The name of the git command to call.  Any '_' characters
+                    will be replaced with '-'.
+            Returns:
+                A callable object that will try to call git with the named
+                command.
+            """
+            name = name.replace("_", "-")
+            def runner(*args, **kwargs):
+                cmdv = []
+                config = kwargs.pop("config", None)
+                for k in kwargs:
+                    raise TypeError(
+                        "%s() got an unexpected keyword argument %r" % (name, k)
+                    )
+                if config is not None:
+                    for k, v in config.items():
+                        cmdv.append("-c")
+                        cmdv.append("%s=%s" % (k, v))
+                cmdv.append(name)
+                cmdv.extend(args)
+                p = GitCommand(
+                    self._project,
+                    cmdv,
+                    bare=self._bare,
+                    gitdir=self._gitdir,
+                    capture_stdout=True,
+                    capture_stderr=True,
+                )
+                if p.Wait() != 0:
+                    raise GitError(
+                        "%s %s: %s" % (self._project.name, name, p.stderr)
+                    )
+                r = p.stdout
+                if r.endswith("\n") and r.index("\n") == len(r) - 1:
+                    return r[:-1]
+                return r
+            return runner
-  def fail(self, project, err=None):
-    self._failures.append(_Failure(project, err))
-    self._MarkUnclean()
-  def later1(self, project, what):
+class _PriorSyncFailedError(Exception):
-    self._later_queue1.append(_Later(project, what))
+    def __str__(self):
+        return "prior sync failed; rebase still in progress"
-  def later2(self, project, what):
-    self._later_queue2.append(_Later(project, what))
-  def Finish(self):
+class _DirtyError(Exception):
-    self._PrintMessages()
+    def __str__(self):
-    self._RunLater()
+        return "contains uncommitted changes"
-    self._PrintMessages()
-    return self.clean
-  def Recently(self):
-    recent_clean = self.recent_clean
-    self.recent_clean = True
-    return recent_clean
-  def _MarkUnclean(self):
+class _InfoMessage(object):
-    self.clean = False
+    def __init__(self, project, text):
-    self.recent_clean = False
+        self.project = project
+        self.text = text
-  def _RunLater(self):
+    def Print(self, syncbuf):
-    for q in ['_later_queue1', '_later_queue2']:
+        syncbuf.out.info(
-      if not self._RunQueue(q):
+            "%s/: %s", self.project.RelPath(local=False), self.text
-        return
+        )
+        syncbuf.out.nl()
-  def _RunQueue(self, queue):
-    for m in getattr(self, queue):
-      if not m.Run(self):
-        self._MarkUnclean()
-        return False
-    setattr(self, queue, [])
-    return True
-  def _PrintMessages(self):
+class _Failure(object):
-    if self._messages or self._failures:
+    def __init__(self, project, why):
-      if os.isatty(2):
+        self.project = project
-        self.out.write(progress.CSI_ERASE_LINE)
+        self.why = why
-      self.out.write('\r')
-    for m in self._messages:
+    def Print(self, syncbuf):
-      m.Print(self)
+        syncbuf.out.fail(
-    for m in self._failures:
+            "error: %s/: %s", self.project.RelPath(local=False), str(self.why)
-      m.Print(self)
+        )
+        syncbuf.out.nl()
-    self._messages = []
-    self._failures = []
+class _Later(object):
+    def __init__(self, project, action):
+        self.project = project
+        self.action = action
+    def Run(self, syncbuf):
+        out = syncbuf.out
+        out.project("project %s/", self.project.RelPath(local=False))
+        out.nl()
+        try:
+            self.action()
+            out.nl()
+            return True
+        except GitError:
+            out.nl()
+            return False
-class MetaProject(Project):
-  """A special project housed under .repo."""
-  def __init__(self, manifest, name, gitdir, worktree):
-    Project.__init__(self,
-                     manifest=manifest,
-                     name=name,
-                     gitdir=gitdir,
-                     objdir=gitdir,
-                     worktree=worktree,
-                     remote=RemoteSpec('origin'),
-                     relpath='.repo/%s' % name,
-                     revisionExpr='refs/heads/master',
-                     revisionId=None,
-                     groups=None)
-  def PreSync(self):
-    if self.Exists:
-      cb = self.CurrentBranch
-      if cb:
-        base = self.GetBranch(cb).merge
-        if base:
-          self.revisionExpr = base
-          self.revisionId = None
-  @property
-  def HasChanges(self):
-    """Has the remote received new commits not yet checked out?"""
-    if not self.remote or not self.revisionExpr:
-      return False
-    all_refs = self.bare_ref.all
-    revid = self.GetRevisionId(all_refs)
-    head = self.work_git.GetHead()
-    if head.startswith(R_HEADS):
-      try:
-        head = all_refs[head]
-      except KeyError:
-        head = None
-    if revid == head:
-      return False
-    elif self._revlist(not_rev(HEAD), revid):
-      return True
-    return False
+class _SyncColoring(Coloring):
+    def __init__(self, config):
+        super().__init__(config, "reposync")
+        self.project = self.printer("header", attr="bold")
+        self.info = self.printer("info")
+        self.fail = self.printer("fail", fg="red")
-class RepoProject(MetaProject):
-  """The MetaProject for repo itself."""
-  @property
+class SyncBuffer(object):
-  def LastFetch(self):
+    def __init__(self, config, detach_head=False):
-    try:
+        self._messages = []
-      fh = os.path.join(self.gitdir, 'FETCH_HEAD')
+        self._failures = []
-      return os.path.getmtime(fh)
+        self._later_queue1 = []
-    except OSError:
+        self._later_queue2 = []
-      return 0
+        self.out = _SyncColoring(config)
+        self.out.redirect(sys.stderr)
-class ManifestProject(MetaProject):
+        self.detach_head = detach_head
-  """The MetaProject for manifests."""
+        self.clean = True
+        self.recent_clean = True
-  def MetaBranchSwitch(self, submodules=False):
-    """Prepare for manifest branch switch."""
-    # detach and delete manifest branch, allowing a new
-    # branch to take over
-    syncbuf = SyncBuffer(self.config, detach_head=True)
-    self.Sync_LocalHalf(syncbuf, submodules=submodules)
-    syncbuf.Finish()
-    return GitCommand(self,
-                      ['update-ref', '-d', 'refs/heads/default'],
-                      capture_stdout=True,
-                      capture_stderr=True).Wait() == 0
-  @property
-  def standalone_manifest_url(self):
-    """The URL of the standalone manifest, or None."""
-    return self.config.GetString('manifest.standalone')
-  @property
-  def manifest_groups(self):
-    """The manifest groups string."""
-    return self.config.GetString('manifest.groups')
-  @property
-  def reference(self):
-    """The --reference for this manifest."""
-    return self.config.GetString('repo.reference')
-  @property
-  def dissociate(self):
-    """Whether to dissociate."""
-    return self.config.GetBoolean('repo.dissociate')
-  @property
-  def archive(self):
-    """Whether we use archive."""
-    return self.config.GetBoolean('repo.archive')
-  @property
-  def mirror(self):
-    """Whether we use mirror."""
-    return self.config.GetBoolean('repo.mirror')
-  @property
-  def use_worktree(self):
-    """Whether we use worktree."""
-    return self.config.GetBoolean('repo.worktree')
-  @property
-  def clone_bundle(self):
-    """Whether we use clone_bundle."""
-    return self.config.GetBoolean('repo.clonebundle')
-  @property
-  def submodules(self):
-    """Whether we use submodules."""
-    return self.config.GetBoolean('repo.submodules')
-  @property
-  def git_lfs(self):
-    """Whether we use git_lfs."""
-    return self.config.GetBoolean('repo.git-lfs')
-  @property
-  def use_superproject(self):
-    """Whether we use superproject."""
-    return self.config.GetBoolean('repo.superproject')
-  @property
-  def partial_clone(self):
-    """Whether this is a partial clone."""
-    return self.config.GetBoolean('repo.partialclone')
-  @property
-  def depth(self):
-    """Partial clone depth."""
-    return self.config.GetString('repo.depth')
-  @property
-  def clone_filter(self):
-    """The clone filter."""
-    return self.config.GetString('repo.clonefilter')
-  @property
-  def partial_clone_exclude(self):
-    """Partial clone exclude string"""
-    return self.config.GetString('repo.partialcloneexclude')
-  @property
-  def manifest_platform(self):
-    """The --platform argument from `repo init`."""
-    return self.config.GetString('manifest.platform')
-  @property
-  def _platform_name(self):
-    """Return the name of the platform."""
-    return platform.system().lower()
-  def SyncWithPossibleInit(self, submanifest, verbose=False,
-                           current_branch_only=False, tags='', git_event_log=None):
-    """Sync a manifestProject, possibly for the first time.
-    Call Sync() with arguments from the most recent `repo init`.  If this is a
-    new sub manifest, then inherit options from the parent's manifestProject.
-    This is used by subcmds.Sync() to do an initial download of new sub
-    manifests.
-    Args:
-      submanifest: an XmlSubmanifest, the submanifest to re-sync.
-      verbose: a boolean, whether to show all output, rather than only errors.
-      current_branch_only: a boolean, whether to only fetch the current manifest
-          branch from the server.
-      tags: a boolean, whether to fetch tags.
-      git_event_log: an EventLog, for git tracing.
-    """
-    # TODO(lamontjones): when refactoring sync (and init?) consider how to
-    # better get the init options that we should use for new submanifests that
-    # are added when syncing an existing workspace.
-    git_event_log = git_event_log or EventLog()
-    spec = submanifest.ToSubmanifestSpec()
-    # Use the init options from the existing manifestProject, or the parent if
-    # it doesn't exist.
-    #
-    # Today, we only support changing manifest_groups on the sub-manifest, with
-    # no supported-for-the-user way to change the other arguments from those
-    # specified by the outermost manifest.
-    #
-    # TODO(lamontjones): determine which of these should come from the outermost
-    # manifest and which should come from the parent manifest.
-    mp = self if self.Exists else submanifest.parent.manifestProject
-    return self.Sync(
-        manifest_url=spec.manifestUrl,
-        manifest_branch=spec.revision,
-        standalone_manifest=mp.standalone_manifest_url,
-        groups=mp.manifest_groups,
-        platform=mp.manifest_platform,
-        mirror=mp.mirror,
-        dissociate=mp.dissociate,
-        reference=mp.reference,
-        worktree=mp.use_worktree,
-        submodules=mp.submodules,
-        archive=mp.archive,
-        partial_clone=mp.partial_clone,
-        clone_filter=mp.clone_filter,
-        partial_clone_exclude=mp.partial_clone_exclude,
-        clone_bundle=mp.clone_bundle,
-        git_lfs=mp.git_lfs,
-        use_superproject=mp.use_superproject,
-        verbose=verbose,
-        current_branch_only=current_branch_only,
-        tags=tags,
-        depth=mp.depth,
-        git_event_log=git_event_log,
-        manifest_name=spec.manifestName,
-        this_manifest_only=True,
-        outer_manifest=False,
-    )
-  def Sync(self, _kwargs_only=(), manifest_url='', manifest_branch=None,
-           standalone_manifest=False, groups='', mirror=False, reference='',
-           dissociate=False, worktree=False, submodules=False, archive=False,
-           partial_clone=None, depth=None, clone_filter='blob:none',
-           partial_clone_exclude=None, clone_bundle=None, git_lfs=None,
-           use_superproject=None, verbose=False, current_branch_only=False,
-           git_event_log=None, platform='', manifest_name='default.xml',
-           tags='', this_manifest_only=False, outer_manifest=True):
-    """Sync the manifest and all submanifests.
-    Args:
-      manifest_url: a string, the URL of the manifest project.
-      manifest_branch: a string, the manifest branch to use.
-      standalone_manifest: a boolean, whether to store the manifest as a static
-          file.
-      groups: a string, restricts the checkout to projects with the specified
-          groups.
-      mirror: a boolean, whether to create a mirror of the remote repository.
-      reference: a string, location of a repo instance to use as a reference.
-      dissociate: a boolean, whether to dissociate from reference mirrors after
-          clone.
-      worktree: a boolean, whether to use git-worktree to manage projects.
-      submodules: a boolean, whether sync submodules associated with the
-          manifest project.
-      archive: a boolean, whether to checkout each project as an archive.  See
-          git-archive.
-      partial_clone: a boolean, whether to perform a partial clone.
-      depth: an int, how deep of a shallow clone to create.
-      clone_filter: a string, filter to use with partial_clone.
-      partial_clone_exclude : a string, comma-delimeted list of project namess
-          to exclude from partial clone.
-      clone_bundle: a boolean, whether to enable /clone.bundle on HTTP/HTTPS.
-      git_lfs: a boolean, whether to enable git LFS support.
-      use_superproject: a boolean, whether to use the manifest superproject to
-          sync projects.
-      verbose: a boolean, whether to show all output, rather than only errors.
-      current_branch_only: a boolean, whether to only fetch the current manifest
-          branch from the server.
-      platform: a string, restrict the checkout to projects with the specified
-          platform group.
-      git_event_log: an EventLog, for git tracing.
-      tags: a boolean, whether to fetch tags.
-      manifest_name: a string, the name of the manifest file to use.
-      this_manifest_only: a boolean, whether to only operate on the current sub
-          manifest.
-      outer_manifest: a boolean, whether to start at the outermost manifest.
-    Returns:
+    def info(self, project, fmt, *args):
-      a boolean, whether the sync was successful.
+        self._messages.append(_InfoMessage(project, fmt % args))
-    """
-    assert _kwargs_only == (), 'Sync only accepts keyword arguments.'
-    groups = groups or self.manifest.GetDefaultGroupsStr(with_platform=False)
-    platform = platform or 'auto'
-    git_event_log = git_event_log or EventLog()
-    if outer_manifest and self.manifest.is_submanifest:
-      # In a multi-manifest checkout, use the outer manifest unless we are told
-      # not to.
-      return self.client.outer_manifest.manifestProject.Sync(
-          manifest_url=manifest_url,
-          manifest_branch=manifest_branch,
-          standalone_manifest=standalone_manifest,
-          groups=groups,
-          platform=platform,
-          mirror=mirror,
-          dissociate=dissociate,
-          reference=reference,
-          worktree=worktree,
-          submodules=submodules,
-          archive=archive,
-          partial_clone=partial_clone,
-          clone_filter=clone_filter,
-          partial_clone_exclude=partial_clone_exclude,
-          clone_bundle=clone_bundle,
-          git_lfs=git_lfs,
-          use_superproject=use_superproject,
-          verbose=verbose,
-          current_branch_only=current_branch_only,
-          tags=tags,
-          depth=depth,
-          git_event_log=git_event_log,
-          manifest_name=manifest_name,
-          this_manifest_only=this_manifest_only,
-          outer_manifest=False)
-    # If repo has already been initialized, we take -u with the absence of
-    # --standalone-manifest to mean "transition to a standard repo set up",
-    # which necessitates starting fresh.
-    # If --standalone-manifest is set, we always tear everything down and start
-    # anew.
-    if self.Exists:
-      was_standalone_manifest = self.config.GetString('manifest.standalone')
-      if was_standalone_manifest and not manifest_url:
-        print('fatal: repo was initialized with a standlone manifest, '
-              'cannot be re-initialized without --manifest-url/-u')
-        return False
-      if standalone_manifest or (was_standalone_manifest and manifest_url):
+    def fail(self, project, err=None):
-        self.config.ClearCache()
+        self._failures.append(_Failure(project, err))
-        if self.gitdir and os.path.exists(self.gitdir):
+        self._MarkUnclean()
-          platform_utils.rmtree(self.gitdir)
-        if self.worktree and os.path.exists(self.worktree):
-          platform_utils.rmtree(self.worktree)
-    is_new = not self.Exists
-    if is_new:
-      if not manifest_url:
-        print('fatal: manifest url is required.', file=sys.stderr)
-        return False
-      if verbose:
+    def later1(self, project, what):
-        print('Downloading manifest from %s' %
+        self._later_queue1.append(_Later(project, what))
-              (GitConfig.ForUser().UrlInsteadOf(manifest_url),),
-              file=sys.stderr)
+    def later2(self, project, what):
+        self._later_queue2.append(_Later(project, what))
-      # The manifest project object doesn't keep track of the path on the
-      # server where this git is located, so let's save that here.
+    def Finish(self):
-      mirrored_manifest_git = None
+        self._PrintMessages()
-      if reference:
+        self._RunLater()
-        manifest_git_path = urllib.parse.urlparse(manifest_url).path[1:]
+        self._PrintMessages()
-        mirrored_manifest_git = os.path.join(reference, manifest_git_path)
+        return self.clean
-        if not mirrored_manifest_git.endswith(".git"):
-          mirrored_manifest_git += ".git"
+    def Recently(self):
-        if not os.path.exists(mirrored_manifest_git):
+        recent_clean = self.recent_clean
-          mirrored_manifest_git = os.path.join(reference,
+        self.recent_clean = True
-                                               '.repo/manifests.git')
+        return recent_clean
-      self._InitGitDir(mirror_git=mirrored_manifest_git)
+    def _MarkUnclean(self):
+        self.clean = False
-    # If standalone_manifest is set, mark the project as "standalone" -- we'll
+        self.recent_clean = False
-    # still do much of the manifests.git set up, but will avoid actual syncs to
-    # a remote.
+    def _RunLater(self):
-    if standalone_manifest:
+        for q in ["_later_queue1", "_later_queue2"]:
-      self.config.SetString('manifest.standalone', manifest_url)
+            if not self._RunQueue(q):
-    elif not manifest_url and not manifest_branch:
+                return
-      # If -u is set and --standalone-manifest is not, then we're not in
-      # standalone mode. Otherwise, use config to infer what we were in the last
+    def _RunQueue(self, queue):
-      # init.
+        for m in getattr(self, queue):
-      standalone_manifest = bool(self.config.GetString('manifest.standalone'))
+            if not m.Run(self):
-    if not standalone_manifest:
+                self._MarkUnclean()
-      self.config.SetString('manifest.standalone', None)
+                return False
+        setattr(self, queue, [])
-    self._ConfigureDepth(depth)
+        return True
-    # Set the remote URL before the remote branch as we might need it below.
+    def _PrintMessages(self):
-    if manifest_url:
+        if self._messages or self._failures:
-      r = self.GetRemote()
+            if os.isatty(2):
-      r.url = manifest_url
+                self.out.write(progress.CSI_ERASE_LINE)
-      r.ResetFetch()
+            self.out.write("\r")
-      r.Save()
+        for m in self._messages:
-    if not standalone_manifest:
+            m.Print(self)
-      if manifest_branch:
+        for m in self._failures:
-        if manifest_branch == 'HEAD':
+            m.Print(self)
-          manifest_branch = self.ResolveRemoteHead()
-          if manifest_branch is None:
+        self._messages = []
-            print('fatal: unable to resolve HEAD', file=sys.stderr)
+        self._failures = []
+class MetaProject(Project):
+    """A special project housed under .repo."""
+    def __init__(self, manifest, name, gitdir, worktree):
+        Project.__init__(
+            self,
+            manifest=manifest,
+            name=name,
+            gitdir=gitdir,
+            objdir=gitdir,
+            worktree=worktree,
+            remote=RemoteSpec("origin"),
+            relpath=".repo/%s" % name,
+            revisionExpr="refs/heads/master",
+            revisionId=None,
+            groups=None,
+        )
+    def PreSync(self):
+        if self.Exists:
+            cb = self.CurrentBranch
+            if cb:
+                base = self.GetBranch(cb).merge
+                if base:
+                    self.revisionExpr = base
+                    self.revisionId = None
+    @property
+    def HasChanges(self):
+        """Has the remote received new commits not yet checked out?"""
+        if not self.remote or not self.revisionExpr:
            return False
-        self.revisionExpr = manifest_branch
-      else:
-        if is_new:
-          default_branch = self.ResolveRemoteHead()
-          if default_branch is None:
-            # If the remote doesn't have HEAD configured, default to master.
-            default_branch = 'refs/heads/master'
-          self.revisionExpr = default_branch
-        else:
-          self.PreSync()
-    groups = re.split(r'[,\s]+', groups or '')
-    all_platforms = ['linux', 'darwin', 'windows']
-    platformize = lambda x: 'platform-' + x
-    if platform == 'auto':
-      if not mirror and not self.mirror:
-        groups.append(platformize(self._platform_name))
-    elif platform == 'all':
-      groups.extend(map(platformize, all_platforms))
-    elif platform in all_platforms:
-      groups.append(platformize(platform))
-    elif platform != 'none':
-      print('fatal: invalid platform flag', file=sys.stderr)
-      return False
-    self.config.SetString('manifest.platform', platform)
-    groups = [x for x in groups if x]
-    groupstr = ','.join(groups)
-    if platform == 'auto' and groupstr == self.manifest.GetDefaultGroupsStr():
-      groupstr = None
-    self.config.SetString('manifest.groups', groupstr)
-    if reference:
-      self.config.SetString('repo.reference', reference)
-    if dissociate:
-      self.config.SetBoolean('repo.dissociate', dissociate)
-    if worktree:
-      if mirror:
-        print('fatal: --mirror and --worktree are incompatible',
-              file=sys.stderr)
-        return False
-      if submodules:
-        print('fatal: --submodules and --worktree are incompatible',
-              file=sys.stderr)
-        return False
-      self.config.SetBoolean('repo.worktree', worktree)
-      if is_new:
-        self.use_git_worktrees = True
-      print('warning: --worktree is experimental!', file=sys.stderr)
-    if archive:
-      if is_new:
-        self.config.SetBoolean('repo.archive', archive)
-      else:
-        print('fatal: --archive is only supported when initializing a new '
-              'workspace.', file=sys.stderr)
-        print('Either delete the .repo folder in this workspace, or initialize '
-              'in another location.', file=sys.stderr)
-        return False
-    if mirror:
+        all_refs = self.bare_ref.all
-      if is_new:
+        revid = self.GetRevisionId(all_refs)
-        self.config.SetBoolean('repo.mirror', mirror)
+        head = self.work_git.GetHead()
-      else:
+        if head.startswith(R_HEADS):
-        print('fatal: --mirror is only supported when initializing a new '
+            try:
-              'workspace.', file=sys.stderr)
+                head = all_refs[head]
-        print('Either delete the .repo folder in this workspace, or initialize '
+            except KeyError:
-              'in another location.', file=sys.stderr)
+                head = None
-        return False
-    if partial_clone is not None:
+        if revid == head:
-      if mirror:
+            return False
-        print('fatal: --mirror and --partial-clone are mutually exclusive',
+        elif self._revlist(not_rev(HEAD), revid):
-              file=sys.stderr)
+            return True
-        return False
-      self.config.SetBoolean('repo.partialclone', partial_clone)
-      if clone_filter:
-        self.config.SetString('repo.clonefilter', clone_filter)
-    elif self.partial_clone:
-      clone_filter = self.clone_filter
-    else:
-      clone_filter = None
-    if partial_clone_exclude is not None:
-      self.config.SetString('repo.partialcloneexclude', partial_clone_exclude)
-    if clone_bundle is None:
-      clone_bundle = False if partial_clone else True
-    else:
-      self.config.SetBoolean('repo.clonebundle', clone_bundle)
-    if submodules:
-      self.config.SetBoolean('repo.submodules', submodules)
-    if git_lfs is not None:
-      if git_lfs:
-        git_require((2, 17, 0), fail=True, msg='Git LFS support')
-      self.config.SetBoolean('repo.git-lfs', git_lfs)
-      if not is_new:
-        print('warning: Changing --git-lfs settings will only affect new project checkouts.\n'
-              '         Existing projects will require manual updates.\n', file=sys.stderr)
-    if use_superproject is not None:
-      self.config.SetBoolean('repo.superproject', use_superproject)
-    if not standalone_manifest:
-      success = self.Sync_NetworkHalf(
-          is_new=is_new, quiet=not verbose, verbose=verbose,
-          clone_bundle=clone_bundle, current_branch_only=current_branch_only,
-          tags=tags, submodules=submodules, clone_filter=clone_filter,
-          partial_clone_exclude=self.manifest.PartialCloneExclude).success
-      if not success:
-        r = self.GetRemote()
-        print('fatal: cannot obtain manifest %s' % r.url, file=sys.stderr)
-        # Better delete the manifest git dir if we created it; otherwise next
-        # time (when user fixes problems) we won't go through the "is_new" logic.
-        if is_new:
-          platform_utils.rmtree(self.gitdir)
        return False
-      if manifest_branch:
-        self.MetaBranchSwitch(submodules=submodules)
-      syncbuf = SyncBuffer(self.config)
+class RepoProject(MetaProject):
-      self.Sync_LocalHalf(syncbuf, submodules=submodules)
+    """The MetaProject for repo itself."""
-      syncbuf.Finish()
-      if is_new or self.CurrentBranch is None:
+    @property
-        if not self.StartBranch('default'):
+    def LastFetch(self):
-          print('fatal: cannot create default in manifest', file=sys.stderr)
+        try:
-          return False
+            fh = os.path.join(self.gitdir, "FETCH_HEAD")
+            return os.path.getmtime(fh)
+        except OSError:
+            return 0
-      if not manifest_name:
-        print('fatal: manifest name (-m) is required.', file=sys.stderr)
-        return False
-    elif is_new:
+class ManifestProject(MetaProject):
-      # This is a new standalone manifest.
+    """The MetaProject for manifests."""
-      manifest_name = 'default.xml'
-      manifest_data = fetch.fetch_file(manifest_url, verbose=verbose)
+    def MetaBranchSwitch(self, submodules=False):
-      dest = os.path.join(self.worktree, manifest_name)
+        """Prepare for manifest branch switch."""
-      os.makedirs(os.path.dirname(dest), exist_ok=True)
-      with open(dest, 'wb') as f:
+        # detach and delete manifest branch, allowing a new
-        f.write(manifest_data)
+        # branch to take over
+        syncbuf = SyncBuffer(self.config, detach_head=True)
+        self.Sync_LocalHalf(syncbuf, submodules=submodules)
+        syncbuf.Finish()
+        return (
+            GitCommand(
+                self,
+                ["update-ref", "-d", "refs/heads/default"],
+                capture_stdout=True,
+                capture_stderr=True,
+            ).Wait()
+            == 0
+        )
+    @property
+    def standalone_manifest_url(self):
+        """The URL of the standalone manifest, or None."""
+        return self.config.GetString("manifest.standalone")
+    @property
+    def manifest_groups(self):
+        """The manifest groups string."""
+        return self.config.GetString("manifest.groups")
+    @property
+    def reference(self):
+        """The --reference for this manifest."""
+        return self.config.GetString("repo.reference")
+    @property
+    def dissociate(self):
+        """Whether to dissociate."""
+        return self.config.GetBoolean("repo.dissociate")
+    @property
+    def archive(self):
+        """Whether we use archive."""
+        return self.config.GetBoolean("repo.archive")
+    @property
+    def mirror(self):
+        """Whether we use mirror."""
+        return self.config.GetBoolean("repo.mirror")
+    @property
+    def use_worktree(self):
+        """Whether we use worktree."""
+        return self.config.GetBoolean("repo.worktree")
+    @property
+    def clone_bundle(self):
+        """Whether we use clone_bundle."""
+        return self.config.GetBoolean("repo.clonebundle")
+    @property
+    def submodules(self):
+        """Whether we use submodules."""
+        return self.config.GetBoolean("repo.submodules")
+    @property
+    def git_lfs(self):
+        """Whether we use git_lfs."""
+        return self.config.GetBoolean("repo.git-lfs")
+    @property
+    def use_superproject(self):
+        """Whether we use superproject."""
+        return self.config.GetBoolean("repo.superproject")
+    @property
+    def partial_clone(self):
+        """Whether this is a partial clone."""
+        return self.config.GetBoolean("repo.partialclone")
+    @property
+    def depth(self):
+        """Partial clone depth."""
+        return self.config.GetString("repo.depth")
+    @property
+    def clone_filter(self):
+        """The clone filter."""
+        return self.config.GetString("repo.clonefilter")
+    @property
+    def partial_clone_exclude(self):
+        """Partial clone exclude string"""
+        return self.config.GetString("repo.partialcloneexclude")
+    @property
+    def manifest_platform(self):
+        """The --platform argument from `repo init`."""
+        return self.config.GetString("manifest.platform")
+    @property
+    def _platform_name(self):
+        """Return the name of the platform."""
+        return platform.system().lower()
+    def SyncWithPossibleInit(
+        self,
+        submanifest,
+        verbose=False,
+        current_branch_only=False,
+        tags="",
+        git_event_log=None,
+    ):
+        """Sync a manifestProject, possibly for the first time.
+        Call Sync() with arguments from the most recent `repo init`.  If this is
+        a new sub manifest, then inherit options from the parent's
+        manifestProject.
+        This is used by subcmds.Sync() to do an initial download of new sub
+        manifests.
-    try:
+        Args:
-      self.manifest.Link(manifest_name)
+            submanifest: an XmlSubmanifest, the submanifest to re-sync.
-    except ManifestParseError as e:
+            verbose: a boolean, whether to show all output, rather than only
-      print("fatal: manifest '%s' not available" % manifest_name,
+                errors.
-            file=sys.stderr)
+            current_branch_only: a boolean, whether to only fetch the current
-      print('fatal: %s' % str(e), file=sys.stderr)
+                manifest branch from the server.
-      return False
+            tags: a boolean, whether to fetch tags.
+            git_event_log: an EventLog, for git tracing.
-    if not this_manifest_only:
+        """
-      for submanifest in self.manifest.submanifests.values():
+        # TODO(lamontjones): when refactoring sync (and init?) consider how to
+        # better get the init options that we should use for new submanifests
+        # that are added when syncing an existing workspace.
+        git_event_log = git_event_log or EventLog()
        spec = submanifest.ToSubmanifestSpec()
-        submanifest.repo_client.manifestProject.Sync(
+        # Use the init options from the existing manifestProject, or the parent
+        # if it doesn't exist.
+        #
+        # Today, we only support changing manifest_groups on the sub-manifest,
+        # with no supported-for-the-user way to change the other arguments from
+        # those specified by the outermost manifest.
+        #
+        # TODO(lamontjones): determine which of these should come from the
+        # outermost manifest and which should come from the parent manifest.
+        mp = self if self.Exists else submanifest.parent.manifestProject
+        return self.Sync(
            manifest_url=spec.manifestUrl,
            manifest_branch=spec.revision,
-            standalone_manifest=standalone_manifest,
+            standalone_manifest=mp.standalone_manifest_url,
-            groups=self.manifest_groups,
+            groups=mp.manifest_groups,
-            platform=platform,
+            platform=mp.manifest_platform,
-            mirror=mirror,
+            mirror=mp.mirror,
-            dissociate=dissociate,
+            dissociate=mp.dissociate,
-            reference=reference,
+            reference=mp.reference,
-            worktree=worktree,
+            worktree=mp.use_worktree,
-            submodules=submodules,
+            submodules=mp.submodules,
-            archive=archive,
+            archive=mp.archive,
-            partial_clone=partial_clone,
+            partial_clone=mp.partial_clone,
-            clone_filter=clone_filter,
+            clone_filter=mp.clone_filter,
-            partial_clone_exclude=partial_clone_exclude,
+            partial_clone_exclude=mp.partial_clone_exclude,
-            clone_bundle=clone_bundle,
+            clone_bundle=mp.clone_bundle,
-            git_lfs=git_lfs,
+            git_lfs=mp.git_lfs,
-            use_superproject=use_superproject,
+            use_superproject=mp.use_superproject,
            verbose=verbose,
            current_branch_only=current_branch_only,
            tags=tags,
-            depth=depth,
+            depth=mp.depth,
            git_event_log=git_event_log,
            manifest_name=spec.manifestName,
-            this_manifest_only=False,
+            this_manifest_only=True,
            outer_manifest=False,
        )
-    # Lastly, if the manifest has a <superproject> then have the superproject
+    def Sync(
-    # sync it (if it will be used).
+        self,
-    if git_superproject.UseSuperproject(use_superproject, self.manifest):
+        _kwargs_only=(),
-      sync_result = self.manifest.superproject.Sync(git_event_log)
+        manifest_url="",
-      if not sync_result.success:
+        manifest_branch=None,
-        submanifest = ''
+        standalone_manifest=False,
-        if self.manifest.path_prefix:
+        groups="",
-          submanifest = f'for {self.manifest.path_prefix} '
+        mirror=False,
-        print(f'warning: git update of superproject {submanifest}failed, repo '
+        reference="",
-              'sync will not use superproject to fetch source; while this '
+        dissociate=False,
-              'error is not fatal, and you can continue to run repo sync, '
+        worktree=False,
-              'please run repo init with the --no-use-superproject option to '
+        submodules=False,
-              'stop seeing this warning', file=sys.stderr)
+        archive=False,
-        if sync_result.fatal and use_superproject is not None:
+        partial_clone=None,
-          return False
+        depth=None,
+        clone_filter="blob:none",
-    return True
+        partial_clone_exclude=None,
+        clone_bundle=None,
-  def _ConfigureDepth(self, depth):
+        git_lfs=None,
-    """Configure the depth we'll sync down.
+        use_superproject=None,
+        verbose=False,
-    Args:
+        current_branch_only=False,
-      depth: an int, how deep of a partial clone to create.
+        git_event_log=None,
-    """
+        platform="",
-    # Opt.depth will be non-None if user actually passed --depth to repo init.
+        manifest_name="default.xml",
-    if depth is not None:
+        tags="",
-      if depth > 0:
+        this_manifest_only=False,
-        # Positive values will set the depth.
+        outer_manifest=True,
-        depth = str(depth)
+    ):
-      else:
+        """Sync the manifest and all submanifests.
-        # Negative numbers will clear the depth; passing None to SetString
-        # will do that.
+        Args:
-        depth = None
+            manifest_url: a string, the URL of the manifest project.
+            manifest_branch: a string, the manifest branch to use.
-      # We store the depth in the main manifest project.
+            standalone_manifest: a boolean, whether to store the manifest as a
-      self.config.SetString('repo.depth', depth)
+                static file.
+            groups: a string, restricts the checkout to projects with the
+                specified groups.
+            mirror: a boolean, whether to create a mirror of the remote
+                repository.
+            reference: a string, location of a repo instance to use as a
+                reference.
+            dissociate: a boolean, whether to dissociate from reference mirrors
+                after clone.
+            worktree: a boolean, whether to use git-worktree to manage projects.
+            submodules: a boolean, whether sync submodules associated with the
+                manifest project.
+            archive: a boolean, whether to checkout each project as an archive.
+                See git-archive.
+            partial_clone: a boolean, whether to perform a partial clone.
+            depth: an int, how deep of a shallow clone to create.
+            clone_filter: a string, filter to use with partial_clone.
+            partial_clone_exclude : a string, comma-delimeted list of project
+                names to exclude from partial clone.
+            clone_bundle: a boolean, whether to enable /clone.bundle on
+                HTTP/HTTPS.
+            git_lfs: a boolean, whether to enable git LFS support.
+            use_superproject: a boolean, whether to use the manifest
+                superproject to sync projects.
+            verbose: a boolean, whether to show all output, rather than only
+                errors.
+            current_branch_only: a boolean, whether to only fetch the current
+                manifest branch from the server.
+            platform: a string, restrict the checkout to projects with the
+                specified platform group.
+            git_event_log: an EventLog, for git tracing.
+            tags: a boolean, whether to fetch tags.
+            manifest_name: a string, the name of the manifest file to use.
+            this_manifest_only: a boolean, whether to only operate on the
+                current sub manifest.
+            outer_manifest: a boolean, whether to start at the outermost
+                manifest.
+        Returns:
+            a boolean, whether the sync was successful.
+        """
+        assert _kwargs_only == (), "Sync only accepts keyword arguments."
+        groups = groups or self.manifest.GetDefaultGroupsStr(
+            with_platform=False
+        )
+        platform = platform or "auto"
+        git_event_log = git_event_log or EventLog()
+        if outer_manifest and self.manifest.is_submanifest:
+            # In a multi-manifest checkout, use the outer manifest unless we are
+            # told not to.
+            return self.client.outer_manifest.manifestProject.Sync(
+                manifest_url=manifest_url,
+                manifest_branch=manifest_branch,
+                standalone_manifest=standalone_manifest,
+                groups=groups,
+                platform=platform,
+                mirror=mirror,
+                dissociate=dissociate,
+                reference=reference,
+                worktree=worktree,
+                submodules=submodules,
+                archive=archive,
+                partial_clone=partial_clone,
+                clone_filter=clone_filter,
+                partial_clone_exclude=partial_clone_exclude,
+                clone_bundle=clone_bundle,
+                git_lfs=git_lfs,
+                use_superproject=use_superproject,
+                verbose=verbose,
+                current_branch_only=current_branch_only,
+                tags=tags,
+                depth=depth,
+                git_event_log=git_event_log,
+                manifest_name=manifest_name,
+                this_manifest_only=this_manifest_only,
+                outer_manifest=False,
+            )
+        # If repo has already been initialized, we take -u with the absence of
+        # --standalone-manifest to mean "transition to a standard repo set up",
+        # which necessitates starting fresh.
+        # If --standalone-manifest is set, we always tear everything down and
+        # start anew.
+        if self.Exists:
+            was_standalone_manifest = self.config.GetString(
+                "manifest.standalone"
+            )
+            if was_standalone_manifest and not manifest_url:
+                print(
+                    "fatal: repo was initialized with a standlone manifest, "
+                    "cannot be re-initialized without --manifest-url/-u"
+                )
+                return False
+            if standalone_manifest or (
+                was_standalone_manifest and manifest_url
+            ):
+                self.config.ClearCache()
+                if self.gitdir and os.path.exists(self.gitdir):
+                    platform_utils.rmtree(self.gitdir)
+                if self.worktree and os.path.exists(self.worktree):
+                    platform_utils.rmtree(self.worktree)
+        is_new = not self.Exists
+        if is_new:
+            if not manifest_url:
+                print("fatal: manifest url is required.", file=sys.stderr)
+                return False
+            if verbose:
+                print(
+                    "Downloading manifest from %s"
+                    % (GitConfig.ForUser().UrlInsteadOf(manifest_url),),
+                    file=sys.stderr,
+                )
+            # The manifest project object doesn't keep track of the path on the
+            # server where this git is located, so let's save that here.
+            mirrored_manifest_git = None
+            if reference:
+                manifest_git_path = urllib.parse.urlparse(manifest_url).path[1:]
+                mirrored_manifest_git = os.path.join(
+                    reference, manifest_git_path
+                )
+                if not mirrored_manifest_git.endswith(".git"):
+                    mirrored_manifest_git += ".git"
+                if not os.path.exists(mirrored_manifest_git):
+                    mirrored_manifest_git = os.path.join(
+                        reference, ".repo/manifests.git"
+                    )
+            self._InitGitDir(mirror_git=mirrored_manifest_git)
+        # If standalone_manifest is set, mark the project as "standalone" --
+        # we'll still do much of the manifests.git set up, but will avoid actual
+        # syncs to a remote.
+        if standalone_manifest:
+            self.config.SetString("manifest.standalone", manifest_url)
+        elif not manifest_url and not manifest_branch:
+            # If -u is set and --standalone-manifest is not, then we're not in
+            # standalone mode. Otherwise, use config to infer what we were in
+            # the last init.
+            standalone_manifest = bool(
+                self.config.GetString("manifest.standalone")
+            )
+        if not standalone_manifest:
+            self.config.SetString("manifest.standalone", None)
+        self._ConfigureDepth(depth)
+        # Set the remote URL before the remote branch as we might need it below.
+        if manifest_url:
+            r = self.GetRemote()
+            r.url = manifest_url
+            r.ResetFetch()
+            r.Save()
+        if not standalone_manifest:
+            if manifest_branch:
+                if manifest_branch == "HEAD":
+                    manifest_branch = self.ResolveRemoteHead()
+                    if manifest_branch is None:
+                        print("fatal: unable to resolve HEAD", file=sys.stderr)
+                        return False
+                self.revisionExpr = manifest_branch
+            else:
+                if is_new:
+                    default_branch = self.ResolveRemoteHead()
+                    if default_branch is None:
+                        # If the remote doesn't have HEAD configured, default to
+                        # master.
+                        default_branch = "refs/heads/master"
+                    self.revisionExpr = default_branch
+                else:
+                    self.PreSync()
+        groups = re.split(r"[,\s]+", groups or "")
+        all_platforms = ["linux", "darwin", "windows"]
+        platformize = lambda x: "platform-" + x
+        if platform == "auto":
+            if not mirror and not self.mirror:
+                groups.append(platformize(self._platform_name))
+        elif platform == "all":
+            groups.extend(map(platformize, all_platforms))
+        elif platform in all_platforms:
+            groups.append(platformize(platform))
+        elif platform != "none":
+            print("fatal: invalid platform flag", file=sys.stderr)
+            return False
+        self.config.SetString("manifest.platform", platform)
+        groups = [x for x in groups if x]
+        groupstr = ",".join(groups)
+        if (
+            platform == "auto"
+            and groupstr == self.manifest.GetDefaultGroupsStr()
+        ):
+            groupstr = None
+        self.config.SetString("manifest.groups", groupstr)
+        if reference:
+            self.config.SetString("repo.reference", reference)
+        if dissociate:
+            self.config.SetBoolean("repo.dissociate", dissociate)
+        if worktree:
+            if mirror:
+                print(
+                    "fatal: --mirror and --worktree are incompatible",
+                    file=sys.stderr,
+                )
+                return False
+            if submodules:
+                print(
+                    "fatal: --submodules and --worktree are incompatible",
+                    file=sys.stderr,
+                )
+                return False
+            self.config.SetBoolean("repo.worktree", worktree)
+            if is_new:
+                self.use_git_worktrees = True
+            print("warning: --worktree is experimental!", file=sys.stderr)
+        if archive:
+            if is_new:
+                self.config.SetBoolean("repo.archive", archive)
+            else:
+                print(
+                    "fatal: --archive is only supported when initializing a "
+                    "new workspace.",
+                    file=sys.stderr,
+                )
+                print(
+                    "Either delete the .repo folder in this workspace, or "
+                    "initialize in another location.",
+                    file=sys.stderr,
+                )
+                return False
+        if mirror:
+            if is_new:
+                self.config.SetBoolean("repo.mirror", mirror)
+            else:
+                print(
+                    "fatal: --mirror is only supported when initializing a new "
+                    "workspace.",
+                    file=sys.stderr,
+                )
+                print(
+                    "Either delete the .repo folder in this workspace, or "
+                    "initialize in another location.",
+                    file=sys.stderr,
+                )
+                return False
+        if partial_clone is not None:
+            if mirror:
+                print(
+                    "fatal: --mirror and --partial-clone are mutually "
+                    "exclusive",
+                    file=sys.stderr,
+                )
+                return False
+            self.config.SetBoolean("repo.partialclone", partial_clone)
+            if clone_filter:
+                self.config.SetString("repo.clonefilter", clone_filter)
+        elif self.partial_clone:
+            clone_filter = self.clone_filter
+        else:
+            clone_filter = None
+        if partial_clone_exclude is not None:
+            self.config.SetString(
+                "repo.partialcloneexclude", partial_clone_exclude
+            )
+        if clone_bundle is None:
+            clone_bundle = False if partial_clone else True
+        else:
+            self.config.SetBoolean("repo.clonebundle", clone_bundle)
+        if submodules:
+            self.config.SetBoolean("repo.submodules", submodules)
+        if git_lfs is not None:
+            if git_lfs:
+                git_require((2, 17, 0), fail=True, msg="Git LFS support")
+            self.config.SetBoolean("repo.git-lfs", git_lfs)
+            if not is_new:
+                print(
+                    "warning: Changing --git-lfs settings will only affect new "
+                    "project checkouts.\n"
+                    "         Existing projects will require manual updates.\n",
+                    file=sys.stderr,
+                )
+        if use_superproject is not None:
+            self.config.SetBoolean("repo.superproject", use_superproject)
+        if not standalone_manifest:
+            success = self.Sync_NetworkHalf(
+                is_new=is_new,
+                quiet=not verbose,
+                verbose=verbose,
+                clone_bundle=clone_bundle,
+                current_branch_only=current_branch_only,
+                tags=tags,
+                submodules=submodules,
+                clone_filter=clone_filter,
+                partial_clone_exclude=self.manifest.PartialCloneExclude,
+            ).success
+            if not success:
+                r = self.GetRemote()
+                print(
+                    "fatal: cannot obtain manifest %s" % r.url, file=sys.stderr
+                )
+                # Better delete the manifest git dir if we created it; otherwise
+                # next time (when user fixes problems) we won't go through the
+                # "is_new" logic.
+                if is_new:
+                    platform_utils.rmtree(self.gitdir)
+                return False
+            if manifest_branch:
+                self.MetaBranchSwitch(submodules=submodules)
+            syncbuf = SyncBuffer(self.config)
+            self.Sync_LocalHalf(syncbuf, submodules=submodules)
+            syncbuf.Finish()
+            if is_new or self.CurrentBranch is None:
+                if not self.StartBranch("default"):
+                    print(
+                        "fatal: cannot create default in manifest",
+                        file=sys.stderr,
+                    )
+                    return False
+            if not manifest_name:
+                print("fatal: manifest name (-m) is required.", file=sys.stderr)
+                return False
+        elif is_new:
+            # This is a new standalone manifest.
+            manifest_name = "default.xml"
+            manifest_data = fetch.fetch_file(manifest_url, verbose=verbose)
+            dest = os.path.join(self.worktree, manifest_name)
+            os.makedirs(os.path.dirname(dest), exist_ok=True)
+            with open(dest, "wb") as f:
+                f.write(manifest_data)
+        try:
+            self.manifest.Link(manifest_name)
+        except ManifestParseError as e:
+            print(
+                "fatal: manifest '%s' not available" % manifest_name,
+                file=sys.stderr,
+            )
+            print("fatal: %s" % str(e), file=sys.stderr)
+            return False
+        if not this_manifest_only:
+            for submanifest in self.manifest.submanifests.values():
+                spec = submanifest.ToSubmanifestSpec()
+                submanifest.repo_client.manifestProject.Sync(
+                    manifest_url=spec.manifestUrl,
+                    manifest_branch=spec.revision,
+                    standalone_manifest=standalone_manifest,
+                    groups=self.manifest_groups,
+                    platform=platform,
+                    mirror=mirror,
+                    dissociate=dissociate,
+                    reference=reference,
+                    worktree=worktree,
+                    submodules=submodules,
+                    archive=archive,
+                    partial_clone=partial_clone,
+                    clone_filter=clone_filter,
+                    partial_clone_exclude=partial_clone_exclude,
+                    clone_bundle=clone_bundle,
+                    git_lfs=git_lfs,
+                    use_superproject=use_superproject,
+                    verbose=verbose,
+                    current_branch_only=current_branch_only,
+                    tags=tags,
+                    depth=depth,
+                    git_event_log=git_event_log,
+                    manifest_name=spec.manifestName,
+                    this_manifest_only=False,
+                    outer_manifest=False,
+                )
+        # Lastly, if the manifest has a <superproject> then have the
+        # superproject sync it (if it will be used).
+        if git_superproject.UseSuperproject(use_superproject, self.manifest):
+            sync_result = self.manifest.superproject.Sync(git_event_log)
+            if not sync_result.success:
+                submanifest = ""
+                if self.manifest.path_prefix:
+                    submanifest = f"for {self.manifest.path_prefix} "
+                print(
+                    f"warning: git update of superproject {submanifest}failed, "
+                    "repo sync will not use superproject to fetch source; "
+                    "while this error is not fatal, and you can continue to "
+                    "run repo sync, please run repo init with the "
+                    "--no-use-superproject option to stop seeing this warning",
+                    file=sys.stderr,
+                )
+                if sync_result.fatal and use_superproject is not None:
+                    return False
+        return True
+    def _ConfigureDepth(self, depth):
+        """Configure the depth we'll sync down.
+        Args:
+            depth: an int, how deep of a partial clone to create.
+        """
+        # Opt.depth will be non-None if user actually passed --depth to repo
+        # init.
+        if depth is not None:
+            if depth > 0:
+                # Positive values will set the depth.
+                depth = str(depth)
+            else:
+                # Negative numbers will clear the depth; passing None to
+                # SetString will do that.
+                depth = None
+            # We store the depth in the main manifest project.
+            self.config.SetString("repo.depth", depth)
diff --git a/release/sign-launcher.py b/release/sign-launcher.py
index ffe23cc5..86566122 100755
--- a/release/sign-launcher.py
+++ b/release/sign-launcher.py
@@ -28,43 +28,56 @@ import util
 def sign(opts):
-  """Sign the launcher!"""
+    """Sign the launcher!"""
-  output = ''
+    output = ""
-  for key in opts.keys:
+    for key in opts.keys:
-    # We use ! at the end of the key so that gpg uses this specific key.
+        # We use ! at the end of the key so that gpg uses this specific key.
-    # Otherwise it uses the key as a lookup into the overall key and uses the
+        # Otherwise it uses the key as a lookup into the overall key and uses
-    # default signing key.  i.e. It will see that KEYID_RSA is a subkey of
+        # the default signing key.  i.e. It will see that KEYID_RSA is a subkey
-    # another key, and use the primary key to sign instead of the subkey.
+        # of another key, and use the primary key to sign instead of the subkey.
-    cmd = ['gpg', '--homedir', opts.gpgdir, '-u', f'{key}!', '--batch', '--yes',
+        cmd = [
-           '--armor', '--detach-sign', '--output', '-', opts.launcher]
+            "gpg",
-    ret = util.run(opts, cmd, encoding='utf-8', stdout=subprocess.PIPE)
+            "--homedir",
-    output += ret.stdout
+            opts.gpgdir,
+            "-u",
-  # Save the combined signatures into one file.
+            f"{key}!",
-  with open(f'{opts.launcher}.asc', 'w', encoding='utf-8') as fp:
+            "--batch",
-    fp.write(output)
+            "--yes",
+            "--armor",
+            "--detach-sign",
+            "--output",
+            "-",
+            opts.launcher,
+        ]
+        ret = util.run(opts, cmd, encoding="utf-8", stdout=subprocess.PIPE)
+        output += ret.stdout
+    # Save the combined signatures into one file.
+    with open(f"{opts.launcher}.asc", "w", encoding="utf-8") as fp:
+        fp.write(output)
 def check(opts):
-  """Check the signature."""
+    """Check the signature."""
-  util.run(opts, ['gpg', '--verify', f'{opts.launcher}.asc'])
+    util.run(opts, ["gpg", "--verify", f"{opts.launcher}.asc"])
 def get_version(opts):
-  """Get the version from |launcher|."""
+    """Get the version from |launcher|."""
-  # Make sure we don't search $PATH when signing the "repo" file in the cwd.
+    # Make sure we don't search $PATH when signing the "repo" file in the cwd.
-  launcher = os.path.join('.', opts.launcher)
+    launcher = os.path.join(".", opts.launcher)
-  cmd = [launcher, '--version']
+    cmd = [launcher, "--version"]
-  ret = util.run(opts, cmd, encoding='utf-8', stdout=subprocess.PIPE)
+    ret = util.run(opts, cmd, encoding="utf-8", stdout=subprocess.PIPE)
-  m = re.search(r'repo launcher version ([0-9.]+)', ret.stdout)
+    m = re.search(r"repo launcher version ([0-9.]+)", ret.stdout)
-  if not m:
+    if not m:
-    sys.exit(f'{opts.launcher}: unable to detect repo version')
+        sys.exit(f"{opts.launcher}: unable to detect repo version")
-  return m.group(1)
+    return m.group(1)
 def postmsg(opts, version):
-  """Helpful info to show at the end for release manager."""
+    """Helpful info to show at the end for release manager."""
-  print(f"""
+    print(
+        f"""
 Repo launcher bucket:
  gs://git-repo-downloads/
@@ -81,55 +94,72 @@ NB: If a rollback is necessary, the GS bucket archives old versions, and may be
  gsutil ls -la gs://git-repo-downloads/repo gs://git-repo-downloads/repo.asc
  gsutil cp -a public-read gs://git-repo-downloads/repo#<unique id> gs://git-repo-downloads/repo
  gsutil cp -a public-read gs://git-repo-downloads/repo.asc#<unique id> gs://git-repo-downloads/repo.asc
-""")
+"""  # noqa: E501
+    )
 def get_parser():
-  """Get a CLI parser."""
+    """Get a CLI parser."""
-  parser = argparse.ArgumentParser(description=__doc__)
+    parser = argparse.ArgumentParser(description=__doc__)
-  parser.add_argument('-n', '--dry-run',
+    parser.add_argument(
-                      dest='dryrun', action='store_true',
+        "-n",
-                      help='show everything that would be done')
+        "--dry-run",
-  parser.add_argument('--gpgdir',
+        dest="dryrun",
-                      default=os.path.join(util.HOMEDIR, '.gnupg', 'repo'),
+        action="store_true",
-                      help='path to dedicated gpg dir with release keys '
+        help="show everything that would be done",
-                           '(default: ~/.gnupg/repo/)')
+    )
-  parser.add_argument('--keyid', dest='keys', default=[], action='append',
+    parser.add_argument(
-                      help='alternative signing keys to use')
+        "--gpgdir",
-  parser.add_argument('launcher',
+        default=os.path.join(util.HOMEDIR, ".gnupg", "repo"),
-                      default=os.path.join(util.TOPDIR, 'repo'), nargs='?',
+        help="path to dedicated gpg dir with release keys "
-                      help='the launcher script to sign')
+        "(default: ~/.gnupg/repo/)",
-  return parser
+    )
+    parser.add_argument(
+        "--keyid",
+        dest="keys",
+        default=[],
+        action="append",
+        help="alternative signing keys to use",
+    )
+    parser.add_argument(
+        "launcher",
+        default=os.path.join(util.TOPDIR, "repo"),
+        nargs="?",
+        help="the launcher script to sign",
+    )
+    return parser
 def main(argv):
-  """The main func!"""
+    """The main func!"""
-  parser = get_parser()
+    parser = get_parser()
-  opts = parser.parse_args(argv)
+    opts = parser.parse_args(argv)
-  if not os.path.exists(opts.gpgdir):
+    if not os.path.exists(opts.gpgdir):
-    parser.error(f'--gpgdir does not exist: {opts.gpgdir}')
+        parser.error(f"--gpgdir does not exist: {opts.gpgdir}")
-  if not os.path.exists(opts.launcher):
+    if not os.path.exists(opts.launcher):
-    parser.error(f'launcher does not exist: {opts.launcher}')
+        parser.error(f"launcher does not exist: {opts.launcher}")
-  opts.launcher = os.path.relpath(opts.launcher)
+    opts.launcher = os.path.relpath(opts.launcher)
-  print(f'Signing "{opts.launcher}" launcher script and saving to '
+    print(
-        f'"{opts.launcher}.asc"')
+        f'Signing "{opts.launcher}" launcher script and saving to '
+        f'"{opts.launcher}.asc"'
-  if opts.keys:
+    )
-    print(f'Using custom keys to sign: {" ".join(opts.keys)}')
-  else:
+    if opts.keys:
-    print('Using official Repo release keys to sign')
+        print(f'Using custom keys to sign: {" ".join(opts.keys)}')
-    opts.keys = [util.KEYID_DSA, util.KEYID_RSA, util.KEYID_ECC]
+    else:
-    util.import_release_key(opts)
+        print("Using official Repo release keys to sign")
+        opts.keys = [util.KEYID_DSA, util.KEYID_RSA, util.KEYID_ECC]
-  version = get_version(opts)
+        util.import_release_key(opts)
-  sign(opts)
-  check(opts)
+    version = get_version(opts)
-  postmsg(opts, version)
+    sign(opts)
+    check(opts)
-  return 0
+    postmsg(opts, version)
+    return 0
-if __name__ == '__main__':
-  sys.exit(main(sys.argv[1:]))
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))
diff --git a/release/sign-tag.py b/release/sign-tag.py
index 605437c9..fbfe7b26 100755
--- a/release/sign-tag.py
+++ b/release/sign-tag.py
@@ -35,46 +35,61 @@ import util
 KEYID = util.KEYID_DSA
 # Regular expression to validate tag names.
-RE_VALID_TAG = r'^v([0-9]+[.])+[0-9]+$'
+RE_VALID_TAG = r"^v([0-9]+[.])+[0-9]+$"
 def sign(opts):
-  """Tag the commit & sign it!"""
+    """Tag the commit & sign it!"""
-  # We use ! at the end of the key so that gpg uses this specific key.
+    # We use ! at the end of the key so that gpg uses this specific key.
-  # Otherwise it uses the key as a lookup into the overall key and uses the
+    # Otherwise it uses the key as a lookup into the overall key and uses the
-  # default signing key.  i.e. It will see that KEYID_RSA is a subkey of
+    # default signing key.  i.e. It will see that KEYID_RSA is a subkey of
-  # another key, and use the primary key to sign instead of the subkey.
+    # another key, and use the primary key to sign instead of the subkey.
-  cmd = ['git', 'tag', '-s', opts.tag, '-u', f'{opts.key}!',
+    cmd = [
-         '-m', f'repo {opts.tag}', opts.commit]
+        "git",
+        "tag",
-  key = 'GNUPGHOME'
+        "-s",
-  print('+', f'export {key}="{opts.gpgdir}"')
+        opts.tag,
-  oldvalue = os.getenv(key)
+        "-u",
-  os.putenv(key, opts.gpgdir)
+        f"{opts.key}!",
-  util.run(opts, cmd)
+        "-m",
-  if oldvalue is None:
+        f"repo {opts.tag}",
-    os.unsetenv(key)
+        opts.commit,
-  else:
+    ]
-    os.putenv(key, oldvalue)
+    key = "GNUPGHOME"
+    print("+", f'export {key}="{opts.gpgdir}"')
+    oldvalue = os.getenv(key)
+    os.putenv(key, opts.gpgdir)
+    util.run(opts, cmd)
+    if oldvalue is None:
+        os.unsetenv(key)
+    else:
+        os.putenv(key, oldvalue)
 def check(opts):
-  """Check the signature."""
+    """Check the signature."""
-  util.run(opts, ['git', 'tag', '--verify', opts.tag])
+    util.run(opts, ["git", "tag", "--verify", opts.tag])
 def postmsg(opts):
-  """Helpful info to show at the end for release manager."""
+    """Helpful info to show at the end for release manager."""
-  cmd = ['git', 'rev-parse', 'remotes/origin/stable']
+    cmd = ["git", "rev-parse", "remotes/origin/stable"]
-  ret = util.run(opts, cmd, encoding='utf-8', stdout=subprocess.PIPE)
+    ret = util.run(opts, cmd, encoding="utf-8", stdout=subprocess.PIPE)
-  current_release = ret.stdout.strip()
+    current_release = ret.stdout.strip()
-  cmd = ['git', 'log', '--format=%h (%aN) %s', '--no-merges',
+    cmd = [
-         f'remotes/origin/stable..{opts.tag}']
+        "git",
-  ret = util.run(opts, cmd, encoding='utf-8', stdout=subprocess.PIPE)
+        "log",
-  shortlog = ret.stdout.strip()
+        "--format=%h (%aN) %s",
+        "--no-merges",
-  print(f"""
+        f"remotes/origin/stable..{opts.tag}",
+    ]
+    ret = util.run(opts, cmd, encoding="utf-8", stdout=subprocess.PIPE)
+    shortlog = ret.stdout.strip()
+    print(
+        f"""
 Here's the short log since the last release.
 {shortlog}
@@ -84,57 +99,69 @@ NB: People will start upgrading to this version immediately.
 To roll back a release:
  git push origin --force {current_release}:stable -n
-""")
+"""
+    )
 def get_parser():
-  """Get a CLI parser."""
+    """Get a CLI parser."""
-  parser = argparse.ArgumentParser(
+    parser = argparse.ArgumentParser(
-      description=__doc__,
+        description=__doc__,
-      formatter_class=argparse.RawDescriptionHelpFormatter)
+        formatter_class=argparse.RawDescriptionHelpFormatter,
-  parser.add_argument('-n', '--dry-run',
+    )
-                      dest='dryrun', action='store_true',
+    parser.add_argument(
-                      help='show everything that would be done')
+        "-n",
-  parser.add_argument('--gpgdir',
+        "--dry-run",
-                      default=os.path.join(util.HOMEDIR, '.gnupg', 'repo'),
+        dest="dryrun",
-                      help='path to dedicated gpg dir with release keys '
+        action="store_true",
-                           '(default: ~/.gnupg/repo/)')
+        help="show everything that would be done",
-  parser.add_argument('-f', '--force', action='store_true',
+    )
-                      help='force signing of any tag')
+    parser.add_argument(
-  parser.add_argument('--keyid', dest='key',
+        "--gpgdir",
-                      help='alternative signing key to use')
+        default=os.path.join(util.HOMEDIR, ".gnupg", "repo"),
-  parser.add_argument('tag',
+        help="path to dedicated gpg dir with release keys "
-                      help='the tag to create (e.g. "v2.0")')
+        "(default: ~/.gnupg/repo/)",
-  parser.add_argument('commit', default='HEAD', nargs='?',
+    )
-                      help='the commit to tag')
+    parser.add_argument(
-  return parser
+        "-f", "--force", action="store_true", help="force signing of any tag"
+    )
+    parser.add_argument(
+        "--keyid", dest="key", help="alternative signing key to use"
+    )
+    parser.add_argument("tag", help='the tag to create (e.g. "v2.0")')
+    parser.add_argument(
+        "commit", default="HEAD", nargs="?", help="the commit to tag"
+    )
+    return parser
 def main(argv):
-  """The main func!"""
+    """The main func!"""
-  parser = get_parser()
+    parser = get_parser()
-  opts = parser.parse_args(argv)
+    opts = parser.parse_args(argv)
-  if not os.path.exists(opts.gpgdir):
+    if not os.path.exists(opts.gpgdir):
-    parser.error(f'--gpgdir does not exist: {opts.gpgdir}')
+        parser.error(f"--gpgdir does not exist: {opts.gpgdir}")
-  if not opts.force and not re.match(RE_VALID_TAG, opts.tag):
+    if not opts.force and not re.match(RE_VALID_TAG, opts.tag):
-    parser.error(f'tag "{opts.tag}" does not match regex "{RE_VALID_TAG}"; '
+        parser.error(
-                 'use --force to sign anyways')
+            f'tag "{opts.tag}" does not match regex "{RE_VALID_TAG}"; '
+            "use --force to sign anyways"
+        )
-  if opts.key:
+    if opts.key:
-    print(f'Using custom key to sign: {opts.key}')
+        print(f"Using custom key to sign: {opts.key}")
-  else:
+    else:
-    print('Using official Repo release key to sign')
+        print("Using official Repo release key to sign")
-    opts.key = KEYID
+        opts.key = KEYID
-    util.import_release_key(opts)
+        util.import_release_key(opts)
-  sign(opts)
+    sign(opts)
-  check(opts)
+    check(opts)
-  postmsg(opts)
+    postmsg(opts)
-  return 0
+    return 0
-if __name__ == '__main__':
+if __name__ == "__main__":
-  sys.exit(main(sys.argv[1:]))
+    sys.exit(main(sys.argv[1:]))
diff --git a/release/update_manpages.py b/release/update_manpages.py
index d1bf8928..cd2acc01 100644
--- a/release/update_manpages.py
+++ b/release/update_manpages.py
@@ -29,91 +29,125 @@ import sys
 import tempfile
 TOPDIR = Path(__file__).resolve().parent.parent
-MANDIR = TOPDIR.joinpath('man')
+MANDIR = TOPDIR.joinpath("man")
 # Load repo local modules.
 sys.path.insert(0, str(TOPDIR))
 from git_command import RepoSourceVersion
 import subcmds
 def worker(cmd, **kwargs):
-  subprocess.run(cmd, **kwargs)
+    subprocess.run(cmd, **kwargs)
 def main(argv):
-  parser = argparse.ArgumentParser(description=__doc__)
+    parser = argparse.ArgumentParser(description=__doc__)
-  opts = parser.parse_args(argv)
+    parser.parse_args(argv)
-  if not shutil.which('help2man'):
+    if not shutil.which("help2man"):
-    sys.exit('Please install help2man to continue.')
+        sys.exit("Please install help2man to continue.")
-  # Let repo know we're generating man pages so it can avoid some dynamic
+    # Let repo know we're generating man pages so it can avoid some dynamic
-  # behavior (like probing active number of CPUs).  We use a weird name &
+    # behavior (like probing active number of CPUs).  We use a weird name &
-  # value to make it less likely for users to set this var themselves.
+    # value to make it less likely for users to set this var themselves.
-  os.environ['_REPO_GENERATE_MANPAGES_'] = ' indeed! '
+    os.environ["_REPO_GENERATE_MANPAGES_"] = " indeed! "
-  # "repo branch" is an alias for "repo branches".
+    # "repo branch" is an alias for "repo branches".
-  del subcmds.all_commands['branch']
+    del subcmds.all_commands["branch"]
-  (MANDIR / 'repo-branch.1').write_text('.so man1/repo-branches.1')
+    (MANDIR / "repo-branch.1").write_text(".so man1/repo-branches.1")
-  version = RepoSourceVersion()
+    version = RepoSourceVersion()
-  cmdlist = [['help2man', '-N', '-n', f'repo {cmd} - manual page for repo {cmd}',
+    cmdlist = [
-    '-S', f'repo {cmd}', '-m', 'Repo Manual', f'--version-string={version}',
+        [
-    '-o', MANDIR.joinpath(f'repo-{cmd}.1.tmp'), './repo',
+            "help2man",
-    '-h', f'help {cmd}'] for cmd in subcmds.all_commands]
+            "-N",
-  cmdlist.append(['help2man', '-N', '-n', 'repository management tool built on top of git',
+            "-n",
-    '-S', 'repo', '-m', 'Repo Manual', f'--version-string={version}',
+            f"repo {cmd} - manual page for repo {cmd}",
-    '-o', MANDIR.joinpath('repo.1.tmp'), './repo',
+            "-S",
-    '-h', '--help-all'])
+            f"repo {cmd}",
+            "-m",
-  with tempfile.TemporaryDirectory() as tempdir:
+            "Repo Manual",
-    tempdir = Path(tempdir)
+            f"--version-string={version}",
-    repo_dir = tempdir / '.repo'
+            "-o",
-    repo_dir.mkdir()
+            MANDIR.joinpath(f"repo-{cmd}.1.tmp"),
-    (repo_dir / 'repo').symlink_to(TOPDIR)
+            "./repo",
+            "-h",
-    # Create a repo wrapper using the active Python executable.  We can't pass
+            f"help {cmd}",
-    # this directly to help2man as it's too simple, so insert it via shebang.
+        ]
-    data = (TOPDIR / 'repo').read_text(encoding='utf-8')
+        for cmd in subcmds.all_commands
-    tempbin = tempdir / 'repo'
+    ]
-    tempbin.write_text(f'#!{sys.executable}\n' + data, encoding='utf-8')
+    cmdlist.append(
-    tempbin.chmod(0o755)
+        [
+            "help2man",
-    # Run all cmd in parallel, and wait for them to finish.
+            "-N",
-    with multiprocessing.Pool() as pool:
+            "-n",
-      pool.map(partial(worker, cwd=tempdir, check=True), cmdlist)
+            "repository management tool built on top of git",
+            "-S",
-  for tmp_path in MANDIR.glob('*.1.tmp'):
+            "repo",
-    path = tmp_path.parent / tmp_path.stem
+            "-m",
-    old_data = path.read_text() if path.exists() else ''
+            "Repo Manual",
+            f"--version-string={version}",
-    data = tmp_path.read_text()
+            "-o",
-    tmp_path.unlink()
+            MANDIR.joinpath("repo.1.tmp"),
+            "./repo",
-    data = replace_regex(data)
+            "-h",
+            "--help-all",
-    # If the only thing that changed was the date, don't refresh.  This avoids
+        ]
-    # a lot of noise when only one file actually updates.
+    )
-    old_data = re.sub(r'^(\.TH REPO "1" ")([^"]+)', r'\1', old_data, flags=re.M)
-    new_data = re.sub(r'^(\.TH REPO "1" ")([^"]+)', r'\1', data, flags=re.M)
+    with tempfile.TemporaryDirectory() as tempdir:
-    if old_data != new_data:
+        tempdir = Path(tempdir)
-      path.write_text(data)
+        repo_dir = tempdir / ".repo"
+        repo_dir.mkdir()
+        (repo_dir / "repo").symlink_to(TOPDIR)
+        # Create a repo wrapper using the active Python executable.  We can't
+        # pass this directly to help2man as it's too simple, so insert it via
+        # shebang.
+        data = (TOPDIR / "repo").read_text(encoding="utf-8")
+        tempbin = tempdir / "repo"
+        tempbin.write_text(f"#!{sys.executable}\n" + data, encoding="utf-8")
+        tempbin.chmod(0o755)
+        # Run all cmd in parallel, and wait for them to finish.
+        with multiprocessing.Pool() as pool:
+            pool.map(partial(worker, cwd=tempdir, check=True), cmdlist)
+    for tmp_path in MANDIR.glob("*.1.tmp"):
+        path = tmp_path.parent / tmp_path.stem
+        old_data = path.read_text() if path.exists() else ""
+        data = tmp_path.read_text()
+        tmp_path.unlink()
+        data = replace_regex(data)
+        # If the only thing that changed was the date, don't refresh.  This
+        # avoids a lot of noise when only one file actually updates.
+        old_data = re.sub(
+            r'^(\.TH REPO "1" ")([^"]+)', r"\1", old_data, flags=re.M
+        )
+        new_data = re.sub(r'^(\.TH REPO "1" ")([^"]+)', r"\1", data, flags=re.M)
+        if old_data != new_data:
+            path.write_text(data)
 def replace_regex(data):
-  """Replace semantically null regexes in the data.
+    """Replace semantically null regexes in the data.
-  Args:
+    Args:
-    data: manpage text.
+        data: manpage text.
-  Returns:
+    Returns:
-    Updated manpage text.
+        Updated manpage text.
-  """
+    """
-  regex = (
+    regex = (
-      (r'(It was generated by help2man) [0-9.]+', r'\g<1>.'),
+        (r"(It was generated by help2man) [0-9.]+", r"\g<1>."),
-      (r'^\033\[[0-9;]*m([^\033]*)\033\[m', r'\g<1>'),
+        (r"^\033\[[0-9;]*m([^\033]*)\033\[m", r"\g<1>"),
-      (r'^\.IP\n(.*:)\n', r'.SS \g<1>\n'),
+        (r"^\.IP\n(.*:)\n", r".SS \g<1>\n"),
-      (r'^\.PP\nDescription', r'.SH DETAILS'),
+        (r"^\.PP\nDescription", r".SH DETAILS"),
-  )
+    )
-  for pattern, replacement in regex:
+    for pattern, replacement in regex:
-    data = re.sub(pattern, replacement, data, flags=re.M)
+        data = re.sub(pattern, replacement, data, flags=re.M)
-  return data
+    return data
diff --git a/release/util.py b/release/util.py
index 9d0eb1dc..df7a5638 100644
--- a/release/util.py
+++ b/release/util.py
@@ -20,54 +20,60 @@ import subprocess
 import sys
-assert sys.version_info >= (3, 6), 'This module requires Python 3.6+'
+assert sys.version_info >= (3, 6), "This module requires Python 3.6+"
 TOPDIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-HOMEDIR = os.path.expanduser('~')
+HOMEDIR = os.path.expanduser("~")
 # These are the release keys we sign with.
-KEYID_DSA = '8BB9AD793E8E6153AF0F9A4416530D5E920F5C65'
+KEYID_DSA = "8BB9AD793E8E6153AF0F9A4416530D5E920F5C65"
-KEYID_RSA = 'A34A13BE8E76BFF46A0C022DA2E75A824AAB9624'
+KEYID_RSA = "A34A13BE8E76BFF46A0C022DA2E75A824AAB9624"
-KEYID_ECC = 'E1F9040D7A3F6DAFAC897CD3D3B95DA243E48A39'
+KEYID_ECC = "E1F9040D7A3F6DAFAC897CD3D3B95DA243E48A39"
 def cmdstr(cmd):
-  """Get a nicely quoted shell command."""
+    """Get a nicely quoted shell command."""
-  ret = []
+    ret = []
-  for arg in cmd:
+    for arg in cmd:
-    if not re.match(r'^[a-zA-Z0-9/_.=-]+$', arg):
+        if not re.match(r"^[a-zA-Z0-9/_.=-]+$", arg):
-      arg = f'"{arg}"'
+            arg = f'"{arg}"'
-    ret.append(arg)
+        ret.append(arg)
-  return ' '.join(ret)
+    return " ".join(ret)
 def run(opts, cmd, check=True, **kwargs):
-  """Helper around subprocess.run to include logging."""
+    """Helper around subprocess.run to include logging."""
-  print('+', cmdstr(cmd))
+    print("+", cmdstr(cmd))
-  if opts.dryrun:
+    if opts.dryrun:
-    cmd = ['true', '--'] + cmd
+        cmd = ["true", "--"] + cmd
-  try:
+    try:
-    return subprocess.run(cmd, check=check, **kwargs)
+        return subprocess.run(cmd, check=check, **kwargs)
-  except subprocess.CalledProcessError as e:
+    except subprocess.CalledProcessError as e:
-    print(f'aborting: {e}', file=sys.stderr)
+        print(f"aborting: {e}", file=sys.stderr)
-    sys.exit(1)
+        sys.exit(1)
 def import_release_key(opts):
-  """Import the public key of the official release repo signing key."""
+    """Import the public key of the official release repo signing key."""
-  # Extract the key from our repo launcher.
+    # Extract the key from our repo launcher.
-  launcher = getattr(opts, 'launcher', os.path.join(TOPDIR, 'repo'))
+    launcher = getattr(opts, "launcher", os.path.join(TOPDIR, "repo"))
-  print(f'Importing keys from "{launcher}" launcher script')
+    print(f'Importing keys from "{launcher}" launcher script')
-  with open(launcher, encoding='utf-8') as fp:
+    with open(launcher, encoding="utf-8") as fp:
-    data = fp.read()
+        data = fp.read()
-  keys = re.findall(
+    keys = re.findall(
-      r'\n-----BEGIN PGP PUBLIC KEY BLOCK-----\n[^-]*'
+        r"\n-----BEGIN PGP PUBLIC KEY BLOCK-----\n[^-]*"
-      r'\n-----END PGP PUBLIC KEY BLOCK-----\n', data, flags=re.M)
+        r"\n-----END PGP PUBLIC KEY BLOCK-----\n",
-  run(opts, ['gpg', '--import'], input='\n'.join(keys).encode('utf-8'))
+        data,
+        flags=re.M,
-  print('Marking keys as fully trusted')
+    )
-  run(opts, ['gpg', '--import-ownertrust'],
+    run(opts, ["gpg", "--import"], input="\n".join(keys).encode("utf-8"))
-      input=f'{KEYID_DSA}:6:\n'.encode('utf-8'))
+    print("Marking keys as fully trusted")
+    run(
+        opts,
+        ["gpg", "--import-ownertrust"],
+        input=f"{KEYID_DSA}:6:\n".encode("utf-8"),
+    )
diff --git a/repo b/repo
index ce3df054..c32e52da 100755
--- a/repo
+++ b/repo
@@ -506,10 +506,10 @@ def gitc_parse_clientdir(gitc_fs_path):
  """Parse a path in the GITC FS and return its client name.
  Args:
-    gitc_fs_path: A subdirectory path within the GITC_FS_ROOT_DIR.
+      gitc_fs_path: A subdirectory path within the GITC_FS_ROOT_DIR.
  Returns:
-    The GITC client name.
+      The GITC client name.
  """
  if gitc_fs_path == GITC_FS_ROOT_DIR:
    return None
@@ -942,14 +942,14 @@ def resolve_repo_rev(cwd, committish):
  * xxx: Branch or tag or commit.
  Args:
-    cwd: The git checkout to run in.
+      cwd: The git checkout to run in.
-    committish: The REPO_REV argument to resolve.
+      committish: The REPO_REV argument to resolve.
  Returns:
-    A tuple of (remote ref, commit) as makes sense for the committish.
+      A tuple of (remote ref, commit) as makes sense for the committish.
-    For branches, this will look like ('refs/heads/stable', <revision>).
+      For branches, this will look like ('refs/heads/stable', <revision>).
-    For tags, this will look like ('refs/tags/v1.0', <revision>).
+      For tags, this will look like ('refs/tags/v1.0', <revision>).
-    For commits, this will be (<revision>, <revision>).
+      For commits, this will be (<revision>, <revision>).
  """
  def resolve(committish):
    ret = run_git('rev-parse', '--verify', '%s^{commit}' % (committish,),
@@ -1104,7 +1104,7 @@ class Requirements(object):
    """Initialize.
    Args:
-      requirements: A dictionary of settings.
+        requirements: A dictionary of settings.
    """
    self.requirements = requirements
diff --git a/repo_trace.py b/repo_trace.py
index 1ba86c79..49462174 100644
--- a/repo_trace.py
+++ b/repo_trace.py
@@ -29,138 +29,142 @@ from contextlib import ContextDecorator
 import platform_utils
 # Env var to implicitly turn on tracing.
-REPO_TRACE = 'REPO_TRACE'
+REPO_TRACE = "REPO_TRACE"
 # Temporarily set tracing to always on unless user expicitly sets to 0.
-_TRACE = os.environ.get(REPO_TRACE) != '0'
+_TRACE = os.environ.get(REPO_TRACE) != "0"
 _TRACE_TO_STDERR = False
 _TRACE_FILE = None
-_TRACE_FILE_NAME = 'TRACE_FILE'
+_TRACE_FILE_NAME = "TRACE_FILE"
 _MAX_SIZE = 70  # in MiB
-_NEW_COMMAND_SEP = '+++++++++++++++NEW COMMAND+++++++++++++++++++'
+_NEW_COMMAND_SEP = "+++++++++++++++NEW COMMAND+++++++++++++++++++"
 def IsTraceToStderr():
-  """Whether traces are written to stderr."""
+    """Whether traces are written to stderr."""
-  return _TRACE_TO_STDERR
+    return _TRACE_TO_STDERR
 def IsTrace():
-  """Whether tracing is enabled."""
+    """Whether tracing is enabled."""
-  return _TRACE
+    return _TRACE
 def SetTraceToStderr():
-  """Enables tracing logging to stderr."""
+    """Enables tracing logging to stderr."""
-  global _TRACE_TO_STDERR
+    global _TRACE_TO_STDERR
-  _TRACE_TO_STDERR = True
+    _TRACE_TO_STDERR = True
 def SetTrace():
-  """Enables tracing."""
+    """Enables tracing."""
-  global _TRACE
+    global _TRACE
-  _TRACE = True
+    _TRACE = True
 def _SetTraceFile(quiet):
-  """Sets the trace file location."""
+    """Sets the trace file location."""
-  global _TRACE_FILE
+    global _TRACE_FILE
-  _TRACE_FILE = _GetTraceFile(quiet)
+    _TRACE_FILE = _GetTraceFile(quiet)
 class Trace(ContextDecorator):
-  """Used to capture and save git traces."""
+    """Used to capture and save git traces."""
-  def _time(self):
+    def _time(self):
-    """Generate nanoseconds of time in a py3.6 safe way"""
+        """Generate nanoseconds of time in a py3.6 safe way"""
-    return int(time.time() * 1e+9)
+        return int(time.time() * 1e9)
-  def __init__(self, fmt, *args, first_trace=False, quiet=True):
+    def __init__(self, fmt, *args, first_trace=False, quiet=True):
-    """Initialize the object.
+        """Initialize the object.
-    Args:
+        Args:
-      fmt: The format string for the trace.
+            fmt: The format string for the trace.
-      *args: Arguments to pass to formatting.
+            *args: Arguments to pass to formatting.
-      first_trace: Whether this is the first trace of a `repo` invocation.
+            first_trace: Whether this is the first trace of a `repo` invocation.
-      quiet: Whether to suppress notification of trace file location.
+            quiet: Whether to suppress notification of trace file location.
-    """
+        """
-    if not IsTrace():
+        if not IsTrace():
-      return
+            return
-    self._trace_msg = fmt % args
+        self._trace_msg = fmt % args
-    if not _TRACE_FILE:
+        if not _TRACE_FILE:
-      _SetTraceFile(quiet)
+            _SetTraceFile(quiet)
-    if first_trace:
+        if first_trace:
-      _ClearOldTraces()
+            _ClearOldTraces()
-      self._trace_msg = f'{_NEW_COMMAND_SEP} {self._trace_msg}'
+            self._trace_msg = f"{_NEW_COMMAND_SEP} {self._trace_msg}"
-  def __enter__(self):
+    def __enter__(self):
-    if not IsTrace():
+        if not IsTrace():
-      return self
+            return self
-    print_msg = f'PID: {os.getpid()} START: {self._time()} :{self._trace_msg}\n'
+        print_msg = (
+            f"PID: {os.getpid()} START: {self._time()} :{self._trace_msg}\n"
+        )
-    with open(_TRACE_FILE, 'a') as f:
+        with open(_TRACE_FILE, "a") as f:
-      print(print_msg, file=f)
+            print(print_msg, file=f)
-    if _TRACE_TO_STDERR:
+        if _TRACE_TO_STDERR:
-      print(print_msg, file=sys.stderr)
+            print(print_msg, file=sys.stderr)
-    return self
+        return self
-  def __exit__(self, *exc):
+    def __exit__(self, *exc):
-    if not IsTrace():
+        if not IsTrace():
-      return False
+            return False
-    print_msg = f'PID: {os.getpid()} END: {self._time()} :{self._trace_msg}\n'
+        print_msg = (
+            f"PID: {os.getpid()} END: {self._time()} :{self._trace_msg}\n"
+        )
-    with open(_TRACE_FILE, 'a') as f:
+        with open(_TRACE_FILE, "a") as f:
-      print(print_msg, file=f)
+            print(print_msg, file=f)
-    if _TRACE_TO_STDERR:
+        if _TRACE_TO_STDERR:
-      print(print_msg, file=sys.stderr)
+            print(print_msg, file=sys.stderr)
-    return False
+        return False
 def _GetTraceFile(quiet):
-  """Get the trace file or create one."""
+    """Get the trace file or create one."""
-  # TODO: refactor to pass repodir to Trace.
+    # TODO: refactor to pass repodir to Trace.
-  repo_dir = os.path.dirname(os.path.dirname(__file__))
+    repo_dir = os.path.dirname(os.path.dirname(__file__))
-  trace_file = os.path.join(repo_dir, _TRACE_FILE_NAME)
+    trace_file = os.path.join(repo_dir, _TRACE_FILE_NAME)
-  if not quiet:
+    if not quiet:
-    print(f'Trace outputs in {trace_file}', file=sys.stderr)
+        print(f"Trace outputs in {trace_file}", file=sys.stderr)
-  return trace_file
+    return trace_file
 def _ClearOldTraces():
-  """Clear the oldest commands if trace file is too big."""
+    """Clear the oldest commands if trace file is too big."""
-  try:
+    try:
-    with open(_TRACE_FILE, 'r', errors='ignore') as f:
+        with open(_TRACE_FILE, "r", errors="ignore") as f:
-      if os.path.getsize(f.name) / (1024 * 1024) <= _MAX_SIZE:
+            if os.path.getsize(f.name) / (1024 * 1024) <= _MAX_SIZE:
+                return
+            trace_lines = f.readlines()
+    except FileNotFoundError:
        return
-      trace_lines = f.readlines()
-  except FileNotFoundError:
+    while sum(len(x) for x in trace_lines) / (1024 * 1024) > _MAX_SIZE:
-    return
+        for i, line in enumerate(trace_lines):
+            if "END:" in line and _NEW_COMMAND_SEP in line:
-  while sum(len(x) for x in trace_lines) / (1024 * 1024) > _MAX_SIZE:
+                trace_lines = trace_lines[i + 1 :]
-    for i, line in enumerate(trace_lines):
+                break
-      if 'END:' in line and _NEW_COMMAND_SEP in line:
+        else:
-        trace_lines = trace_lines[i + 1:]
+            # The last chunk is bigger than _MAX_SIZE, so just throw everything
-        break
+            # away.
-    else:
+            trace_lines = []
-      # The last chunk is bigger than _MAX_SIZE, so just throw everything away.
-      trace_lines = []
+    while trace_lines and trace_lines[-1] == "\n":
+        trace_lines = trace_lines[:-1]
-  while trace_lines and trace_lines[-1] == '\n':
+    # Write to a temporary file with a unique name in the same filesystem
-    trace_lines = trace_lines[:-1]
+    # before replacing the original trace file.
-  # Write to a temporary file with a unique name in the same filesystem
+    temp_dir, temp_prefix = os.path.split(_TRACE_FILE)
-  # before replacing the original trace file.
+    with tempfile.NamedTemporaryFile(
-  temp_dir, temp_prefix = os.path.split(_TRACE_FILE)
+        "w", dir=temp_dir, prefix=temp_prefix, delete=False
-  with tempfile.NamedTemporaryFile('w',
+    ) as f:
-                                   dir=temp_dir,
+        f.writelines(trace_lines)
-                                   prefix=temp_prefix,
+    platform_utils.rename(f.name, _TRACE_FILE)
-                                   delete=False) as f:
-    f.writelines(trace_lines)
-  platform_utils.rename(f.name, _TRACE_FILE)
diff --git a/run_tests b/run_tests
index 0ea098a6..e76f9d8c 100755
--- a/run_tests
+++ b/run_tests
@@ -13,10 +13,28 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
-"""Wrapper to run pytest with the right settings."""
+"""Wrapper to run black and pytest with the right settings."""
+import os
+import subprocess
 import sys
 import pytest
-if __name__ == '__main__':
-  sys.exit(pytest.main(sys.argv[1:]))
+def run_black():
+    """Returns the exit code of running `black --check`."""
+    dirpath = os.path.dirname(os.path.realpath(__file__))
+    return subprocess.run(
+        [sys.executable, "-m", "black", "--check", dirpath], check=False
+    ).returncode
+def main(argv):
+    """The main entry."""
+    black_ret = 0 if argv else run_black()
+    pytest_ret = pytest.main(argv)
+    return 0 if not black_ret and not pytest_ret else 1
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))
diff --git a/run_tests.vpython3 b/run_tests.vpython3
index d0e821dd..0c790bca 100644
--- a/run_tests.vpython3
+++ b/run_tests.vpython3
@@ -26,8 +26,8 @@ wheel: <
 # Required by pytest==6.2.2
 wheel: <
-  name: "infra/python/wheels/packaging-py2_py3"
+  name: "infra/python/wheels/packaging-py3"
-  version: "version:16.8"
+  version: "version:23.0"
 >
 # Required by pytest==6.2.2
@@ -59,3 +59,44 @@ wheel: <
  name: "infra/python/wheels/six-py2_py3"
  version: "version:1.16.0"
 >
+wheel: <
+  name: "infra/python/wheels/black-py3"
+  version: "version:23.1.0"
+>
+# Required by black==23.1.0
+wheel: <
+  name: "infra/python/wheels/mypy-extensions-py3"
+  version: "version:0.4.3"
+>
+# Required by black==23.1.0
+wheel: <
+  name: "infra/python/wheels/tomli-py3"
+  version: "version:2.0.1"
+>
+# Required by black==23.1.0
+wheel: <
+  name: "infra/python/wheels/platformdirs-py3"
+  version: "version:2.5.2"
+>
+# Required by black==23.1.0
+wheel: <
+  name: "infra/python/wheels/pathspec-py3"
+  version: "version:0.9.0"
+>
+# Required by black==23.1.0
+wheel: <
+  name: "infra/python/wheels/typing-extensions-py3"
+  version: "version:4.3.0"
+>
+# Required by black==23.1.0
+wheel: <
+  name: "infra/python/wheels/click-py3"
+  version: "version:8.0.3"
+>
diff --git a/setup.py b/setup.py
index 848b3f60..f50eb473 100755
--- a/setup.py
+++ b/setup.py
@@ -23,39 +23,39 @@ TOPDIR = os.path.dirname(os.path.abspath(__file__))
 # Rip out the first intro paragraph.
-with open(os.path.join(TOPDIR, 'README.md')) as fp:
+with open(os.path.join(TOPDIR, "README.md")) as fp:
    lines = fp.read().splitlines()[2:]
-    end = lines.index('')
+    end = lines.index("")
-    long_description = ' '.join(lines[0:end])
+    long_description = " ".join(lines[0:end])
 # https://packaging.python.org/tutorials/packaging-projects/
 setuptools.setup(
-    name='repo',
+    name="repo",
-    version='2',
+    version="2",
-    maintainer='Various',
+    maintainer="Various",
-    maintainer_email='repo-discuss@googlegroups.com',
+    maintainer_email="repo-discuss@googlegroups.com",
-    description='Repo helps manage many Git repositories',
+    description="Repo helps manage many Git repositories",
    long_description=long_description,
-    long_description_content_type='text/plain',
+    long_description_content_type="text/plain",
-    url='https://gerrit.googlesource.com/git-repo/',
+    url="https://gerrit.googlesource.com/git-repo/",
    project_urls={
-        'Bug Tracker': 'https://bugs.chromium.org/p/gerrit/issues/list?q=component:Applications%3Erepo',
+        "Bug Tracker": "https://bugs.chromium.org/p/gerrit/issues/list?q=component:Applications%3Erepo",  # noqa: E501
    },
    # https://pypi.org/classifiers/
    classifiers=[
-        'Development Status :: 6 - Mature',
+        "Development Status :: 6 - Mature",
-        'Environment :: Console',
+        "Environment :: Console",
-        'Intended Audience :: Developers',
+        "Intended Audience :: Developers",
-        'License :: OSI Approved :: Apache Software License',
+        "License :: OSI Approved :: Apache Software License",
-        'Natural Language :: English',
+        "Natural Language :: English",
-        'Operating System :: MacOS :: MacOS X',
+        "Operating System :: MacOS :: MacOS X",
-        'Operating System :: Microsoft :: Windows :: Windows 10',
+        "Operating System :: Microsoft :: Windows :: Windows 10",
-        'Operating System :: POSIX :: Linux',
+        "Operating System :: POSIX :: Linux",
-        'Programming Language :: Python :: 3',
+        "Programming Language :: Python :: 3",
-        'Programming Language :: Python :: 3 :: Only',
+        "Programming Language :: Python :: 3 :: Only",
-        'Topic :: Software Development :: Version Control :: Git',
+        "Topic :: Software Development :: Version Control :: Git",
    ],
-    python_requires='>=3.6',
+    python_requires=">=3.6",
-    packages=['subcmds'],
+    packages=["subcmds"],
 )
diff --git a/ssh.py b/ssh.py
index 004fdbad..1d7ebe32 100644
--- a/ssh.py
+++ b/ssh.py
@@ -28,254 +28,264 @@ import platform_utils
 from repo_trace import Trace
-PROXY_PATH = os.path.join(os.path.dirname(__file__), 'git_ssh')
+PROXY_PATH = os.path.join(os.path.dirname(__file__), "git_ssh")
 def _run_ssh_version():
-  """run ssh -V to display the version number"""
+    """run ssh -V to display the version number"""
-  return subprocess.check_output(['ssh', '-V'], stderr=subprocess.STDOUT).decode()
+    return subprocess.check_output(
+        ["ssh", "-V"], stderr=subprocess.STDOUT
+    ).decode()
 def _parse_ssh_version(ver_str=None):
-  """parse a ssh version string into a tuple"""
+    """parse a ssh version string into a tuple"""
-  if ver_str is None:
+    if ver_str is None:
-    ver_str = _run_ssh_version()
+        ver_str = _run_ssh_version()
-  m = re.match(r'^OpenSSH_([0-9.]+)(p[0-9]+)?\s', ver_str)
+    m = re.match(r"^OpenSSH_([0-9.]+)(p[0-9]+)?\s", ver_str)
-  if m:
+    if m:
-    return tuple(int(x) for x in m.group(1).split('.'))
+        return tuple(int(x) for x in m.group(1).split("."))
-  else:
+    else:
-    return ()
+        return ()
 @functools.lru_cache(maxsize=None)
 def version():
-  """return ssh version as a tuple"""
+    """return ssh version as a tuple"""
-  try:
-    return _parse_ssh_version()
-  except FileNotFoundError:
-    print('fatal: ssh not installed', file=sys.stderr)
-    sys.exit(1)
-  except subprocess.CalledProcessError:
-    print('fatal: unable to detect ssh version', file=sys.stderr)
-    sys.exit(1)
-URI_SCP = re.compile(r'^([^@:]*@?[^:/]{1,}):')
-URI_ALL = re.compile(r'^([a-z][a-z+-]*)://([^@/]*@?[^/]*)/')
-class ProxyManager:
-  """Manage various ssh clients & masters that we spawn.
-  This will take care of sharing state between multiprocessing children, and
-  make sure that if we crash, we don't leak any of the ssh sessions.
-  The code should work with a single-process scenario too, and not add too much
-  overhead due to the manager.
-  """
-  # Path to the ssh program to run which will pass our master settings along.
-  # Set here more as a convenience API.
-  proxy = PROXY_PATH
-  def __init__(self, manager):
-    # Protect access to the list of active masters.
-    self._lock = multiprocessing.Lock()
-    # List of active masters (pid).  These will be spawned on demand, and we are
-    # responsible for shutting them all down at the end.
-    self._masters = manager.list()
-    # Set of active masters indexed by "host:port" information.
-    # The value isn't used, but multiprocessing doesn't provide a set class.
-    self._master_keys = manager.dict()
-    # Whether ssh masters are known to be broken, so we give up entirely.
-    self._master_broken = manager.Value('b', False)
-    # List of active ssh sesssions.  Clients will be added & removed as
-    # connections finish, so this list is just for safety & cleanup if we crash.
-    self._clients = manager.list()
-    # Path to directory for holding master sockets.
-    self._sock_path = None
-  def __enter__(self):
-    """Enter a new context."""
-    return self
-  def __exit__(self, exc_type, exc_value, traceback):
-    """Exit a context & clean up all resources."""
-    self.close()
-  def add_client(self, proc):
-    """Track a new ssh session."""
-    self._clients.append(proc.pid)
-  def remove_client(self, proc):
-    """Remove a completed ssh session."""
    try:
-      self._clients.remove(proc.pid)
+        return _parse_ssh_version()
-    except ValueError:
+    except FileNotFoundError:
-      pass
+        print("fatal: ssh not installed", file=sys.stderr)
+        sys.exit(1)
-  def add_master(self, proc):
+    except subprocess.CalledProcessError:
-    """Track a new master connection."""
+        print("fatal: unable to detect ssh version", file=sys.stderr)
-    self._masters.append(proc.pid)
+        sys.exit(1)
-  def _terminate(self, procs):
-    """Kill all |procs|."""
-    for pid in procs:
-      try:
-        os.kill(pid, signal.SIGTERM)
-        os.waitpid(pid, 0)
-      except OSError:
-        pass
-    # The multiprocessing.list() API doesn't provide many standard list()
-    # methods, so we have to manually clear the list.
-    while True:
-      try:
-        procs.pop(0)
-      except:
-        break
-  def close(self):
-    """Close this active ssh session.
-    Kill all ssh clients & masters we created, and nuke the socket dir.
-    """
-    self._terminate(self._clients)
-    self._terminate(self._masters)
-    d = self.sock(create=False)
-    if d:
-      try:
-        platform_utils.rmdir(os.path.dirname(d))
-      except OSError:
-        pass
-  def _open_unlocked(self, host, port=None):
-    """Make sure a ssh master session exists for |host| & |port|.
-    If one doesn't exist already, we'll create it.
-    We won't grab any locks, so the caller has to do that.  This helps keep the
+URI_SCP = re.compile(r"^([^@:]*@?[^:/]{1,}):")
-    business logic of actually creating the master separate from grabbing locks.
+URI_ALL = re.compile(r"^([a-z][a-z+-]*)://([^@/]*@?[^/]*)/")
-    """
-    # Check to see whether we already think that the master is running; if we
-    # think it's already running, return right away.
-    if port is not None:
-      key = '%s:%s' % (host, port)
-    else:
-      key = host
-    if key in self._master_keys:
-      return True
-    if self._master_broken.value or 'GIT_SSH' in os.environ:
-      # Failed earlier, so don't retry.
-      return False
-    # We will make two calls to ssh; this is the common part of both calls.
-    command_base = ['ssh', '-o', 'ControlPath %s' % self.sock(), host]
-    if port is not None:
-      command_base[1:1] = ['-p', str(port)]
-    # Since the key wasn't in _master_keys, we think that master isn't running.
-    # ...but before actually starting a master, we'll double-check.  This can
-    # be important because we can't tell that that 'git@myhost.com' is the same
-    # as 'myhost.com' where "User git" is setup in the user's ~/.ssh/config file.
-    check_command = command_base + ['-O', 'check']
-    with Trace('Call to ssh (check call): %s', ' '.join(check_command)):
-      try:
-        check_process = subprocess.Popen(check_command,
-                                        stdout=subprocess.PIPE,
-                                        stderr=subprocess.PIPE)
-        check_process.communicate()  # read output, but ignore it...
-        isnt_running = check_process.wait()
-        if not isnt_running:
-          # Our double-check found that the master _was_ infact running.  Add to
-          # the list of keys.
-          self._master_keys[key] = True
-          return True
-      except Exception:
-        # Ignore excpetions.  We we will fall back to the normal command and
-        # print to the log there.
-        pass
-    command = command_base[:1] + ['-M', '-N'] + command_base[1:]
-    p = None
-    try:
-      with Trace('Call to ssh: %s', ' '.join(command)):
-        p = subprocess.Popen(command)
-    except Exception as e:
-      self._master_broken.value = True
-      print('\nwarn: cannot enable ssh control master for %s:%s\n%s'
-            % (host, port, str(e)), file=sys.stderr)
-      return False
-    time.sleep(1)
-    ssh_died = (p.poll() is not None)
-    if ssh_died:
-      return False
-    self.add_master(p)
+class ProxyManager:
-    self._master_keys[key] = True
+    """Manage various ssh clients & masters that we spawn.
-    return True
-  def _open(self, host, port=None):
-    """Make sure a ssh master session exists for |host| & |port|.
-    If one doesn't exist already, we'll create it.
+    This will take care of sharing state between multiprocessing children, and
+    make sure that if we crash, we don't leak any of the ssh sessions.
-    This will obtain any necessary locks to avoid inter-process races.
+    The code should work with a single-process scenario too, and not add too
+    much overhead due to the manager.
    """
-    # Bail before grabbing the lock if we already know that we aren't going to
-    # try creating new masters below.
-    if sys.platform in ('win32', 'cygwin'):
-      return False
-    # Acquire the lock.  This is needed to prevent opening multiple masters for
-    # the same host when we're running "repo sync -jN" (for N > 1) _and_ the
-    # manifest <remote fetch="ssh://xyz"> specifies a different host from the
-    # one that was passed to repo init.
-    with self._lock:
-      return self._open_unlocked(host, port)
-  def preconnect(self, url):
-    """If |uri| will create a ssh connection, setup the ssh master for it."""
-    m = URI_ALL.match(url)
-    if m:
-      scheme = m.group(1)
-      host = m.group(2)
-      if ':' in host:
-        host, port = host.split(':')
-      else:
-        port = None
-      if scheme in ('ssh', 'git+ssh', 'ssh+git'):
-        return self._open(host, port)
-      return False
-    m = URI_SCP.match(url)
-    if m:
-      host = m.group(1)
-      return self._open(host)
-    return False
-  def sock(self, create=True):
+    # Path to the ssh program to run which will pass our master settings along.
-    """Return the path to the ssh socket dir.
+    # Set here more as a convenience API.
+    proxy = PROXY_PATH
-    This has all the master sockets so clients can talk to them.
-    """
+    def __init__(self, manager):
-    if self._sock_path is None:
+        # Protect access to the list of active masters.
-      if not create:
+        self._lock = multiprocessing.Lock()
-        return None
+        # List of active masters (pid).  These will be spawned on demand, and we
-      tmp_dir = '/tmp'
+        # are responsible for shutting them all down at the end.
-      if not os.path.exists(tmp_dir):
+        self._masters = manager.list()
-        tmp_dir = tempfile.gettempdir()
+        # Set of active masters indexed by "host:port" information.
-      if version() < (6, 7):
+        # The value isn't used, but multiprocessing doesn't provide a set class.
-        tokens = '%r@%h:%p'
+        self._master_keys = manager.dict()
-      else:
+        # Whether ssh masters are known to be broken, so we give up entirely.
-        tokens = '%C'  # hash of %l%h%p%r
+        self._master_broken = manager.Value("b", False)
-      self._sock_path = os.path.join(
+        # List of active ssh sesssions.  Clients will be added & removed as
-          tempfile.mkdtemp('', 'ssh-', tmp_dir),
+        # connections finish, so this list is just for safety & cleanup if we
-          'master-' + tokens)
+        # crash.
-    return self._sock_path
+        self._clients = manager.list()
+        # Path to directory for holding master sockets.
+        self._sock_path = None
+    def __enter__(self):
+        """Enter a new context."""
+        return self
+    def __exit__(self, exc_type, exc_value, traceback):
+        """Exit a context & clean up all resources."""
+        self.close()
+    def add_client(self, proc):
+        """Track a new ssh session."""
+        self._clients.append(proc.pid)
+    def remove_client(self, proc):
+        """Remove a completed ssh session."""
+        try:
+            self._clients.remove(proc.pid)
+        except ValueError:
+            pass
+    def add_master(self, proc):
+        """Track a new master connection."""
+        self._masters.append(proc.pid)
+    def _terminate(self, procs):
+        """Kill all |procs|."""
+        for pid in procs:
+            try:
+                os.kill(pid, signal.SIGTERM)
+                os.waitpid(pid, 0)
+            except OSError:
+                pass
+        # The multiprocessing.list() API doesn't provide many standard list()
+        # methods, so we have to manually clear the list.
+        while True:
+            try:
+                procs.pop(0)
+            except:  # noqa: E722
+                break
+    def close(self):
+        """Close this active ssh session.
+        Kill all ssh clients & masters we created, and nuke the socket dir.
+        """
+        self._terminate(self._clients)
+        self._terminate(self._masters)
+        d = self.sock(create=False)
+        if d:
+            try:
+                platform_utils.rmdir(os.path.dirname(d))
+            except OSError:
+                pass
+    def _open_unlocked(self, host, port=None):
+        """Make sure a ssh master session exists for |host| & |port|.
+        If one doesn't exist already, we'll create it.
+        We won't grab any locks, so the caller has to do that.  This helps keep
+        the business logic of actually creating the master separate from
+        grabbing locks.
+        """
+        # Check to see whether we already think that the master is running; if
+        # we think it's already running, return right away.
+        if port is not None:
+            key = "%s:%s" % (host, port)
+        else:
+            key = host
+        if key in self._master_keys:
+            return True
+        if self._master_broken.value or "GIT_SSH" in os.environ:
+            # Failed earlier, so don't retry.
+            return False
+        # We will make two calls to ssh; this is the common part of both calls.
+        command_base = ["ssh", "-o", "ControlPath %s" % self.sock(), host]
+        if port is not None:
+            command_base[1:1] = ["-p", str(port)]
+        # Since the key wasn't in _master_keys, we think that master isn't
+        # running... but before actually starting a master, we'll double-check.
+        # This can be important because we can't tell that that 'git@myhost.com'
+        # is the same as 'myhost.com' where "User git" is setup in the user's
+        # ~/.ssh/config file.
+        check_command = command_base + ["-O", "check"]
+        with Trace("Call to ssh (check call): %s", " ".join(check_command)):
+            try:
+                check_process = subprocess.Popen(
+                    check_command,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                )
+                check_process.communicate()  # read output, but ignore it...
+                isnt_running = check_process.wait()
+                if not isnt_running:
+                    # Our double-check found that the master _was_ infact
+                    # running.  Add to the list of keys.
+                    self._master_keys[key] = True
+                    return True
+            except Exception:
+                # Ignore excpetions.  We we will fall back to the normal command
+                # and print to the log there.
+                pass
+        command = command_base[:1] + ["-M", "-N"] + command_base[1:]
+        p = None
+        try:
+            with Trace("Call to ssh: %s", " ".join(command)):
+                p = subprocess.Popen(command)
+        except Exception as e:
+            self._master_broken.value = True
+            print(
+                "\nwarn: cannot enable ssh control master for %s:%s\n%s"
+                % (host, port, str(e)),
+                file=sys.stderr,
+            )
+            return False
+        time.sleep(1)
+        ssh_died = p.poll() is not None
+        if ssh_died:
+            return False
+        self.add_master(p)
+        self._master_keys[key] = True
+        return True
+    def _open(self, host, port=None):
+        """Make sure a ssh master session exists for |host| & |port|.
+        If one doesn't exist already, we'll create it.
+        This will obtain any necessary locks to avoid inter-process races.
+        """
+        # Bail before grabbing the lock if we already know that we aren't going
+        # to try creating new masters below.
+        if sys.platform in ("win32", "cygwin"):
+            return False
+        # Acquire the lock.  This is needed to prevent opening multiple masters
+        # for the same host when we're running "repo sync -jN" (for N > 1) _and_
+        # the manifest <remote fetch="ssh://xyz"> specifies a different host
+        # from the one that was passed to repo init.
+        with self._lock:
+            return self._open_unlocked(host, port)
+    def preconnect(self, url):
+        """If |uri| will create a ssh connection, setup the ssh master for it."""  # noqa: E501
+        m = URI_ALL.match(url)
+        if m:
+            scheme = m.group(1)
+            host = m.group(2)
+            if ":" in host:
+                host, port = host.split(":")
+            else:
+                port = None
+            if scheme in ("ssh", "git+ssh", "ssh+git"):
+                return self._open(host, port)
+            return False
+        m = URI_SCP.match(url)
+        if m:
+            host = m.group(1)
+            return self._open(host)
+        return False
+    def sock(self, create=True):
+        """Return the path to the ssh socket dir.
+        This has all the master sockets so clients can talk to them.
+        """
+        if self._sock_path is None:
+            if not create:
+                return None
+            tmp_dir = "/tmp"
+            if not os.path.exists(tmp_dir):
+                tmp_dir = tempfile.gettempdir()
+            if version() < (6, 7):
+                tokens = "%r@%h:%p"
+            else:
+                tokens = "%C"  # hash of %l%h%p%r
+            self._sock_path = os.path.join(
+                tempfile.mkdtemp("", "ssh-", tmp_dir), "master-" + tokens
+            )
+        return self._sock_path
diff --git a/subcmds/__init__.py b/subcmds/__init__.py
index 051dda06..4e41afc0 100644
--- a/subcmds/__init__.py
+++ b/subcmds/__init__.py
@@ -19,31 +19,29 @@ all_commands = {}
 my_dir = os.path.dirname(__file__)
 for py in os.listdir(my_dir):
-  if py == '__init__.py':
+    if py == "__init__.py":
-    continue
+        continue
-  if py.endswith('.py'):
+    if py.endswith(".py"):
-    name = py[:-3]
+        name = py[:-3]
-    clsn = name.capitalize()
+        clsn = name.capitalize()
-    while clsn.find('_') > 0:
+        while clsn.find("_") > 0:
-      h = clsn.index('_')
+            h = clsn.index("_")
-      clsn = clsn[0:h] + clsn[h + 1:].capitalize()
+            clsn = clsn[0:h] + clsn[h + 1 :].capitalize()
-    mod = __import__(__name__,
+        mod = __import__(__name__, globals(), locals(), ["%s" % name])
-                     globals(),
+        mod = getattr(mod, name)
-                     locals(),
+        try:
-                     ['%s' % name])
+            cmd = getattr(mod, clsn)
-    mod = getattr(mod, name)
+        except AttributeError:
-    try:
+            raise SyntaxError(
-      cmd = getattr(mod, clsn)
+                "%s/%s does not define class %s" % (__name__, py, clsn)
-    except AttributeError:
+            )
-      raise SyntaxError('%s/%s does not define class %s' % (
-          __name__, py, clsn))
+        name = name.replace("_", "-")
+        cmd.NAME = name
-    name = name.replace('_', '-')
+        all_commands[name] = cmd
-    cmd.NAME = name
-    all_commands[name] = cmd
 # Add 'branch' as an alias for 'branches'.
-all_commands['branch'] = all_commands['branches']
+all_commands["branch"] = all_commands["branches"]
diff --git a/subcmds/abandon.py b/subcmds/abandon.py
index c3d2d5b7..1f687f53 100644
--- a/subcmds/abandon.py
+++ b/subcmds/abandon.py
@@ -23,9 +23,9 @@ from progress import Progress
 class Abandon(Command):
-  COMMON = True
+    COMMON = True
-  helpSummary = "Permanently abandon a development branch"
+    helpSummary = "Permanently abandon a development branch"
-  helpUsage = """
+    helpUsage = """
 %prog [--all | <branchname>] [<project>...]
 This subcommand permanently abandons a development branch by
@@ -33,83 +33,104 @@ deleting it (and all its history) from your local repository.
 It is equivalent to "git branch -D <branchname>".
 """
-  PARALLEL_JOBS = DEFAULT_LOCAL_JOBS
+    PARALLEL_JOBS = DEFAULT_LOCAL_JOBS
-  def _Options(self, p):
+    def _Options(self, p):
-    p.add_option('--all',
+        p.add_option(
-                 dest='all', action='store_true',
+            "--all",
-                 help='delete all branches in all projects')
+            dest="all",
+            action="store_true",
+            help="delete all branches in all projects",
+        )
-  def ValidateOptions(self, opt, args):
+    def ValidateOptions(self, opt, args):
-    if not opt.all and not args:
+        if not opt.all and not args:
-      self.Usage()
+            self.Usage()
-    if not opt.all:
+        if not opt.all:
-      nb = args[0]
+            nb = args[0]
-      if not git.check_ref_format('heads/%s' % nb):
+            if not git.check_ref_format("heads/%s" % nb):
-        self.OptionParser.error("'%s' is not a valid branch name" % nb)
+                self.OptionParser.error("'%s' is not a valid branch name" % nb)
-    else:
+        else:
-      args.insert(0, "'All local branches'")
+            args.insert(0, "'All local branches'")
-  def _ExecuteOne(self, all_branches, nb, project):
+    def _ExecuteOne(self, all_branches, nb, project):
-    """Abandon one project."""
+        """Abandon one project."""
-    if all_branches:
+        if all_branches:
-      branches = project.GetBranches()
+            branches = project.GetBranches()
-    else:
+        else:
-      branches = [nb]
+            branches = [nb]
-    ret = {}
+        ret = {}
-    for name in branches:
+        for name in branches:
-      status = project.AbandonBranch(name)
+            status = project.AbandonBranch(name)
-      if status is not None:
+            if status is not None:
-        ret[name] = status
+                ret[name] = status
-    return (ret, project)
+        return (ret, project)
-  def Execute(self, opt, args):
+    def Execute(self, opt, args):
-    nb = args[0]
+        nb = args[0]
-    err = defaultdict(list)
+        err = defaultdict(list)
-    success = defaultdict(list)
+        success = defaultdict(list)
-    all_projects = self.GetProjects(args[1:], all_manifests=not opt.this_manifest_only)
+        all_projects = self.GetProjects(
-    _RelPath = lambda p: p.RelPath(local=opt.this_manifest_only)
+            args[1:], all_manifests=not opt.this_manifest_only
+        )
+        _RelPath = lambda p: p.RelPath(local=opt.this_manifest_only)
-    def _ProcessResults(_pool, pm, states):
+        def _ProcessResults(_pool, pm, states):
-      for (results, project) in states:
+            for results, project in states:
-        for branch, status in results.items():
+                for branch, status in results.items():
-          if status:
+                    if status:
-            success[branch].append(project)
+                        success[branch].append(project)
-          else:
+                    else:
-            err[branch].append(project)
+                        err[branch].append(project)
-        pm.update()
+                pm.update()
-    self.ExecuteInParallel(
+        self.ExecuteInParallel(
-        opt.jobs,
+            opt.jobs,
-        functools.partial(self._ExecuteOne, opt.all, nb),
+            functools.partial(self._ExecuteOne, opt.all, nb),
-        all_projects,
+            all_projects,
-        callback=_ProcessResults,
+            callback=_ProcessResults,
-        output=Progress('Abandon %s' % (nb,), len(all_projects), quiet=opt.quiet))
+            output=Progress(
+                "Abandon %s" % (nb,), len(all_projects), quiet=opt.quiet
+            ),
+        )
-    width = max(itertools.chain(
+        width = max(
-        [25], (len(x) for x in itertools.chain(success, err))))
+            itertools.chain(
-    if err:
+                [25], (len(x) for x in itertools.chain(success, err))
-      for br in err.keys():
+            )
-        err_msg = "error: cannot abandon %s" % br
+        )
-        print(err_msg, file=sys.stderr)
+        if err:
-        for proj in err[br]:
+            for br in err.keys():
-          print(' ' * len(err_msg) + " | %s" % _RelPath(proj), file=sys.stderr)
+                err_msg = "error: cannot abandon %s" % br
-      sys.exit(1)
+                print(err_msg, file=sys.stderr)
-    elif not success:
+                for proj in err[br]:
-      print('error: no project has local branch(es) : %s' % nb,
+                    print(
-            file=sys.stderr)
+                        " " * len(err_msg) + " | %s" % _RelPath(proj),
-      sys.exit(1)
+                        file=sys.stderr,
-    else:
+                    )
-      # Everything below here is displaying status.
+            sys.exit(1)
-      if opt.quiet:
+        elif not success:
-        return
+            print(
-      print('Abandoned branches:')
+                "error: no project has local branch(es) : %s" % nb,
-      for br in success.keys():
+                file=sys.stderr,
-        if len(all_projects) > 1 and len(all_projects) == len(success[br]):
+            )
-          result = "all project"
+            sys.exit(1)
        else:
-          result = "%s" % (
+            # Everything below here is displaying status.
-              ('\n' + ' ' * width + '| ').join(_RelPath(p) for p in success[br]))
+            if opt.quiet:
-        print("%s%s| %s\n" % (br, ' ' * (width - len(br)), result))
+                return
+            print("Abandoned branches:")
+            for br in success.keys():
+                if len(all_projects) > 1 and len(all_projects) == len(
+                    success[br]
+                ):
+                    result = "all project"
+                else:
+                    result = "%s" % (
+                        ("\n" + " " * width + "| ").join(
+                            _RelPath(p) for p in success[br]
+                        )
+                    )
+                print("%s%s| %s\n" % (br, " " * (width - len(br)), result))
diff --git a/subcmds/branches.py b/subcmds/branches.py
index fcf67ef5..4d5bb196 100644
--- a/subcmds/branches.py
+++ b/subcmds/branches.py
@@ -20,51 +20,51 @@ from command import Command, DEFAULT_LOCAL_JOBS
 class BranchColoring(Coloring):
-  def __init__(self, config):
+    def __init__(self, config):
-    Coloring.__init__(self, config, 'branch')
+        Coloring.__init__(self, config, "branch")
-    self.current = self.printer('current', fg='green')
+        self.current = self.printer("current", fg="green")
-    self.local = self.printer('local')
+        self.local = self.printer("local")
-    self.notinproject = self.printer('notinproject', fg='red')
+        self.notinproject = self.printer("notinproject", fg="red")
 class BranchInfo(object):
-  def __init__(self, name):
+    def __init__(self, name):
-    self.name = name
+        self.name = name
-    self.current = 0
+        self.current = 0
-    self.published = 0
+        self.published = 0
-    self.published_equal = 0
+        self.published_equal = 0
-    self.projects = []
+        self.projects = []
-  def add(self, b):
+    def add(self, b):
-    if b.current:
+        if b.current:
-      self.current += 1
+            self.current += 1
-    if b.published:
+        if b.published:
-      self.published += 1
+            self.published += 1
-    if b.revision == b.published:
+        if b.revision == b.published:
-      self.published_equal += 1
+            self.published_equal += 1
-    self.projects.append(b)
+        self.projects.append(b)
-  @property
+    @property
-  def IsCurrent(self):
+    def IsCurrent(self):
-    return self.current > 0
+        return self.current > 0
-  @property
+    @property
-  def IsSplitCurrent(self):
+    def IsSplitCurrent(self):
-    return self.current != 0 and self.current != len(self.projects)
+        return self.current != 0 and self.current != len(self.projects)
-  @property
+    @property
-  def IsPublished(self):
+    def IsPublished(self):
-    return self.published > 0
+        return self.published > 0
-  @property
+    @property
-  def IsPublishedEqual(self):
+    def IsPublishedEqual(self):
-    return self.published_equal == len(self.projects)
+        return self.published_equal == len(self.projects)
 class Branches(Command):
-  COMMON = True
+    COMMON = True
-  helpSummary = "View current topic branches"
+    helpSummary = "View current topic branches"
-  helpUsage = """
+    helpUsage = """
 %prog [<project>...]
 Summarizes the currently available topic branches.
@@ -95,111 +95,114 @@ the branch appears in, or does not appear in.  If no project list
 is shown, then the branch appears in all projects.
 """
-  PARALLEL_JOBS = DEFAULT_LOCAL_JOBS
+    PARALLEL_JOBS = DEFAULT_LOCAL_JOBS
-  def Execute(self, opt, args):
+    def Execute(self, opt, args):
-    projects = self.GetProjects(args, all_manifests=not opt.this_manifest_only)
+        projects = self.GetProjects(
-    out = BranchColoring(self.manifest.manifestProject.config)
+            args, all_manifests=not opt.this_manifest_only
-    all_branches = {}
+        )
-    project_cnt = len(projects)
+        out = BranchColoring(self.manifest.manifestProject.config)
+        all_branches = {}
-    def _ProcessResults(_pool, _output, results):
+        project_cnt = len(projects)
-      for name, b in itertools.chain.from_iterable(results):
-        if name not in all_branches:
+        def _ProcessResults(_pool, _output, results):
-          all_branches[name] = BranchInfo(name)
+            for name, b in itertools.chain.from_iterable(results):
-        all_branches[name].add(b)
+                if name not in all_branches:
+                    all_branches[name] = BranchInfo(name)
-    self.ExecuteInParallel(
+                all_branches[name].add(b)
-        opt.jobs,
-        expand_project_to_branches,
+        self.ExecuteInParallel(
-        projects,
+            opt.jobs,
-        callback=_ProcessResults)
+            expand_project_to_branches,
+            projects,
-    names = sorted(all_branches)
+            callback=_ProcessResults,
+        )
-    if not names:
-      print('   (no branches)', file=sys.stderr)
+        names = sorted(all_branches)
-      return
+        if not names:
-    width = 25
+            print("   (no branches)", file=sys.stderr)
-    for name in names:
+            return
-      if width < len(name):
-        width = len(name)
+        width = 25
+        for name in names:
-    for name in names:
+            if width < len(name):
-      i = all_branches[name]
+                width = len(name)
-      in_cnt = len(i.projects)
+        for name in names:
-      if i.IsCurrent:
+            i = all_branches[name]
-        current = '*'
+            in_cnt = len(i.projects)
-        hdr = out.current
-      else:
+            if i.IsCurrent:
-        current = ' '
+                current = "*"
-        hdr = out.local
+                hdr = out.current
-      if i.IsPublishedEqual:
-        published = 'P'
-      elif i.IsPublished:
-        published = 'p'
-      else:
-        published = ' '
-      hdr('%c%c %-*s' % (current, published, width, name))
-      out.write(' |')
-      _RelPath = lambda p: p.RelPath(local=opt.this_manifest_only)
-      if in_cnt < project_cnt:
-        fmt = out.write
-        paths = []
-        non_cur_paths = []
-        if i.IsSplitCurrent or (in_cnt <= project_cnt - in_cnt):
-          in_type = 'in'
-          for b in i.projects:
-            relpath = _RelPath(b.project)
-            if not i.IsSplitCurrent or b.current:
-              paths.append(relpath)
            else:
-              non_cur_paths.append(relpath)
+                current = " "
-        else:
+                hdr = out.local
-          fmt = out.notinproject
-          in_type = 'not in'
+            if i.IsPublishedEqual:
-          have = set()
+                published = "P"
-          for b in i.projects:
+            elif i.IsPublished:
-            have.add(_RelPath(b.project))
+                published = "p"
-          for p in projects:
+            else:
-            if _RelPath(p) not in have:
+                published = " "
-              paths.append(_RelPath(p))
+            hdr("%c%c %-*s" % (current, published, width, name))
-        s = ' %s %s' % (in_type, ', '.join(paths))
+            out.write(" |")
-        if not i.IsSplitCurrent and (width + 7 + len(s) < 80):
-          fmt = out.current if i.IsCurrent else fmt
+            _RelPath = lambda p: p.RelPath(local=opt.this_manifest_only)
-          fmt(s)
+            if in_cnt < project_cnt:
-        else:
+                fmt = out.write
-          fmt(' %s:' % in_type)
+                paths = []
-          fmt = out.current if i.IsCurrent else out.write
+                non_cur_paths = []
-          for p in paths:
+                if i.IsSplitCurrent or (in_cnt <= project_cnt - in_cnt):
-            out.nl()
+                    in_type = "in"
-            fmt(width * ' ' + '          %s' % p)
+                    for b in i.projects:
-          fmt = out.write
+                        relpath = _RelPath(b.project)
-          for p in non_cur_paths:
+                        if not i.IsSplitCurrent or b.current:
+                            paths.append(relpath)
+                        else:
+                            non_cur_paths.append(relpath)
+                else:
+                    fmt = out.notinproject
+                    in_type = "not in"
+                    have = set()
+                    for b in i.projects:
+                        have.add(_RelPath(b.project))
+                    for p in projects:
+                        if _RelPath(p) not in have:
+                            paths.append(_RelPath(p))
+                s = " %s %s" % (in_type, ", ".join(paths))
+                if not i.IsSplitCurrent and (width + 7 + len(s) < 80):
+                    fmt = out.current if i.IsCurrent else fmt
+                    fmt(s)
+                else:
+                    fmt(" %s:" % in_type)
+                    fmt = out.current if i.IsCurrent else out.write
+                    for p in paths:
+                        out.nl()
+                        fmt(width * " " + "          %s" % p)
+                    fmt = out.write
+                    for p in non_cur_paths:
+                        out.nl()
+                        fmt(width * " " + "          %s" % p)
+            else:
+                out.write(" in all projects")
            out.nl()
-            fmt(width * ' ' + '          %s' % p)
-      else:
-        out.write(' in all projects')
-      out.nl()
 def expand_project_to_branches(project):
-  """Expands a project into a list of branch names & associated information.
+    """Expands a project into a list of branch names & associated information.
-  Args:
+    Args:
-    project: project.Project
+        project: project.Project
-  Returns:
+    Returns:
-    List[Tuple[str, git_config.Branch]]
+        List[Tuple[str, git_config.Branch]]
-  """
+    """
-  branches = []
+    branches = []
-  for name, b in project.GetBranches().items():
+    for name, b in project.GetBranches().items():
-    b.project = project
+        b.project = project
-    branches.append((name, b))
+        branches.append((name, b))
-  return branches
+    return branches
diff --git a/subcmds/checkout.py b/subcmds/checkout.py
index 768b6027..08012a82 100644
--- a/subcmds/checkout.py
+++ b/subcmds/checkout.py
@@ -20,12 +20,12 @@ from progress import Progress
 class Checkout(Command):
-  COMMON = True
+    COMMON = True
-  helpSummary = "Checkout a branch for development"
+    helpSummary = "Checkout a branch for development"
-  helpUsage = """
+    helpUsage = """
 %prog <branchname> [<project>...]
 """
-  helpDescription = """
+    helpDescription = """
 The '%prog' command checks out an existing branch that was previously
 created by 'repo start'.
@@ -33,43 +33,50 @@ The command is equivalent to:
  repo forall [<project>...] -c git checkout <branchname>
 """
-  PARALLEL_JOBS = DEFAULT_LOCAL_JOBS
+    PARALLEL_JOBS = DEFAULT_LOCAL_JOBS
-  def ValidateOptions(self, opt, args):
+    def ValidateOptions(self, opt, args):
-    if not args:
+        if not args:
-      self.Usage()
+            self.Usage()
-  def _ExecuteOne(self, nb, project):
+    def _ExecuteOne(self, nb, project):
-    """Checkout one project."""
+        """Checkout one project."""
-    return (project.CheckoutBranch(nb), project)
+        return (project.CheckoutBranch(nb), project)
-  def Execute(self, opt, args):
+    def Execute(self, opt, args):
-    nb = args[0]
+        nb = args[0]
-    err = []
+        err = []
-    success = []
+        success = []
-    all_projects = self.GetProjects(args[1:], all_manifests=not opt.this_manifest_only)
+        all_projects = self.GetProjects(
+            args[1:], all_manifests=not opt.this_manifest_only
+        )
-    def _ProcessResults(_pool, pm, results):
+        def _ProcessResults(_pool, pm, results):
-      for status, project in results:
+            for status, project in results:
-        if status is not None:
+                if status is not None:
-          if status:
+                    if status:
-            success.append(project)
+                        success.append(project)
-          else:
+                    else:
-            err.append(project)
+                        err.append(project)
-        pm.update()
+                pm.update()
-    self.ExecuteInParallel(
+        self.ExecuteInParallel(
-        opt.jobs,
+            opt.jobs,
-        functools.partial(self._ExecuteOne, nb),
+            functools.partial(self._ExecuteOne, nb),
-        all_projects,
+            all_projects,
-        callback=_ProcessResults,
+            callback=_ProcessResults,
-        output=Progress('Checkout %s' % (nb,), len(all_projects), quiet=opt.quiet))
+            output=Progress(
+                "Checkout %s" % (nb,), len(all_projects), quiet=opt.quiet
+            ),
+        )
-    if err:
+        if err:
-      for p in err:
+            for p in err:
-        print("error: %s/: cannot checkout %s" % (p.relpath, nb),
+                print(
-              file=sys.stderr)
+                    "error: %s/: cannot checkout %s" % (p.relpath, nb),
-      sys.exit(1)
+                    file=sys.stderr,
-    elif not success:
+                )
-      print('error: no project has branch %s' % nb, file=sys.stderr)
+            sys.exit(1)
-      sys.exit(1)
+        elif not success:
+            print("error: no project has branch %s" % nb, file=sys.stderr)
+            sys.exit(1)
diff --git a/subcmds/cherry_pick.py b/subcmds/cherry_pick.py
index eecf4e17..4cfb8c88 100644
--- a/subcmds/cherry_pick.py
+++ b/subcmds/cherry_pick.py
@@ -17,96 +17,107 @@ import sys
 from command import Command
 from git_command import GitCommand
-CHANGE_ID_RE = re.compile(r'^\s*Change-Id: I([0-9a-f]{40})\s*$')
+CHANGE_ID_RE = re.compile(r"^\s*Change-Id: I([0-9a-f]{40})\s*$")
 class CherryPick(Command):
-  COMMON = True
+    COMMON = True
-  helpSummary = "Cherry-pick a change."
+    helpSummary = "Cherry-pick a change."
-  helpUsage = """
+    helpUsage = """
 %prog <sha1>
 """
-  helpDescription = """
+    helpDescription = """
 '%prog' cherry-picks a change from one branch to another.
 The change id will be updated, and a reference to the old
 change id will be added.
 """
-  def ValidateOptions(self, opt, args):
+    def ValidateOptions(self, opt, args):
-    if len(args) != 1:
+        if len(args) != 1:
-      self.Usage()
+            self.Usage()
-  def Execute(self, opt, args):
+    def Execute(self, opt, args):
-    reference = args[0]
+        reference = args[0]
-    p = GitCommand(None,
+        p = GitCommand(
-                   ['rev-parse', '--verify', reference],
+            None,
-                   capture_stdout=True,
+            ["rev-parse", "--verify", reference],
-                   capture_stderr=True)
+            capture_stdout=True,
-    if p.Wait() != 0:
+            capture_stderr=True,
-      print(p.stderr, file=sys.stderr)
+        )
-      sys.exit(1)
+        if p.Wait() != 0:
-    sha1 = p.stdout.strip()
+            print(p.stderr, file=sys.stderr)
+            sys.exit(1)
-    p = GitCommand(None, ['cat-file', 'commit', sha1], capture_stdout=True)
+        sha1 = p.stdout.strip()
-    if p.Wait() != 0:
-      print("error: Failed to retrieve old commit message", file=sys.stderr)
+        p = GitCommand(None, ["cat-file", "commit", sha1], capture_stdout=True)
-      sys.exit(1)
+        if p.Wait() != 0:
-    old_msg = self._StripHeader(p.stdout)
+            print(
+                "error: Failed to retrieve old commit message", file=sys.stderr
-    p = GitCommand(None,
+            )
-                   ['cherry-pick', sha1],
+            sys.exit(1)
-                   capture_stdout=True,
+        old_msg = self._StripHeader(p.stdout)
-                   capture_stderr=True)
-    status = p.Wait()
+        p = GitCommand(
+            None,
-    if p.stdout:
+            ["cherry-pick", sha1],
-      print(p.stdout.strip(), file=sys.stdout)
+            capture_stdout=True,
-    if p.stderr:
+            capture_stderr=True,
-      print(p.stderr.strip(), file=sys.stderr)
+        )
+        status = p.Wait()
-    if status == 0:
-      # The cherry-pick was applied correctly. We just need to edit the
+        if p.stdout:
-      # commit message.
+            print(p.stdout.strip(), file=sys.stdout)
-      new_msg = self._Reformat(old_msg, sha1)
+        if p.stderr:
+            print(p.stderr.strip(), file=sys.stderr)
-      p = GitCommand(None, ['commit', '--amend', '-F', '-'],
-                     input=new_msg,
+        if status == 0:
-                     capture_stdout=True,
+            # The cherry-pick was applied correctly. We just need to edit the
-                     capture_stderr=True)
+            # commit message.
-      if p.Wait() != 0:
+            new_msg = self._Reformat(old_msg, sha1)
-        print("error: Failed to update commit message", file=sys.stderr)
-        sys.exit(1)
+            p = GitCommand(
+                None,
-    else:
+                ["commit", "--amend", "-F", "-"],
-      print('NOTE: When committing (please see above) and editing the commit '
+                input=new_msg,
-            'message, please remove the old Change-Id-line and add:')
+                capture_stdout=True,
-      print(self._GetReference(sha1), file=sys.stderr)
+                capture_stderr=True,
-      print(file=sys.stderr)
+            )
+            if p.Wait() != 0:
-  def _IsChangeId(self, line):
+                print("error: Failed to update commit message", file=sys.stderr)
-    return CHANGE_ID_RE.match(line)
+                sys.exit(1)
-  def _GetReference(self, sha1):
+        else:
-    return "(cherry picked from commit %s)" % sha1
+            print(
+                "NOTE: When committing (please see above) and editing the "
-  def _StripHeader(self, commit_msg):
+                "commit message, please remove the old Change-Id-line and add:"
-    lines = commit_msg.splitlines()
+            )
-    return "\n".join(lines[lines.index("") + 1:])
+            print(self._GetReference(sha1), file=sys.stderr)
+            print(file=sys.stderr)
-  def _Reformat(self, old_msg, sha1):
-    new_msg = []
+    def _IsChangeId(self, line):
+        return CHANGE_ID_RE.match(line)
-    for line in old_msg.splitlines():
-      if not self._IsChangeId(line):
+    def _GetReference(self, sha1):
-        new_msg.append(line)
+        return "(cherry picked from commit %s)" % sha1
-    # Add a blank line between the message and the change id/reference
+    def _StripHeader(self, commit_msg):
-    try:
+        lines = commit_msg.splitlines()
-      if new_msg[-1].strip() != "":
+        return "\n".join(lines[lines.index("") + 1 :])
-        new_msg.append("")
-    except IndexError:
+    def _Reformat(self, old_msg, sha1):
-      pass
+        new_msg = []
-    new_msg.append(self._GetReference(sha1))
+        for line in old_msg.splitlines():
-    return "\n".join(new_msg)
+            if not self._IsChangeId(line):
+                new_msg.append(line)
+        # Add a blank line between the message and the change id/reference.
+        try:
+            if new_msg[-1].strip() != "":
+                new_msg.append("")
+        except IndexError:
+            pass
+        new_msg.append(self._GetReference(sha1))
+        return "\n".join(new_msg)
diff --git a/subcmds/diff.py b/subcmds/diff.py
index a606ee9a..5c627c0c 100644
--- a/subcmds/diff.py
+++ b/subcmds/diff.py
@@ -19,54 +19,63 @@ from command import DEFAULT_LOCAL_JOBS, PagedCommand
 class Diff(PagedCommand):
-  COMMON = True
+    COMMON = True
-  helpSummary = "Show changes between commit and working tree"
+    helpSummary = "Show changes between commit and working tree"
-  helpUsage = """
+    helpUsage = """
 %prog [<project>...]
 The -u option causes '%prog' to generate diff output with file paths
 relative to the repository root, so the output can be applied
 to the Unix 'patch' command.
 """
-  PARALLEL_JOBS = DEFAULT_LOCAL_JOBS
+    PARALLEL_JOBS = DEFAULT_LOCAL_JOBS
-  def _Options(self, p):
+    def _Options(self, p):
-    p.add_option('-u', '--absolute',
+        p.add_option(
-                 dest='absolute', action='store_true',
+            "-u",
-                 help='paths are relative to the repository root')
+            "--absolute",
+            dest="absolute",
+            action="store_true",
+            help="paths are relative to the repository root",
+        )
-  def _ExecuteOne(self, absolute, local, project):
+    def _ExecuteOne(self, absolute, local, project):
-    """Obtains the diff for a specific project.
+        """Obtains the diff for a specific project.
-    Args:
+        Args:
-      absolute: Paths are relative to the root.
+            absolute: Paths are relative to the root.
-      local: a boolean, if True, the path is relative to the local
+            local: a boolean, if True, the path is relative to the local
-             (sub)manifest.  If false, the path is relative to the
+                (sub)manifest.  If false, the path is relative to the outermost
-             outermost manifest.
+                manifest.
-      project: Project to get status of.
+            project: Project to get status of.
-    Returns:
+        Returns:
-      The status of the project.
+            The status of the project.
-    """
+        """
-    buf = io.StringIO()
+        buf = io.StringIO()
-    ret = project.PrintWorkTreeDiff(absolute, output_redir=buf, local=local)
+        ret = project.PrintWorkTreeDiff(absolute, output_redir=buf, local=local)
-    return (ret, buf.getvalue())
+        return (ret, buf.getvalue())
-  def Execute(self, opt, args):
+    def Execute(self, opt, args):
-    all_projects = self.GetProjects(args, all_manifests=not opt.this_manifest_only)
+        all_projects = self.GetProjects(
+            args, all_manifests=not opt.this_manifest_only
+        )
-    def _ProcessResults(_pool, _output, results):
+        def _ProcessResults(_pool, _output, results):
-      ret = 0
+            ret = 0
-      for (state, output) in results:
+            for state, output in results:
-        if output:
+                if output:
-          print(output, end='')
+                    print(output, end="")
-        if not state:
+                if not state:
-          ret = 1
+                    ret = 1
-      return ret
+            return ret
-    return self.ExecuteInParallel(
+        return self.ExecuteInParallel(
-        opt.jobs,
+            opt.jobs,
-        functools.partial(self._ExecuteOne, opt.absolute, opt.this_manifest_only),
+            functools.partial(
-        all_projects,
+                self._ExecuteOne, opt.absolute, opt.this_manifest_only
-        callback=_ProcessResults,
+            ),
-        ordered=True)
+            all_projects,
+            callback=_ProcessResults,
+            ordered=True,
+        )
diff --git a/subcmds/diffmanifests.py b/subcmds/diffmanifests.py
index 4f9f5b0f..b446dbd8 100644
--- a/subcmds/diffmanifests.py
+++ b/subcmds/diffmanifests.py
@@ -18,24 +18,24 @@ from manifest_xml import RepoClient
 class _Coloring(Coloring):
-  def __init__(self, config):
+    def __init__(self, config):
-    Coloring.__init__(self, config, "status")
+        Coloring.__init__(self, config, "status")
 class Diffmanifests(PagedCommand):
-  """ A command to see logs in projects represented by manifests
+    """A command to see logs in projects represented by manifests
-  This is used to see deeper differences between manifests. Where a simple
+    This is used to see deeper differences between manifests. Where a simple
-  diff would only show a diff of sha1s for example, this command will display
+    diff would only show a diff of sha1s for example, this command will display
-  the logs of the project between both sha1s, allowing user to see diff at a
+    the logs of the project between both sha1s, allowing user to see diff at a
-  deeper level.
+    deeper level.
-  """
+    """
-  COMMON = True
+    COMMON = True
-  helpSummary = "Manifest diff utility"
+    helpSummary = "Manifest diff utility"
-  helpUsage = """%prog manifest1.xml [manifest2.xml] [options]"""
+    helpUsage = """%prog manifest1.xml [manifest2.xml] [options]"""
-  helpDescription = """
+    helpDescription = """
 The %prog command shows differences between project revisions of manifest1 and
 manifest2. if manifest2 is not specified, current manifest.xml will be used
 instead. Both absolute and relative paths may be used for manifests. Relative
@@ -65,159 +65,209 @@ synced and their revisions won't be found.
 """
-  def _Options(self, p):
+    def _Options(self, p):
-    p.add_option('--raw',
+        p.add_option(
-                 dest='raw', action='store_true',
+            "--raw", dest="raw", action="store_true", help="display raw diff"
-                 help='display raw diff')
+        )
-    p.add_option('--no-color',
+        p.add_option(
-                 dest='color', action='store_false', default=True,
+            "--no-color",
-                 help='does not display the diff in color')
+            dest="color",
-    p.add_option('--pretty-format',
+            action="store_false",
-                 dest='pretty_format', action='store',
+            default=True,
-                 metavar='<FORMAT>',
+            help="does not display the diff in color",
-                 help='print the log using a custom git pretty format string')
+        )
+        p.add_option(
-  def _printRawDiff(self, diff, pretty_format=None, local=False):
+            "--pretty-format",
-    _RelPath = lambda p: p.RelPath(local=local)
+            dest="pretty_format",
-    for project in diff['added']:
+            action="store",
-      self.printText("A %s %s" % (_RelPath(project), project.revisionExpr))
+            metavar="<FORMAT>",
-      self.out.nl()
+            help="print the log using a custom git pretty format string",
+        )
-    for project in diff['removed']:
-      self.printText("R %s %s" % (_RelPath(project), project.revisionExpr))
+    def _printRawDiff(self, diff, pretty_format=None, local=False):
-      self.out.nl()
+        _RelPath = lambda p: p.RelPath(local=local)
+        for project in diff["added"]:
-    for project, otherProject in diff['changed']:
+            self.printText(
-      self.printText("C %s %s %s" % (_RelPath(project), project.revisionExpr,
+                "A %s %s" % (_RelPath(project), project.revisionExpr)
-                                     otherProject.revisionExpr))
+            )
-      self.out.nl()
-      self._printLogs(project, otherProject, raw=True, color=False, pretty_format=pretty_format)
-    for project, otherProject in diff['unreachable']:
-      self.printText("U %s %s %s" % (_RelPath(project), project.revisionExpr,
-                                     otherProject.revisionExpr))
-      self.out.nl()
-  def _printDiff(self, diff, color=True, pretty_format=None, local=False):
-    _RelPath = lambda p: p.RelPath(local=local)
-    if diff['added']:
-      self.out.nl()
-      self.printText('added projects : \n')
-      self.out.nl()
-      for project in diff['added']:
-        self.printProject('\t%s' % (_RelPath(project)))
-        self.printText(' at revision ')
-        self.printRevision(project.revisionExpr)
-        self.out.nl()
-    if diff['removed']:
-      self.out.nl()
-      self.printText('removed projects : \n')
-      self.out.nl()
-      for project in diff['removed']:
-        self.printProject('\t%s' % (_RelPath(project)))
-        self.printText(' at revision ')
-        self.printRevision(project.revisionExpr)
-        self.out.nl()
-    if diff['missing']:
-      self.out.nl()
-      self.printText('missing projects : \n')
-      self.out.nl()
-      for project in diff['missing']:
-        self.printProject('\t%s' % (_RelPath(project)))
-        self.printText(' at revision ')
-        self.printRevision(project.revisionExpr)
-        self.out.nl()
-    if diff['changed']:
-      self.out.nl()
-      self.printText('changed projects : \n')
-      self.out.nl()
-      for project, otherProject in diff['changed']:
-        self.printProject('\t%s' % (_RelPath(project)))
-        self.printText(' changed from ')
-        self.printRevision(project.revisionExpr)
-        self.printText(' to ')
-        self.printRevision(otherProject.revisionExpr)
-        self.out.nl()
-        self._printLogs(project, otherProject, raw=False, color=color,
-                        pretty_format=pretty_format)
-        self.out.nl()
-    if diff['unreachable']:
-      self.out.nl()
-      self.printText('projects with unreachable revisions : \n')
-      self.out.nl()
-      for project, otherProject in diff['unreachable']:
-        self.printProject('\t%s ' % (_RelPath(project)))
-        self.printRevision(project.revisionExpr)
-        self.printText(' or ')
-        self.printRevision(otherProject.revisionExpr)
-        self.printText(' not found')
-        self.out.nl()
-  def _printLogs(self, project, otherProject, raw=False, color=True,
-                 pretty_format=None):
-    logs = project.getAddedAndRemovedLogs(otherProject,
-                                          oneline=(pretty_format is None),
-                                          color=color,
-                                          pretty_format=pretty_format)
-    if logs['removed']:
-      removedLogs = logs['removed'].split('\n')
-      for log in removedLogs:
-        if log.strip():
-          if raw:
-            self.printText(' R ' + log)
            self.out.nl()
-          else:
-            self.printRemoved('\t\t[-] ')
+        for project in diff["removed"]:
-            self.printText(log)
+            self.printText(
+                "R %s %s" % (_RelPath(project), project.revisionExpr)
+            )
+            self.out.nl()
+        for project, otherProject in diff["changed"]:
+            self.printText(
+                "C %s %s %s"
+                % (
+                    _RelPath(project),
+                    project.revisionExpr,
+                    otherProject.revisionExpr,
+                )
+            )
+            self.out.nl()
+            self._printLogs(
+                project,
+                otherProject,
+                raw=True,
+                color=False,
+                pretty_format=pretty_format,
+            )
+        for project, otherProject in diff["unreachable"]:
+            self.printText(
+                "U %s %s %s"
+                % (
+                    _RelPath(project),
+                    project.revisionExpr,
+                    otherProject.revisionExpr,
+                )
+            )
+            self.out.nl()
+    def _printDiff(self, diff, color=True, pretty_format=None, local=False):
+        _RelPath = lambda p: p.RelPath(local=local)
+        if diff["added"]:
+            self.out.nl()
+            self.printText("added projects : \n")
            self.out.nl()
+            for project in diff["added"]:
+                self.printProject("\t%s" % (_RelPath(project)))
+                self.printText(" at revision ")
+                self.printRevision(project.revisionExpr)
+                self.out.nl()
-    if logs['added']:
+        if diff["removed"]:
-      addedLogs = logs['added'].split('\n')
-      for log in addedLogs:
-        if log.strip():
-          if raw:
-            self.printText(' A ' + log)
            self.out.nl()
-          else:
+            self.printText("removed projects : \n")
-            self.printAdded('\t\t[+] ')
-            self.printText(log)
            self.out.nl()
+            for project in diff["removed"]:
+                self.printProject("\t%s" % (_RelPath(project)))
+                self.printText(" at revision ")
+                self.printRevision(project.revisionExpr)
+                self.out.nl()
-  def ValidateOptions(self, opt, args):
+        if diff["missing"]:
-    if not args or len(args) > 2:
+            self.out.nl()
-      self.OptionParser.error('missing manifests to diff')
+            self.printText("missing projects : \n")
-    if opt.this_manifest_only is False:
+            self.out.nl()
-      raise self.OptionParser.error(
+            for project in diff["missing"]:
-          '`diffmanifest` only supports the current tree')
+                self.printProject("\t%s" % (_RelPath(project)))
+                self.printText(" at revision ")
-  def Execute(self, opt, args):
+                self.printRevision(project.revisionExpr)
-    self.out = _Coloring(self.client.globalConfig)
+                self.out.nl()
-    self.printText = self.out.nofmt_printer('text')
-    if opt.color:
+        if diff["changed"]:
-      self.printProject = self.out.nofmt_printer('project', attr='bold')
+            self.out.nl()
-      self.printAdded = self.out.nofmt_printer('green', fg='green', attr='bold')
+            self.printText("changed projects : \n")
-      self.printRemoved = self.out.nofmt_printer('red', fg='red', attr='bold')
+            self.out.nl()
-      self.printRevision = self.out.nofmt_printer('revision', fg='yellow')
+            for project, otherProject in diff["changed"]:
-    else:
+                self.printProject("\t%s" % (_RelPath(project)))
-      self.printProject = self.printAdded = self.printRemoved = self.printRevision = self.printText
+                self.printText(" changed from ")
+                self.printRevision(project.revisionExpr)
-    manifest1 = RepoClient(self.repodir)
+                self.printText(" to ")
-    manifest1.Override(args[0], load_local_manifests=False)
+                self.printRevision(otherProject.revisionExpr)
-    if len(args) == 1:
+                self.out.nl()
-      manifest2 = self.manifest
+                self._printLogs(
-    else:
+                    project,
-      manifest2 = RepoClient(self.repodir)
+                    otherProject,
-      manifest2.Override(args[1], load_local_manifests=False)
+                    raw=False,
+                    color=color,
-    diff = manifest1.projectsDiff(manifest2)
+                    pretty_format=pretty_format,
-    if opt.raw:
+                )
-      self._printRawDiff(diff, pretty_format=opt.pretty_format,
+                self.out.nl()
-                         local=opt.this_manifest_only)
-    else:
+        if diff["unreachable"]:
-      self._printDiff(diff, color=opt.color, pretty_format=opt.pretty_format,
+            self.out.nl()
-                      local=opt.this_manifest_only)
+            self.printText("projects with unreachable revisions : \n")
+            self.out.nl()
+            for project, otherProject in diff["unreachable"]:
+                self.printProject("\t%s " % (_RelPath(project)))
+                self.printRevision(project.revisionExpr)
+                self.printText(" or ")
+                self.printRevision(otherProject.revisionExpr)
+                self.printText(" not found")
+                self.out.nl()
+    def _printLogs(
+        self, project, otherProject, raw=False, color=True, pretty_format=None
+    ):
+        logs = project.getAddedAndRemovedLogs(
+            otherProject,
+            oneline=(pretty_format is None),
+            color=color,
+            pretty_format=pretty_format,
+        )
+        if logs["removed"]:
+            removedLogs = logs["removed"].split("\n")
+            for log in removedLogs:
+                if log.strip():
+                    if raw:
+                        self.printText(" R " + log)
+                        self.out.nl()
+                    else:
+                        self.printRemoved("\t\t[-] ")
+                        self.printText(log)
+                        self.out.nl()
+        if logs["added"]:
+            addedLogs = logs["added"].split("\n")
+            for log in addedLogs:
+                if log.strip():
+                    if raw:
+                        self.printText(" A " + log)
+                        self.out.nl()
+                    else:
+                        self.printAdded("\t\t[+] ")
+                        self.printText(log)
+                        self.out.nl()
+    def ValidateOptions(self, opt, args):
+        if not args or len(args) > 2:
+            self.OptionParser.error("missing manifests to diff")
+        if opt.this_manifest_only is False:
+            raise self.OptionParser.error(
+                "`diffmanifest` only supports the current tree"
+            )
+    def Execute(self, opt, args):
+        self.out = _Coloring(self.client.globalConfig)
+        self.printText = self.out.nofmt_printer("text")
+        if opt.color:
+            self.printProject = self.out.nofmt_printer("project", attr="bold")
+            self.printAdded = self.out.nofmt_printer(
+                "green", fg="green", attr="bold"
+            )
+            self.printRemoved = self.out.nofmt_printer(
+                "red", fg="red", attr="bold"
+            )
+            self.printRevision = self.out.nofmt_printer("revision", fg="yellow")
+        else:
+            self.printProject = (
+                self.printAdded
+            ) = self.printRemoved = self.printRevision = self.printText
+        manifest1 = RepoClient(self.repodir)
+        manifest1.Override(args[0], load_local_manifests=False)
+        if len(args) == 1:
+            manifest2 = self.manifest
+        else:
+            manifest2 = RepoClient(self.repodir)
+            manifest2.Override(args[1], load_local_manifests=False)
+        diff = manifest1.projectsDiff(manifest2)
+        if opt.raw:
+            self._printRawDiff(
+                diff,
+                pretty_format=opt.pretty_format,
+                local=opt.this_manifest_only,
+            )
+        else:
+            self._printDiff(
+                diff,
+                color=opt.color,
+                pretty_format=opt.pretty_format,
+                local=opt.this_manifest_only,
+            )
diff --git a/subcmds/download.py b/subcmds/download.py
index 15824843..d81d1f8c 100644
--- a/subcmds/download.py
+++ b/subcmds/download.py
@@ -18,143 +18,187 @@ import sys
 from command import Command
 from error import GitError, NoSuchProjectError
-CHANGE_RE = re.compile(r'^([1-9][0-9]*)(?:[/\.-]([1-9][0-9]*))?$')
+CHANGE_RE = re.compile(r"^([1-9][0-9]*)(?:[/\.-]([1-9][0-9]*))?$")
 class Download(Command):
-  COMMON = True
+    COMMON = True
-  helpSummary = "Download and checkout a change"
+    helpSummary = "Download and checkout a change"
-  helpUsage = """
+    helpUsage = """
 %prog {[project] change[/patchset]}...
 """
-  helpDescription = """
+    helpDescription = """
 The '%prog' command downloads a change from the review system and
 makes it available in your project's local working directory.
 If no project is specified try to use current directory as a project.
 """
-  def _Options(self, p):
+    def _Options(self, p):
-    p.add_option('-b', '--branch',
+        p.add_option("-b", "--branch", help="create a new branch first")
-                 help='create a new branch first')
+        p.add_option(
-    p.add_option('-c', '--cherry-pick',
+            "-c",
-                 dest='cherrypick', action='store_true',
+            "--cherry-pick",
-                 help="cherry-pick instead of checkout")
+            dest="cherrypick",
-    p.add_option('-x', '--record-origin', action='store_true',
+            action="store_true",
-                 help='pass -x when cherry-picking')
+            help="cherry-pick instead of checkout",
-    p.add_option('-r', '--revert',
+        )
-                 dest='revert', action='store_true',
+        p.add_option(
-                 help="revert instead of checkout")
+            "-x",
-    p.add_option('-f', '--ff-only',
+            "--record-origin",
-                 dest='ffonly', action='store_true',
+            action="store_true",
-                 help="force fast-forward merge")
+            help="pass -x when cherry-picking",
+        )
-  def _ParseChangeIds(self, opt, args):
+        p.add_option(
-    if not args:
+            "-r",
-      self.Usage()
+            "--revert",
+            dest="revert",
-    to_get = []
+            action="store_true",
-    project = None
+            help="revert instead of checkout",
+        )
-    for a in args:
+        p.add_option(
-      m = CHANGE_RE.match(a)
+            "-f",
-      if m:
+            "--ff-only",
-        if not project:
+            dest="ffonly",
-          project = self.GetProjects(".")[0]
+            action="store_true",
-          print('Defaulting to cwd project', project.name)
+            help="force fast-forward merge",
-        chg_id = int(m.group(1))
+        )
-        if m.group(2):
-          ps_id = int(m.group(2))
+    def _ParseChangeIds(self, opt, args):
-        else:
+        if not args:
-          ps_id = 1
+            self.Usage()
-          refs = 'refs/changes/%2.2d/%d/' % (chg_id % 100, chg_id)
-          output = project._LsRemote(refs + '*')
+        to_get = []
-          if output:
+        project = None
-            regex = refs + r'(\d+)'
-            rcomp = re.compile(regex, re.I)
+        for a in args:
-            for line in output.splitlines():
+            m = CHANGE_RE.match(a)
-              match = rcomp.search(line)
+            if m:
-              if match:
+                if not project:
-                ps_id = max(int(match.group(1)), ps_id)
+                    project = self.GetProjects(".")[0]
-        to_get.append((project, chg_id, ps_id))
+                    print("Defaulting to cwd project", project.name)
-      else:
+                chg_id = int(m.group(1))
-        projects = self.GetProjects([a], all_manifests=not opt.this_manifest_only)
+                if m.group(2):
-        if len(projects) > 1:
+                    ps_id = int(m.group(2))
-          # If the cwd is one of the projects, assume they want that.
+                else:
-          try:
+                    ps_id = 1
-            project = self.GetProjects('.')[0]
+                    refs = "refs/changes/%2.2d/%d/" % (chg_id % 100, chg_id)
-          except NoSuchProjectError:
+                    output = project._LsRemote(refs + "*")
-            project = None
+                    if output:
-          if project not in projects:
+                        regex = refs + r"(\d+)"
-            print('error: %s matches too many projects; please re-run inside '
+                        rcomp = re.compile(regex, re.I)
-                  'the project checkout.' % (a,), file=sys.stderr)
+                        for line in output.splitlines():
-            for project in projects:
+                            match = rcomp.search(line)
-              print('  %s/ @ %s' % (project.RelPath(local=opt.this_manifest_only),
+                            if match:
-                                    project.revisionExpr), file=sys.stderr)
+                                ps_id = max(int(match.group(1)), ps_id)
-            sys.exit(1)
+                to_get.append((project, chg_id, ps_id))
-        else:
+            else:
-          project = projects[0]
+                projects = self.GetProjects(
-          print('Defaulting to cwd project', project.name)
+                    [a], all_manifests=not opt.this_manifest_only
-    return to_get
+                )
+                if len(projects) > 1:
-  def ValidateOptions(self, opt, args):
+                    # If the cwd is one of the projects, assume they want that.
-    if opt.record_origin:
+                    try:
-      if not opt.cherrypick:
+                        project = self.GetProjects(".")[0]
-        self.OptionParser.error('-x only makes sense with --cherry-pick')
+                    except NoSuchProjectError:
+                        project = None
-      if opt.ffonly:
+                    if project not in projects:
-        self.OptionParser.error('-x and --ff are mutually exclusive options')
+                        print(
+                            "error: %s matches too many projects; please "
-  def Execute(self, opt, args):
+                            "re-run inside the project checkout." % (a,),
-    for project, change_id, ps_id in self._ParseChangeIds(opt, args):
+                            file=sys.stderr,
-      dl = project.DownloadPatchSet(change_id, ps_id)
+                        )
-      if not dl:
+                        for project in projects:
-        print('[%s] change %d/%d not found'
+                            print(
-              % (project.name, change_id, ps_id),
+                                "  %s/ @ %s"
-              file=sys.stderr)
+                                % (
-        sys.exit(1)
+                                    project.RelPath(
+                                        local=opt.this_manifest_only
-      if not opt.revert and not dl.commits:
+                                    ),
-        print('[%s] change %d/%d has already been merged'
+                                    project.revisionExpr,
-              % (project.name, change_id, ps_id),
+                                ),
-              file=sys.stderr)
+                                file=sys.stderr,
-        continue
+                            )
+                        sys.exit(1)
-      if len(dl.commits) > 1:
+                else:
-        print('[%s] %d/%d depends on %d unmerged changes:'
+                    project = projects[0]
-              % (project.name, change_id, ps_id, len(dl.commits)),
+                    print("Defaulting to cwd project", project.name)
-              file=sys.stderr)
+        return to_get
-        for c in dl.commits:
-          print('  %s' % (c), file=sys.stderr)
+    def ValidateOptions(self, opt, args):
+        if opt.record_origin:
-      if opt.cherrypick:
+            if not opt.cherrypick:
-        mode = 'cherry-pick'
+                self.OptionParser.error(
-      elif opt.revert:
+                    "-x only makes sense with --cherry-pick"
-        mode = 'revert'
+                )
-      elif opt.ffonly:
-        mode = 'fast-forward merge'
+            if opt.ffonly:
-      else:
+                self.OptionParser.error(
-        mode = 'checkout'
+                    "-x and --ff are mutually exclusive options"
+                )
-      # We'll combine the branch+checkout operation, but all the rest need a
-      # dedicated branch start.
+    def Execute(self, opt, args):
-      if opt.branch and mode != 'checkout':
+        for project, change_id, ps_id in self._ParseChangeIds(opt, args):
-        project.StartBranch(opt.branch)
+            dl = project.DownloadPatchSet(change_id, ps_id)
+            if not dl:
-      try:
+                print(
-        if opt.cherrypick:
+                    "[%s] change %d/%d not found"
-          project._CherryPick(dl.commit, ffonly=opt.ffonly,
+                    % (project.name, change_id, ps_id),
-                              record_origin=opt.record_origin)
+                    file=sys.stderr,
-        elif opt.revert:
+                )
-          project._Revert(dl.commit)
+                sys.exit(1)
-        elif opt.ffonly:
-          project._FastForward(dl.commit, ffonly=True)
+            if not opt.revert and not dl.commits:
-        else:
+                print(
-          if opt.branch:
+                    "[%s] change %d/%d has already been merged"
-            project.StartBranch(opt.branch, revision=dl.commit)
+                    % (project.name, change_id, ps_id),
-          else:
+                    file=sys.stderr,
-            project._Checkout(dl.commit)
+                )
+                continue
-      except GitError:
-        print('[%s] Could not complete the %s of %s'
+            if len(dl.commits) > 1:
-              % (project.name, mode, dl.commit), file=sys.stderr)
+                print(
-        sys.exit(1)
+                    "[%s] %d/%d depends on %d unmerged changes:"
+                    % (project.name, change_id, ps_id, len(dl.commits)),
+                    file=sys.stderr,
+                )
+                for c in dl.commits:
+                    print("  %s" % (c), file=sys.stderr)
+            if opt.cherrypick:
+                mode = "cherry-pick"
+            elif opt.revert:
+                mode = "revert"
+            elif opt.ffonly:
+                mode = "fast-forward merge"
+            else:
+                mode = "checkout"
+            # We'll combine the branch+checkout operation, but all the rest need
+            # a dedicated branch start.
+            if opt.branch and mode != "checkout":
+                project.StartBranch(opt.branch)
+            try:
+                if opt.cherrypick:
+                    project._CherryPick(
+                        dl.commit,
+                        ffonly=opt.ffonly,
+                        record_origin=opt.record_origin,
+                    )
+                elif opt.revert:
+                    project._Revert(dl.commit)
+                elif opt.ffonly:
+                    project._FastForward(dl.commit, ffonly=True)
+                else:
+                    if opt.branch:
+                        project.StartBranch(opt.branch, revision=dl.commit)
+                    else:
+                        project._Checkout(dl.commit)
+            except GitError:
+                print(
+                    "[%s] Could not complete the %s of %s"
+                    % (project.name, mode, dl.commit),
+                    file=sys.stderr,
+                )
+                sys.exit(1)
diff --git a/subcmds/forall.py b/subcmds/forall.py
index f9f34e33..0a897357 100644
--- a/subcmds/forall.py
+++ b/subcmds/forall.py
@@ -23,31 +23,36 @@ import sys
 import subprocess
 from color import Coloring
-from command import DEFAULT_LOCAL_JOBS, Command, MirrorSafeCommand, WORKER_BATCH_SIZE
+from command import (
+    DEFAULT_LOCAL_JOBS,
+    Command,
+    MirrorSafeCommand,
+    WORKER_BATCH_SIZE,
+)
 from error import ManifestInvalidRevisionError
 _CAN_COLOR = [
-    'branch',
+    "branch",
-    'diff',
+    "diff",
-    'grep',
+    "grep",
-    'log',
+    "log",
 ]
 class ForallColoring(Coloring):
-  def __init__(self, config):
+    def __init__(self, config):
-    Coloring.__init__(self, config, 'forall')
+        Coloring.__init__(self, config, "forall")
-    self.project = self.printer('project', attr='bold')
+        self.project = self.printer("project", attr="bold")
 class Forall(Command, MirrorSafeCommand):
-  COMMON = False
+    COMMON = False
-  helpSummary = "Run a shell command in each project"
+    helpSummary = "Run a shell command in each project"
-  helpUsage = """
+    helpUsage = """
 %prog [<project>...] -c <command> [<arg>...]
 %prog -r str1 [str2] ... -c <command> [<arg>...]
 """
-  helpDescription = """
+    helpDescription = """
 Executes the same shell command in each project.
 The -r option allows running the command only on projects matching
@@ -125,236 +130,285 @@ terminal and are not redirected.
 If -e is used, when a command exits unsuccessfully, '%prog' will abort
 without iterating through the remaining projects.
 """
-  PARALLEL_JOBS = DEFAULT_LOCAL_JOBS
+    PARALLEL_JOBS = DEFAULT_LOCAL_JOBS
-  @staticmethod
+    @staticmethod
-  def _cmd_option(option, _opt_str, _value, parser):
+    def _cmd_option(option, _opt_str, _value, parser):
-    setattr(parser.values, option.dest, list(parser.rargs))
+        setattr(parser.values, option.dest, list(parser.rargs))
-    while parser.rargs:
+        while parser.rargs:
-      del parser.rargs[0]
+            del parser.rargs[0]
-  def _Options(self, p):
+    def _Options(self, p):
-    p.add_option('-r', '--regex',
+        p.add_option(
-                 dest='regex', action='store_true',
+            "-r",
-                 help='execute the command only on projects matching regex or wildcard expression')
+            "--regex",
-    p.add_option('-i', '--inverse-regex',
+            dest="regex",
-                 dest='inverse_regex', action='store_true',
+            action="store_true",
-                 help='execute the command only on projects not matching regex or '
+            help="execute the command only on projects matching regex or "
-                      'wildcard expression')
+            "wildcard expression",
-    p.add_option('-g', '--groups',
+        )
-                 dest='groups',
+        p.add_option(
-                 help='execute the command only on projects matching the specified groups')
+            "-i",
-    p.add_option('-c', '--command',
+            "--inverse-regex",
-                 help='command (and arguments) to execute',
+            dest="inverse_regex",
-                 dest='command',
+            action="store_true",
-                 action='callback',
+            help="execute the command only on projects not matching regex or "
-                 callback=self._cmd_option)
+            "wildcard expression",
-    p.add_option('-e', '--abort-on-errors',
+        )
-                 dest='abort_on_errors', action='store_true',
+        p.add_option(
-                 help='abort if a command exits unsuccessfully')
+            "-g",
-    p.add_option('--ignore-missing', action='store_true',
+            "--groups",
-                 help='silently skip & do not exit non-zero due missing '
+            dest="groups",
-                      'checkouts')
+            help="execute the command only on projects matching the specified "
+            "groups",
-    g = p.get_option_group('--quiet')
+        )
-    g.add_option('-p',
+        p.add_option(
-                 dest='project_header', action='store_true',
+            "-c",
-                 help='show project headers before output')
+            "--command",
-    p.add_option('--interactive',
+            help="command (and arguments) to execute",
-                 action='store_true',
+            dest="command",
-                 help='force interactive usage')
+            action="callback",
+            callback=self._cmd_option,
-  def WantPager(self, opt):
+        )
-    return opt.project_header and opt.jobs == 1
+        p.add_option(
+            "-e",
-  def ValidateOptions(self, opt, args):
+            "--abort-on-errors",
-    if not opt.command:
+            dest="abort_on_errors",
-      self.Usage()
+            action="store_true",
+            help="abort if a command exits unsuccessfully",
-  def Execute(self, opt, args):
+        )
-    cmd = [opt.command[0]]
+        p.add_option(
-    all_trees = not opt.this_manifest_only
+            "--ignore-missing",
+            action="store_true",
-    shell = True
+            help="silently skip & do not exit non-zero due missing "
-    if re.compile(r'^[a-z0-9A-Z_/\.-]+$').match(cmd[0]):
+            "checkouts",
-      shell = False
+        )
-    if shell:
+        g = p.get_option_group("--quiet")
-      cmd.append(cmd[0])
+        g.add_option(
-    cmd.extend(opt.command[1:])
+            "-p",
+            dest="project_header",
-    # Historically, forall operated interactively, and in serial.  If the user
+            action="store_true",
-    # has selected 1 job, then default to interacive mode.
+            help="show project headers before output",
-    if opt.jobs == 1:
+        )
-      opt.interactive = True
+        p.add_option(
+            "--interactive", action="store_true", help="force interactive usage"
-    if opt.project_header \
+        )
-            and not shell \
-            and cmd[0] == 'git':
+    def WantPager(self, opt):
-      # If this is a direct git command that can enable colorized
+        return opt.project_header and opt.jobs == 1
-      # output and the user prefers coloring, add --color into the
-      # command line because we are going to wrap the command into
+    def ValidateOptions(self, opt, args):
-      # a pipe and git won't know coloring should activate.
+        if not opt.command:
-      #
+            self.Usage()
-      for cn in cmd[1:]:
-        if not cn.startswith('-'):
+    def Execute(self, opt, args):
-          break
+        cmd = [opt.command[0]]
-      else:
+        all_trees = not opt.this_manifest_only
-        cn = None
-      if cn and cn in _CAN_COLOR:
+        shell = True
-        class ColorCmd(Coloring):
+        if re.compile(r"^[a-z0-9A-Z_/\.-]+$").match(cmd[0]):
-          def __init__(self, config, cmd):
+            shell = False
-            Coloring.__init__(self, config, cmd)
-        if ColorCmd(self.manifest.manifestProject.config, cn).is_on:
+        if shell:
-          cmd.insert(cmd.index(cn) + 1, '--color')
+            cmd.append(cmd[0])
+        cmd.extend(opt.command[1:])
-    mirror = self.manifest.IsMirror
-    rc = 0
+        # Historically, forall operated interactively, and in serial.  If the
+        # user has selected 1 job, then default to interacive mode.
-    smart_sync_manifest_name = "smart_sync_override.xml"
+        if opt.jobs == 1:
-    smart_sync_manifest_path = os.path.join(
+            opt.interactive = True
-        self.manifest.manifestProject.worktree, smart_sync_manifest_name)
+        if opt.project_header and not shell and cmd[0] == "git":
-    if os.path.isfile(smart_sync_manifest_path):
+            # If this is a direct git command that can enable colorized
-      self.manifest.Override(smart_sync_manifest_path)
+            # output and the user prefers coloring, add --color into the
+            # command line because we are going to wrap the command into
-    if opt.regex:
+            # a pipe and git won't know coloring should activate.
-      projects = self.FindProjects(args, all_manifests=all_trees)
+            #
-    elif opt.inverse_regex:
+            for cn in cmd[1:]:
-      projects = self.FindProjects(args, inverse=True, all_manifests=all_trees)
+                if not cn.startswith("-"):
-    else:
+                    break
-      projects = self.GetProjects(args, groups=opt.groups, all_manifests=all_trees)
+            else:
+                cn = None
-    os.environ['REPO_COUNT'] = str(len(projects))
+            if cn and cn in _CAN_COLOR:
-    try:
+                class ColorCmd(Coloring):
-      config = self.manifest.manifestProject.config
+                    def __init__(self, config, cmd):
-      with multiprocessing.Pool(opt.jobs, InitWorker) as pool:
+                        Coloring.__init__(self, config, cmd)
-        results_it = pool.imap(
-            functools.partial(DoWorkWrapper, mirror, opt, cmd, shell, config),
+                if ColorCmd(self.manifest.manifestProject.config, cn).is_on:
-            enumerate(projects),
+                    cmd.insert(cmd.index(cn) + 1, "--color")
-            chunksize=WORKER_BATCH_SIZE)
-        first = True
+        mirror = self.manifest.IsMirror
-        for (r, output) in results_it:
+        rc = 0
-          if output:
-            if first:
+        smart_sync_manifest_name = "smart_sync_override.xml"
-              first = False
+        smart_sync_manifest_path = os.path.join(
-            elif opt.project_header:
+            self.manifest.manifestProject.worktree, smart_sync_manifest_name
-              print()
+        )
-            # To simplify the DoWorkWrapper, take care of automatic newlines.
-            end = '\n'
+        if os.path.isfile(smart_sync_manifest_path):
-            if output[-1] == '\n':
+            self.manifest.Override(smart_sync_manifest_path)
-              end = ''
-            print(output, end=end)
+        if opt.regex:
-          rc = rc or r
+            projects = self.FindProjects(args, all_manifests=all_trees)
-          if r != 0 and opt.abort_on_errors:
+        elif opt.inverse_regex:
-            raise Exception('Aborting due to previous error')
+            projects = self.FindProjects(
-    except (KeyboardInterrupt, WorkerKeyboardInterrupt):
+                args, inverse=True, all_manifests=all_trees
-      # Catch KeyboardInterrupt raised inside and outside of workers
+            )
-      rc = rc or errno.EINTR
+        else:
-    except Exception as e:
+            projects = self.GetProjects(
-      # Catch any other exceptions raised
+                args, groups=opt.groups, all_manifests=all_trees
-      print('forall: unhandled error, terminating the pool: %s: %s' %
+            )
-            (type(e).__name__, e),
-            file=sys.stderr)
+        os.environ["REPO_COUNT"] = str(len(projects))
-      rc = rc or getattr(e, 'errno', 1)
-    if rc != 0:
+        try:
-      sys.exit(rc)
+            config = self.manifest.manifestProject.config
+            with multiprocessing.Pool(opt.jobs, InitWorker) as pool:
+                results_it = pool.imap(
+                    functools.partial(
+                        DoWorkWrapper, mirror, opt, cmd, shell, config
+                    ),
+                    enumerate(projects),
+                    chunksize=WORKER_BATCH_SIZE,
+                )
+                first = True
+                for r, output in results_it:
+                    if output:
+                        if first:
+                            first = False
+                        elif opt.project_header:
+                            print()
+                        # To simplify the DoWorkWrapper, take care of automatic
+                        # newlines.
+                        end = "\n"
+                        if output[-1] == "\n":
+                            end = ""
+                        print(output, end=end)
+                    rc = rc or r
+                    if r != 0 and opt.abort_on_errors:
+                        raise Exception("Aborting due to previous error")
+        except (KeyboardInterrupt, WorkerKeyboardInterrupt):
+            # Catch KeyboardInterrupt raised inside and outside of workers
+            rc = rc or errno.EINTR
+        except Exception as e:
+            # Catch any other exceptions raised
+            print(
+                "forall: unhandled error, terminating the pool: %s: %s"
+                % (type(e).__name__, e),
+                file=sys.stderr,
+            )
+            rc = rc or getattr(e, "errno", 1)
+        if rc != 0:
+            sys.exit(rc)
 class WorkerKeyboardInterrupt(Exception):
-  """ Keyboard interrupt exception for worker processes. """
+    """Keyboard interrupt exception for worker processes."""
 def InitWorker():
-  signal.signal(signal.SIGINT, signal.SIG_IGN)
+    signal.signal(signal.SIGINT, signal.SIG_IGN)
 def DoWorkWrapper(mirror, opt, cmd, shell, config, args):
-  """ A wrapper around the DoWork() method.
+    """A wrapper around the DoWork() method.
-  Catch the KeyboardInterrupt exceptions here and re-raise them as a different,
+    Catch the KeyboardInterrupt exceptions here and re-raise them as a
-  ``Exception``-based exception to stop it flooding the console with stacktraces
+    different, ``Exception``-based exception to stop it flooding the console
-  and making the parent hang indefinitely.
+    with stacktraces and making the parent hang indefinitely.
-  """
+    """
-  cnt, project = args
+    cnt, project = args
-  try:
+    try:
-    return DoWork(project, mirror, opt, cmd, shell, cnt, config)
+        return DoWork(project, mirror, opt, cmd, shell, cnt, config)
-  except KeyboardInterrupt:
+    except KeyboardInterrupt:
-    print('%s: Worker interrupted' % project.name)
+        print("%s: Worker interrupted" % project.name)
-    raise WorkerKeyboardInterrupt()
+        raise WorkerKeyboardInterrupt()
 def DoWork(project, mirror, opt, cmd, shell, cnt, config):
-  env = os.environ.copy()
+    env = os.environ.copy()
-  def setenv(name, val):
+    def setenv(name, val):
-    if val is None:
+        if val is None:
-      val = ''
+            val = ""
-    env[name] = val
+        env[name] = val
-  setenv('REPO_PROJECT', project.name)
+    setenv("REPO_PROJECT", project.name)
-  setenv('REPO_OUTERPATH', project.manifest.path_prefix)
+    setenv("REPO_OUTERPATH", project.manifest.path_prefix)
-  setenv('REPO_INNERPATH', project.relpath)
+    setenv("REPO_INNERPATH", project.relpath)
-  setenv('REPO_PATH', project.RelPath(local=opt.this_manifest_only))
+    setenv("REPO_PATH", project.RelPath(local=opt.this_manifest_only))
-  setenv('REPO_REMOTE', project.remote.name)
+    setenv("REPO_REMOTE", project.remote.name)
-  try:
+    try:
-    # If we aren't in a fully synced state and we don't have the ref the manifest
+        # If we aren't in a fully synced state and we don't have the ref the
-    # wants, then this will fail.  Ignore it for the purposes of this code.
+        # manifest wants, then this will fail.  Ignore it for the purposes of
-    lrev = '' if mirror else project.GetRevisionId()
+        # this code.
-  except ManifestInvalidRevisionError:
+        lrev = "" if mirror else project.GetRevisionId()
-    lrev = ''
+    except ManifestInvalidRevisionError:
-  setenv('REPO_LREV', lrev)
+        lrev = ""
-  setenv('REPO_RREV', project.revisionExpr)
+    setenv("REPO_LREV", lrev)
-  setenv('REPO_UPSTREAM', project.upstream)
+    setenv("REPO_RREV", project.revisionExpr)
-  setenv('REPO_DEST_BRANCH', project.dest_branch)
+    setenv("REPO_UPSTREAM", project.upstream)
-  setenv('REPO_I', str(cnt + 1))
+    setenv("REPO_DEST_BRANCH", project.dest_branch)
-  for annotation in project.annotations:
+    setenv("REPO_I", str(cnt + 1))
-    setenv("REPO__%s" % (annotation.name), annotation.value)
+    for annotation in project.annotations:
+        setenv("REPO__%s" % (annotation.name), annotation.value)
-  if mirror:
-    setenv('GIT_DIR', project.gitdir)
+    if mirror:
-    cwd = project.gitdir
+        setenv("GIT_DIR", project.gitdir)
-  else:
+        cwd = project.gitdir
-    cwd = project.worktree
+    else:
+        cwd = project.worktree
-  if not os.path.exists(cwd):
-    # Allow the user to silently ignore missing checkouts so they can run on
+    if not os.path.exists(cwd):
-    # partial checkouts (good for infra recovery tools).
+        # Allow the user to silently ignore missing checkouts so they can run on
-    if opt.ignore_missing:
+        # partial checkouts (good for infra recovery tools).
-      return (0, '')
+        if opt.ignore_missing:
+            return (0, "")
-    output = ''
-    if ((opt.project_header and opt.verbose)
+        output = ""
-            or not opt.project_header):
+        if (opt.project_header and opt.verbose) or not opt.project_header:
-      output = 'skipping %s/' % project.RelPath(local=opt.this_manifest_only)
+            output = "skipping %s/" % project.RelPath(
-    return (1, output)
+                local=opt.this_manifest_only
+            )
-  if opt.verbose:
+        return (1, output)
-    stderr = subprocess.STDOUT
-  else:
+    if opt.verbose:
-    stderr = subprocess.DEVNULL
+        stderr = subprocess.STDOUT
+    else:
-  stdin = None if opt.interactive else subprocess.DEVNULL
+        stderr = subprocess.DEVNULL
-  result = subprocess.run(
+    stdin = None if opt.interactive else subprocess.DEVNULL
-      cmd, cwd=cwd, shell=shell, env=env, check=False,
-      encoding='utf-8', errors='replace',
+    result = subprocess.run(
-      stdin=stdin, stdout=subprocess.PIPE, stderr=stderr)
+        cmd,
+        cwd=cwd,
-  output = result.stdout
+        shell=shell,
-  if opt.project_header:
+        env=env,
-    if output:
+        check=False,
-      buf = io.StringIO()
+        encoding="utf-8",
-      out = ForallColoring(config)
+        errors="replace",
-      out.redirect(buf)
+        stdin=stdin,
-      if mirror:
+        stdout=subprocess.PIPE,
-        project_header_path = project.name
+        stderr=stderr,
-      else:
+    )
-        project_header_path = project.RelPath(local=opt.this_manifest_only)
-      out.project('project %s/' % project_header_path)
+    output = result.stdout
-      out.nl()
+    if opt.project_header:
-      buf.write(output)
+        if output:
-      output = buf.getvalue()
+            buf = io.StringIO()
-  return (result.returncode, output)
+            out = ForallColoring(config)
+            out.redirect(buf)
+            if mirror:
+                project_header_path = project.name
+            else:
+                project_header_path = project.RelPath(
+                    local=opt.this_manifest_only
+                )
+            out.project("project %s/" % project_header_path)
+            out.nl()
+            buf.write(output)
+            output = buf.getvalue()
+    return (result.returncode, output)
diff --git a/subcmds/gitc_delete.py b/subcmds/gitc_delete.py
index df749469..ae9d4d1f 100644
--- a/subcmds/gitc_delete.py
+++ b/subcmds/gitc_delete.py
@@ -19,28 +19,34 @@ import platform_utils
 class GitcDelete(Command, GitcClientCommand):
-  COMMON = True
+    COMMON = True
-  visible_everywhere = False
+    visible_everywhere = False
-  helpSummary = "Delete a GITC Client."
+    helpSummary = "Delete a GITC Client."
-  helpUsage = """
+    helpUsage = """
 %prog
 """
-  helpDescription = """
+    helpDescription = """
 This subcommand deletes the current GITC client, deleting the GITC manifest
 and all locally downloaded sources.
 """
-  def _Options(self, p):
+    def _Options(self, p):
-    p.add_option('-f', '--force',
+        p.add_option(
-                 dest='force', action='store_true',
+            "-f",
-                 help='force the deletion (no prompt)')
+            "--force",
+            dest="force",
+            action="store_true",
+            help="force the deletion (no prompt)",
+        )
-  def Execute(self, opt, args):
+    def Execute(self, opt, args):
-    if not opt.force:
+        if not opt.force:
-      prompt = ('This will delete GITC client: %s\nAre you sure? (yes/no) ' %
+            prompt = (
-                self.gitc_manifest.gitc_client_name)
+                "This will delete GITC client: %s\nAre you sure? (yes/no) "
-      response = input(prompt).lower()
+                % self.gitc_manifest.gitc_client_name
-      if not response == 'yes':
+            )
-        print('Response was not "yes"\n Exiting...')
+            response = input(prompt).lower()
-        sys.exit(1)
+            if not response == "yes":
-    platform_utils.rmtree(self.gitc_manifest.gitc_client_dir)
+                print('Response was not "yes"\n Exiting...')
+                sys.exit(1)
+        platform_utils.rmtree(self.gitc_manifest.gitc_client_dir)
diff --git a/subcmds/gitc_init.py b/subcmds/gitc_init.py
index e3a5813d..54791d58 100644
--- a/subcmds/gitc_init.py
+++ b/subcmds/gitc_init.py
@@ -23,13 +23,13 @@ import wrapper
 class GitcInit(init.Init, GitcAvailableCommand):
-  COMMON = True
+    COMMON = True
-  MULTI_MANIFEST_SUPPORT = False
+    MULTI_MANIFEST_SUPPORT = False
-  helpSummary = "Initialize a GITC Client."
+    helpSummary = "Initialize a GITC Client."
-  helpUsage = """
+    helpUsage = """
 %prog [options] [client name]
 """
-  helpDescription = """
+    helpDescription = """
 The '%prog' command is ran to initialize a new GITC client for use
 with the GITC file system.
@@ -47,30 +47,41 @@ The optional -f argument can be used to specify the manifest file to
 use for this GITC client.
 """
-  def _Options(self, p):
+    def _Options(self, p):
-    super()._Options(p, gitc_init=True)
+        super()._Options(p, gitc_init=True)
-  def Execute(self, opt, args):
+    def Execute(self, opt, args):
-    gitc_client = gitc_utils.parse_clientdir(os.getcwd())
+        gitc_client = gitc_utils.parse_clientdir(os.getcwd())
-    if not gitc_client or (opt.gitc_client and gitc_client != opt.gitc_client):
+        if not gitc_client or (
-      print('fatal: Please update your repo command. See go/gitc for instructions.',
+            opt.gitc_client and gitc_client != opt.gitc_client
-            file=sys.stderr)
+        ):
-      sys.exit(1)
+            print(
-    self.client_dir = os.path.join(gitc_utils.get_gitc_manifest_dir(),
+                "fatal: Please update your repo command. See go/gitc for "
-                                   gitc_client)
+                "instructions.",
-    super().Execute(opt, args)
+                file=sys.stderr,
+            )
+            sys.exit(1)
+        self.client_dir = os.path.join(
+            gitc_utils.get_gitc_manifest_dir(), gitc_client
+        )
+        super().Execute(opt, args)
-    manifest_file = self.manifest.manifestFile
+        manifest_file = self.manifest.manifestFile
-    if opt.manifest_file:
+        if opt.manifest_file:
-      if not os.path.exists(opt.manifest_file):
+            if not os.path.exists(opt.manifest_file):
-        print('fatal: Specified manifest file %s does not exist.' %
+                print(
-              opt.manifest_file)
+                    "fatal: Specified manifest file %s does not exist."
-        sys.exit(1)
+                    % opt.manifest_file
-      manifest_file = opt.manifest_file
+                )
+                sys.exit(1)
+            manifest_file = opt.manifest_file
-    manifest = GitcManifest(self.repodir, os.path.join(self.client_dir,
+        manifest = GitcManifest(
-                                                       '.manifest'))
+            self.repodir, os.path.join(self.client_dir, ".manifest")
-    manifest.Override(manifest_file)
+        )
-    gitc_utils.generate_gitc_manifest(None, manifest)
+        manifest.Override(manifest_file)
-    print('Please run `cd %s` to view your GITC client.' %
+        gitc_utils.generate_gitc_manifest(None, manifest)
-          os.path.join(wrapper.Wrapper().GITC_FS_ROOT_DIR, gitc_client))
+        print(
+            "Please run `cd %s` to view your GITC client."
+            % os.path.join(wrapper.Wrapper().GITC_FS_ROOT_DIR, gitc_client)
+        )
diff --git a/subcmds/grep.py b/subcmds/grep.py
index 93c9ae51..5cd33763 100644
--- a/subcmds/grep.py
+++ b/subcmds/grep.py
@@ -22,19 +22,19 @@ from git_command import GitCommand
 class GrepColoring(Coloring):
-  def __init__(self, config):
+    def __init__(self, config):
-    Coloring.__init__(self, config, 'grep')
+        Coloring.__init__(self, config, "grep")
-    self.project = self.printer('project', attr='bold')
+        self.project = self.printer("project", attr="bold")
-    self.fail = self.printer('fail', fg='red')
+        self.fail = self.printer("fail", fg="red")
 class Grep(PagedCommand):
-  COMMON = True
+    COMMON = True
-  helpSummary = "Print lines matching a pattern"
+    helpSummary = "Print lines matching a pattern"
-  helpUsage = """
+    helpUsage = """
 %prog {pattern | -e pattern} [<project>...]
 """
-  helpDescription = """
+    helpDescription = """
 Search for the specified patterns in all project files.
 # Boolean Options
@@ -62,215 +62,304 @@ contain a line that matches both expressions:
  repo grep --all-match -e NODE -e Unexpected
 """
-  PARALLEL_JOBS = DEFAULT_LOCAL_JOBS
+    PARALLEL_JOBS = DEFAULT_LOCAL_JOBS
-  @staticmethod
+    @staticmethod
-  def _carry_option(_option, opt_str, value, parser):
+    def _carry_option(_option, opt_str, value, parser):
-    pt = getattr(parser.values, 'cmd_argv', None)
+        pt = getattr(parser.values, "cmd_argv", None)
-    if pt is None:
+        if pt is None:
-      pt = []
+            pt = []
-      setattr(parser.values, 'cmd_argv', pt)
+            setattr(parser.values, "cmd_argv", pt)
-    if opt_str == '-(':
+        if opt_str == "-(":
-      pt.append('(')
+            pt.append("(")
-    elif opt_str == '-)':
+        elif opt_str == "-)":
-      pt.append(')')
+            pt.append(")")
-    else:
+        else:
-      pt.append(opt_str)
+            pt.append(opt_str)
-    if value is not None:
+        if value is not None:
-      pt.append(value)
+            pt.append(value)
-  def _CommonOptions(self, p):
+    def _CommonOptions(self, p):
-    """Override common options slightly."""
+        """Override common options slightly."""
-    super()._CommonOptions(p, opt_v=False)
+        super()._CommonOptions(p, opt_v=False)
-  def _Options(self, p):
+    def _Options(self, p):
-    g = p.add_option_group('Sources')
+        g = p.add_option_group("Sources")
-    g.add_option('--cached',
+        g.add_option(
-                 action='callback', callback=self._carry_option,
+            "--cached",
-                 help='Search the index, instead of the work tree')
+            action="callback",
-    g.add_option('-r', '--revision',
+            callback=self._carry_option,
-                 dest='revision', action='append', metavar='TREEish',
+            help="Search the index, instead of the work tree",
-                 help='Search TREEish, instead of the work tree')
+        )
+        g.add_option(
-    g = p.add_option_group('Pattern')
+            "-r",
-    g.add_option('-e',
+            "--revision",
-                 action='callback', callback=self._carry_option,
+            dest="revision",
-                 metavar='PATTERN', type='str',
+            action="append",
-                 help='Pattern to search for')
+            metavar="TREEish",
-    g.add_option('-i', '--ignore-case',
+            help="Search TREEish, instead of the work tree",
-                 action='callback', callback=self._carry_option,
+        )
-                 help='Ignore case differences')
-    g.add_option('-a', '--text',
+        g = p.add_option_group("Pattern")
-                 action='callback', callback=self._carry_option,
+        g.add_option(
-                 help="Process binary files as if they were text")
+            "-e",
-    g.add_option('-I',
+            action="callback",
-                 action='callback', callback=self._carry_option,
+            callback=self._carry_option,
-                 help="Don't match the pattern in binary files")
+            metavar="PATTERN",
-    g.add_option('-w', '--word-regexp',
+            type="str",
-                 action='callback', callback=self._carry_option,
+            help="Pattern to search for",
-                 help='Match the pattern only at word boundaries')
+        )
-    g.add_option('-v', '--invert-match',
+        g.add_option(
-                 action='callback', callback=self._carry_option,
+            "-i",
-                 help='Select non-matching lines')
+            "--ignore-case",
-    g.add_option('-G', '--basic-regexp',
+            action="callback",
-                 action='callback', callback=self._carry_option,
+            callback=self._carry_option,
-                 help='Use POSIX basic regexp for patterns (default)')
+            help="Ignore case differences",
-    g.add_option('-E', '--extended-regexp',
+        )
-                 action='callback', callback=self._carry_option,
+        g.add_option(
-                 help='Use POSIX extended regexp for patterns')
+            "-a",
-    g.add_option('-F', '--fixed-strings',
+            "--text",
-                 action='callback', callback=self._carry_option,
+            action="callback",
-                 help='Use fixed strings (not regexp) for pattern')
+            callback=self._carry_option,
+            help="Process binary files as if they were text",
-    g = p.add_option_group('Pattern Grouping')
+        )
-    g.add_option('--all-match',
+        g.add_option(
-                 action='callback', callback=self._carry_option,
+            "-I",
-                 help='Limit match to lines that have all patterns')
+            action="callback",
-    g.add_option('--and', '--or', '--not',
+            callback=self._carry_option,
-                 action='callback', callback=self._carry_option,
+            help="Don't match the pattern in binary files",
-                 help='Boolean operators to combine patterns')
+        )
-    g.add_option('-(', '-)',
+        g.add_option(
-                 action='callback', callback=self._carry_option,
+            "-w",
-                 help='Boolean operator grouping')
+            "--word-regexp",
+            action="callback",
-    g = p.add_option_group('Output')
+            callback=self._carry_option,
-    g.add_option('-n',
+            help="Match the pattern only at word boundaries",
-                 action='callback', callback=self._carry_option,
+        )
-                 help='Prefix the line number to matching lines')
+        g.add_option(
-    g.add_option('-C',
+            "-v",
-                 action='callback', callback=self._carry_option,
+            "--invert-match",
-                 metavar='CONTEXT', type='str',
+            action="callback",
-                 help='Show CONTEXT lines around match')
+            callback=self._carry_option,
-    g.add_option('-B',
+            help="Select non-matching lines",
-                 action='callback', callback=self._carry_option,
+        )
-                 metavar='CONTEXT', type='str',
+        g.add_option(
-                 help='Show CONTEXT lines before match')
+            "-G",
-    g.add_option('-A',
+            "--basic-regexp",
-                 action='callback', callback=self._carry_option,
+            action="callback",
-                 metavar='CONTEXT', type='str',
+            callback=self._carry_option,
-                 help='Show CONTEXT lines after match')
+            help="Use POSIX basic regexp for patterns (default)",
-    g.add_option('-l', '--name-only', '--files-with-matches',
+        )
-                 action='callback', callback=self._carry_option,
+        g.add_option(
-                 help='Show only file names containing matching lines')
+            "-E",
-    g.add_option('-L', '--files-without-match',
+            "--extended-regexp",
-                 action='callback', callback=self._carry_option,
+            action="callback",
-                 help='Show only file names not containing matching lines')
+            callback=self._carry_option,
+            help="Use POSIX extended regexp for patterns",
-  def _ExecuteOne(self, cmd_argv, project):
+        )
-    """Process one project."""
+        g.add_option(
-    try:
+            "-F",
-      p = GitCommand(project,
+            "--fixed-strings",
-                     cmd_argv,
+            action="callback",
-                     bare=False,
+            callback=self._carry_option,
-                     capture_stdout=True,
+            help="Use fixed strings (not regexp) for pattern",
-                     capture_stderr=True)
+        )
-    except GitError as e:
-      return (project, -1, None, str(e))
+        g = p.add_option_group("Pattern Grouping")
+        g.add_option(
-    return (project, p.Wait(), p.stdout, p.stderr)
+            "--all-match",
+            action="callback",
-  @staticmethod
+            callback=self._carry_option,
-  def _ProcessResults(full_name, have_rev, opt, _pool, out, results):
+            help="Limit match to lines that have all patterns",
-    git_failed = False
+        )
-    bad_rev = False
+        g.add_option(
-    have_match = False
+            "--and",
-    _RelPath = lambda p: p.RelPath(local=opt.this_manifest_only)
+            "--or",
+            "--not",
-    for project, rc, stdout, stderr in results:
+            action="callback",
-      if rc < 0:
+            callback=self._carry_option,
-        git_failed = True
+            help="Boolean operators to combine patterns",
-        out.project('--- project %s ---' % _RelPath(project))
+        )
-        out.nl()
+        g.add_option(
-        out.fail('%s', stderr)
+            "-(",
-        out.nl()
+            "-)",
-        continue
+            action="callback",
+            callback=self._carry_option,
-      if rc:
+            help="Boolean operator grouping",
-        # no results
+        )
-        if stderr:
-          if have_rev and 'fatal: ambiguous argument' in stderr:
+        g = p.add_option_group("Output")
-            bad_rev = True
+        g.add_option(
-          else:
+            "-n",
-            out.project('--- project %s ---' % _RelPath(project))
+            action="callback",
-            out.nl()
+            callback=self._carry_option,
-            out.fail('%s', stderr.strip())
+            help="Prefix the line number to matching lines",
-            out.nl()
+        )
-        continue
+        g.add_option(
-      have_match = True
+            "-C",
+            action="callback",
-      # We cut the last element, to avoid a blank line.
+            callback=self._carry_option,
-      r = stdout.split('\n')
+            metavar="CONTEXT",
-      r = r[0:-1]
+            type="str",
+            help="Show CONTEXT lines around match",
-      if have_rev and full_name:
+        )
-        for line in r:
+        g.add_option(
-          rev, line = line.split(':', 1)
+            "-B",
-          out.write("%s", rev)
+            action="callback",
-          out.write(':')
+            callback=self._carry_option,
-          out.project(_RelPath(project))
+            metavar="CONTEXT",
-          out.write('/')
+            type="str",
-          out.write("%s", line)
+            help="Show CONTEXT lines before match",
-          out.nl()
+        )
-      elif full_name:
+        g.add_option(
-        for line in r:
+            "-A",
-          out.project(_RelPath(project))
+            action="callback",
-          out.write('/')
+            callback=self._carry_option,
-          out.write("%s", line)
+            metavar="CONTEXT",
-          out.nl()
+            type="str",
-      else:
+            help="Show CONTEXT lines after match",
-        for line in r:
+        )
-          print(line)
+        g.add_option(
+            "-l",
-    return (git_failed, bad_rev, have_match)
+            "--name-only",
+            "--files-with-matches",
-  def Execute(self, opt, args):
+            action="callback",
-    out = GrepColoring(self.manifest.manifestProject.config)
+            callback=self._carry_option,
+            help="Show only file names containing matching lines",
-    cmd_argv = ['grep']
+        )
-    if out.is_on:
+        g.add_option(
-      cmd_argv.append('--color')
+            "-L",
-    cmd_argv.extend(getattr(opt, 'cmd_argv', []))
+            "--files-without-match",
+            action="callback",
-    if '-e' not in cmd_argv:
+            callback=self._carry_option,
-      if not args:
+            help="Show only file names not containing matching lines",
-        self.Usage()
+        )
-      cmd_argv.append('-e')
-      cmd_argv.append(args[0])
+    def _ExecuteOne(self, cmd_argv, project):
-      args = args[1:]
+        """Process one project."""
+        try:
-    projects = self.GetProjects(args, all_manifests=not opt.this_manifest_only)
+            p = GitCommand(
+                project,
-    full_name = False
+                cmd_argv,
-    if len(projects) > 1:
+                bare=False,
-      cmd_argv.append('--full-name')
+                capture_stdout=True,
-      full_name = True
+                capture_stderr=True,
+            )
-    have_rev = False
+        except GitError as e:
-    if opt.revision:
+            return (project, -1, None, str(e))
-      if '--cached' in cmd_argv:
-        print('fatal: cannot combine --cached and --revision', file=sys.stderr)
+        return (project, p.Wait(), p.stdout, p.stderr)
-        sys.exit(1)
-      have_rev = True
+    @staticmethod
-      cmd_argv.extend(opt.revision)
+    def _ProcessResults(full_name, have_rev, opt, _pool, out, results):
-    cmd_argv.append('--')
+        git_failed = False
+        bad_rev = False
-    git_failed, bad_rev, have_match = self.ExecuteInParallel(
+        have_match = False
-        opt.jobs,
+        _RelPath = lambda p: p.RelPath(local=opt.this_manifest_only)
-        functools.partial(self._ExecuteOne, cmd_argv),
-        projects,
+        for project, rc, stdout, stderr in results:
-        callback=functools.partial(self._ProcessResults, full_name, have_rev, opt),
+            if rc < 0:
-        output=out,
+                git_failed = True
-        ordered=True)
+                out.project("--- project %s ---" % _RelPath(project))
+                out.nl()
-    if git_failed:
+                out.fail("%s", stderr)
-      sys.exit(1)
+                out.nl()
-    elif have_match:
+                continue
-      sys.exit(0)
-    elif have_rev and bad_rev:
+            if rc:
-      for r in opt.revision:
+                # no results
-        print("error: can't search revision %s" % r, file=sys.stderr)
+                if stderr:
-      sys.exit(1)
+                    if have_rev and "fatal: ambiguous argument" in stderr:
-    else:
+                        bad_rev = True
-      sys.exit(1)
+                    else:
+                        out.project("--- project %s ---" % _RelPath(project))
+                        out.nl()
+                        out.fail("%s", stderr.strip())
+                        out.nl()
+                continue
+            have_match = True
+            # We cut the last element, to avoid a blank line.
+            r = stdout.split("\n")
+            r = r[0:-1]
+            if have_rev and full_name:
+                for line in r:
+                    rev, line = line.split(":", 1)
+                    out.write("%s", rev)
+                    out.write(":")
+                    out.project(_RelPath(project))
+                    out.write("/")
+                    out.write("%s", line)
+                    out.nl()
+            elif full_name:
+                for line in r:
+                    out.project(_RelPath(project))
+                    out.write("/")
+                    out.write("%s", line)
+                    out.nl()
+            else:
+                for line in r:
+                    print(line)
+        return (git_failed, bad_rev, have_match)
+    def Execute(self, opt, args):
+        out = GrepColoring(self.manifest.manifestProject.config)
+        cmd_argv = ["grep"]
+        if out.is_on:
+            cmd_argv.append("--color")
+        cmd_argv.extend(getattr(opt, "cmd_argv", []))
+        if "-e" not in cmd_argv:
+            if not args:
+                self.Usage()
+            cmd_argv.append("-e")
+            cmd_argv.append(args[0])
+            args = args[1:]
+        projects = self.GetProjects(
+            args, all_manifests=not opt.this_manifest_only
+        )
+        full_name = False
+        if len(projects) > 1:
+            cmd_argv.append("--full-name")
+            full_name = True
+        have_rev = False
+        if opt.revision:
+            if "--cached" in cmd_argv:
+                print(
+                    "fatal: cannot combine --cached and --revision",
+                    file=sys.stderr,
+                )
+                sys.exit(1)
+            have_rev = True
+            cmd_argv.extend(opt.revision)
+        cmd_argv.append("--")
+        git_failed, bad_rev, have_match = self.ExecuteInParallel(
+            opt.jobs,
+            functools.partial(self._ExecuteOne, cmd_argv),
+            projects,
+            callback=functools.partial(
+                self._ProcessResults, full_name, have_rev, opt
+            ),
+            output=out,
+            ordered=True,
+        )
+        if git_failed:
+            sys.exit(1)
+        elif have_match:
+            sys.exit(0)
+        elif have_rev and bad_rev:
+            for r in opt.revision:
+                print("error: can't search revision %s" % r, file=sys.stderr)
+            sys.exit(1)
+        else:
+            sys.exit(1)
diff --git a/subcmds/help.py b/subcmds/help.py
index 1ad391db..50a48047 100644
--- a/subcmds/help.py
+++ b/subcmds/help.py
@@ -18,163 +18,193 @@ import textwrap
 from subcmds import all_commands
 from color import Coloring
-from command import PagedCommand, MirrorSafeCommand, GitcAvailableCommand, GitcClientCommand
+from command import (
+    PagedCommand,
+    MirrorSafeCommand,
+    GitcAvailableCommand,
+    GitcClientCommand,
+)
 import gitc_utils
 from wrapper import Wrapper
 class Help(PagedCommand, MirrorSafeCommand):
-  COMMON = False
+    COMMON = False
-  helpSummary = "Display detailed help on a command"
+    helpSummary = "Display detailed help on a command"
-  helpUsage = """
+    helpUsage = """
 %prog [--all|command]
 """
-  helpDescription = """
+    helpDescription = """
 Displays detailed usage information about a command.
 """
-  def _PrintCommands(self, commandNames):
+    def _PrintCommands(self, commandNames):
-    """Helper to display |commandNames| summaries."""
+        """Helper to display |commandNames| summaries."""
-    maxlen = 0
+        maxlen = 0
-    for name in commandNames:
+        for name in commandNames:
-      maxlen = max(maxlen, len(name))
+            maxlen = max(maxlen, len(name))
-    fmt = '  %%-%ds  %%s' % maxlen
+        fmt = "  %%-%ds  %%s" % maxlen
-    for name in commandNames:
+        for name in commandNames:
-      command = all_commands[name]()
+            command = all_commands[name]()
-      try:
+            try:
-        summary = command.helpSummary.strip()
+                summary = command.helpSummary.strip()
-      except AttributeError:
+            except AttributeError:
-        summary = ''
+                summary = ""
-      print(fmt % (name, summary))
+            print(fmt % (name, summary))
-  def _PrintAllCommands(self):
+    def _PrintAllCommands(self):
-    print('usage: repo COMMAND [ARGS]')
+        print("usage: repo COMMAND [ARGS]")
-    self.PrintAllCommandsBody()
+        self.PrintAllCommandsBody()
-  def PrintAllCommandsBody(self):
+    def PrintAllCommandsBody(self):
-    print('The complete list of recognized repo commands is:')
+        print("The complete list of recognized repo commands is:")
-    commandNames = list(sorted(all_commands))
+        commandNames = list(sorted(all_commands))
-    self._PrintCommands(commandNames)
+        self._PrintCommands(commandNames)
-    print("See 'repo help <command>' for more information on a "
+        print(
-          'specific command.')
+            "See 'repo help <command>' for more information on a "
-    print('Bug reports:', Wrapper().BUG_URL)
+            "specific command."
+        )
-  def _PrintCommonCommands(self):
+        print("Bug reports:", Wrapper().BUG_URL)
-    print('usage: repo COMMAND [ARGS]')
-    self.PrintCommonCommandsBody()
+    def _PrintCommonCommands(self):
+        print("usage: repo COMMAND [ARGS]")
-  def PrintCommonCommandsBody(self):
+        self.PrintCommonCommandsBody()
-    print('The most commonly used repo commands are:')
+    def PrintCommonCommandsBody(self):
-    def gitc_supported(cmd):
+        print("The most commonly used repo commands are:")
-      if not isinstance(cmd, GitcAvailableCommand) and not isinstance(cmd, GitcClientCommand):
-        return True
+        def gitc_supported(cmd):
-      if self.client.isGitcClient:
+            if not isinstance(cmd, GitcAvailableCommand) and not isinstance(
-        return True
+                cmd, GitcClientCommand
-      if isinstance(cmd, GitcClientCommand):
+            ):
-        return False
+                return True
-      if gitc_utils.get_gitc_manifest_dir():
+            if self.client.isGitcClient:
-        return True
+                return True
-      return False
+            if isinstance(cmd, GitcClientCommand):
+                return False
-    commandNames = list(sorted([name
+            if gitc_utils.get_gitc_manifest_dir():
-                                for name, command in all_commands.items()
+                return True
-                                if command.COMMON and gitc_supported(command)]))
+            return False
-    self._PrintCommands(commandNames)
+        commandNames = list(
-    print(
+            sorted(
-        "See 'repo help <command>' for more information on a specific command.\n"
+                [
-        "See 'repo help --all' for a complete list of recognized commands.")
+                    name
-    print('Bug reports:', Wrapper().BUG_URL)
+                    for name, command in all_commands.items()
+                    if command.COMMON and gitc_supported(command)
-  def _PrintCommandHelp(self, cmd, header_prefix=''):
+                ]
-    class _Out(Coloring):
+            )
-      def __init__(self, gc):
+        )
-        Coloring.__init__(self, gc, 'help')
+        self._PrintCommands(commandNames)
-        self.heading = self.printer('heading', attr='bold')
-        self._first = True
+        print(
+            "See 'repo help <command>' for more information on a specific "
-      def _PrintSection(self, heading, bodyAttr):
+            "command.\nSee 'repo help --all' for a complete list of recognized "
-        try:
+            "commands."
-          body = getattr(cmd, bodyAttr)
+        )
-        except AttributeError:
+        print("Bug reports:", Wrapper().BUG_URL)
-          return
-        if body == '' or body is None:
+    def _PrintCommandHelp(self, cmd, header_prefix=""):
-          return
+        class _Out(Coloring):
+            def __init__(self, gc):
-        if not self._first:
+                Coloring.__init__(self, gc, "help")
-          self.nl()
+                self.heading = self.printer("heading", attr="bold")
-        self._first = False
+                self._first = True
-        self.heading('%s%s', header_prefix, heading)
+            def _PrintSection(self, heading, bodyAttr):
-        self.nl()
+                try:
-        self.nl()
+                    body = getattr(cmd, bodyAttr)
+                except AttributeError:
-        me = 'repo %s' % cmd.NAME
+                    return
-        body = body.strip()
+                if body == "" or body is None:
-        body = body.replace('%prog', me)
+                    return
-        # Extract the title, but skip any trailing {#anchors}.
+                if not self._first:
-        asciidoc_hdr = re.compile(r'^\n?#+ ([^{]+)(\{#.+\})?$')
+                    self.nl()
-        for para in body.split("\n\n"):
+                self._first = False
-          if para.startswith(' '):
-            self.write('%s', para)
+                self.heading("%s%s", header_prefix, heading)
-            self.nl()
+                self.nl()
-            self.nl()
+                self.nl()
-            continue
+                me = "repo %s" % cmd.NAME
-          m = asciidoc_hdr.match(para)
+                body = body.strip()
-          if m:
+                body = body.replace("%prog", me)
-            self.heading('%s%s', header_prefix, m.group(1))
-            self.nl()
+                # Extract the title, but skip any trailing {#anchors}.
-            self.nl()
+                asciidoc_hdr = re.compile(r"^\n?#+ ([^{]+)(\{#.+\})?$")
-            continue
+                for para in body.split("\n\n"):
+                    if para.startswith(" "):
-          lines = textwrap.wrap(para.replace('  ', ' '), width=80,
+                        self.write("%s", para)
-                                break_long_words=False, break_on_hyphens=False)
+                        self.nl()
-          for line in lines:
+                        self.nl()
-            self.write('%s', line)
+                        continue
-            self.nl()
-          self.nl()
+                    m = asciidoc_hdr.match(para)
+                    if m:
-    out = _Out(self.client.globalConfig)
+                        self.heading("%s%s", header_prefix, m.group(1))
-    out._PrintSection('Summary', 'helpSummary')
+                        self.nl()
-    cmd.OptionParser.print_help()
+                        self.nl()
-    out._PrintSection('Description', 'helpDescription')
+                        continue
-  def _PrintAllCommandHelp(self):
+                    lines = textwrap.wrap(
-    for name in sorted(all_commands):
+                        para.replace("  ", " "),
-      cmd = all_commands[name](manifest=self.manifest)
+                        width=80,
-      self._PrintCommandHelp(cmd, header_prefix='[%s] ' % (name,))
+                        break_long_words=False,
+                        break_on_hyphens=False,
-  def _Options(self, p):
+                    )
-    p.add_option('-a', '--all',
+                    for line in lines:
-                 dest='show_all', action='store_true',
+                        self.write("%s", line)
-                 help='show the complete list of commands')
+                        self.nl()
-    p.add_option('--help-all',
+                    self.nl()
-                 dest='show_all_help', action='store_true',
-                 help='show the --help of all commands')
+        out = _Out(self.client.globalConfig)
+        out._PrintSection("Summary", "helpSummary")
-  def Execute(self, opt, args):
+        cmd.OptionParser.print_help()
-    if len(args) == 0:
+        out._PrintSection("Description", "helpDescription")
-      if opt.show_all_help:
-        self._PrintAllCommandHelp()
+    def _PrintAllCommandHelp(self):
-      elif opt.show_all:
+        for name in sorted(all_commands):
-        self._PrintAllCommands()
+            cmd = all_commands[name](manifest=self.manifest)
-      else:
+            self._PrintCommandHelp(cmd, header_prefix="[%s] " % (name,))
-        self._PrintCommonCommands()
+    def _Options(self, p):
-    elif len(args) == 1:
+        p.add_option(
-      name = args[0]
+            "-a",
+            "--all",
-      try:
+            dest="show_all",
-        cmd = all_commands[name](manifest=self.manifest)
+            action="store_true",
-      except KeyError:
+            help="show the complete list of commands",
-        print("repo: '%s' is not a repo command." % name, file=sys.stderr)
+        )
-        sys.exit(1)
+        p.add_option(
+            "--help-all",
-      self._PrintCommandHelp(cmd)
+            dest="show_all_help",
+            action="store_true",
-    else:
+            help="show the --help of all commands",
-      self._PrintCommandHelp(self)
+        )
+    def Execute(self, opt, args):
+        if len(args) == 0:
+            if opt.show_all_help:
+                self._PrintAllCommandHelp()
+            elif opt.show_all:
+                self._PrintAllCommands()
+            else:
+                self._PrintCommonCommands()
+        elif len(args) == 1:
+            name = args[0]
+            try:
+                cmd = all_commands[name](manifest=self.manifest)
+            except KeyError:
+                print(
+                    "repo: '%s' is not a repo command." % name, file=sys.stderr
+                )
+                sys.exit(1)
+            self._PrintCommandHelp(cmd)
+        else:
+            self._PrintCommandHelp(self)
diff --git a/subcmds/info.py b/subcmds/info.py
index baa4c5b1..6e7f3ed2 100644
--- a/subcmds/info.py
+++ b/subcmds/info.py
@@ -20,203 +20,234 @@ from git_refs import R_M, R_HEADS
 class _Coloring(Coloring):
-  def __init__(self, config):
+    def __init__(self, config):
-    Coloring.__init__(self, config, "status")
+        Coloring.__init__(self, config, "status")
 class Info(PagedCommand):
-  COMMON = True
+    COMMON = True
-  helpSummary = "Get info on the manifest branch, current branch or unmerged branches"
+    helpSummary = (
-  helpUsage = "%prog [-dl] [-o [-c]] [<project>...]"
+        "Get info on the manifest branch, current branch or unmerged branches"
+    )
-  def _Options(self, p):
+    helpUsage = "%prog [-dl] [-o [-c]] [<project>...]"
-    p.add_option('-d', '--diff',
-                 dest='all', action='store_true',
+    def _Options(self, p):
-                 help="show full info and commit diff including remote branches")
+        p.add_option(
-    p.add_option('-o', '--overview',
+            "-d",
-                 dest='overview', action='store_true',
+            "--diff",
-                 help='show overview of all local commits')
+            dest="all",
-    p.add_option('-c', '--current-branch',
+            action="store_true",
-                 dest="current_branch", action="store_true",
+            help="show full info and commit diff including remote branches",
-                 help="consider only checked out branches")
+        )
-    p.add_option('--no-current-branch',
+        p.add_option(
-                 dest='current_branch', action='store_false',
+            "-o",
-                 help='consider all local branches')
+            "--overview",
-    # Turn this into a warning & remove this someday.
+            dest="overview",
-    p.add_option('-b',
+            action="store_true",
-                 dest='current_branch', action='store_true',
+            help="show overview of all local commits",
-                 help=optparse.SUPPRESS_HELP)
+        )
-    p.add_option('-l', '--local-only',
+        p.add_option(
-                 dest="local", action="store_true",
+            "-c",
-                 help="disable all remote operations")
+            "--current-branch",
+            dest="current_branch",
-  def Execute(self, opt, args):
+            action="store_true",
-    self.out = _Coloring(self.client.globalConfig)
+            help="consider only checked out branches",
-    self.heading = self.out.printer('heading', attr='bold')
+        )
-    self.headtext = self.out.nofmt_printer('headtext', fg='yellow')
+        p.add_option(
-    self.redtext = self.out.printer('redtext', fg='red')
+            "--no-current-branch",
-    self.sha = self.out.printer("sha", fg='yellow')
+            dest="current_branch",
-    self.text = self.out.nofmt_printer('text')
+            action="store_false",
-    self.dimtext = self.out.printer('dimtext', attr='dim')
+            help="consider all local branches",
+        )
-    self.opt = opt
+        # Turn this into a warning & remove this someday.
+        p.add_option(
-    if not opt.this_manifest_only:
+            "-b",
-      self.manifest = self.manifest.outer_client
+            dest="current_branch",
-    manifestConfig = self.manifest.manifestProject.config
+            action="store_true",
-    mergeBranch = manifestConfig.GetBranch("default").merge
+            help=optparse.SUPPRESS_HELP,
-    manifestGroups = self.manifest.GetGroupsStr()
+        )
+        p.add_option(
-    self.heading("Manifest branch: ")
+            "-l",
-    if self.manifest.default.revisionExpr:
+            "--local-only",
-        self.headtext(self.manifest.default.revisionExpr)
+            dest="local",
-    self.out.nl()
+            action="store_true",
-    self.heading("Manifest merge branch: ")
+            help="disable all remote operations",
-    self.headtext(mergeBranch)
+        )
-    self.out.nl()
-    self.heading("Manifest groups: ")
+    def Execute(self, opt, args):
-    self.headtext(manifestGroups)
+        self.out = _Coloring(self.client.globalConfig)
-    self.out.nl()
+        self.heading = self.out.printer("heading", attr="bold")
+        self.headtext = self.out.nofmt_printer("headtext", fg="yellow")
-    self.printSeparator()
+        self.redtext = self.out.printer("redtext", fg="red")
+        self.sha = self.out.printer("sha", fg="yellow")
-    if not opt.overview:
+        self.text = self.out.nofmt_printer("text")
-      self._printDiffInfo(opt, args)
+        self.dimtext = self.out.printer("dimtext", attr="dim")
-    else:
-      self._printCommitOverview(opt, args)
+        self.opt = opt
-  def printSeparator(self):
+        if not opt.this_manifest_only:
-    self.text("----------------------------")
+            self.manifest = self.manifest.outer_client
-    self.out.nl()
+        manifestConfig = self.manifest.manifestProject.config
+        mergeBranch = manifestConfig.GetBranch("default").merge
-  def _printDiffInfo(self, opt, args):
+        manifestGroups = self.manifest.GetGroupsStr()
-    # We let exceptions bubble up to main as they'll be well structured.
-    projs = self.GetProjects(args, all_manifests=not opt.this_manifest_only)
+        self.heading("Manifest branch: ")
+        if self.manifest.default.revisionExpr:
-    for p in projs:
+            self.headtext(self.manifest.default.revisionExpr)
-      self.heading("Project: ")
+        self.out.nl()
-      self.headtext(p.name)
+        self.heading("Manifest merge branch: ")
-      self.out.nl()
+        self.headtext(mergeBranch)
+        self.out.nl()
-      self.heading("Mount path: ")
+        self.heading("Manifest groups: ")
-      self.headtext(p.worktree)
+        self.headtext(manifestGroups)
-      self.out.nl()
+        self.out.nl()
-      self.heading("Current revision: ")
+        self.printSeparator()
-      self.headtext(p.GetRevisionId())
-      self.out.nl()
+        if not opt.overview:
+            self._printDiffInfo(opt, args)
-      currentBranch = p.CurrentBranch
+        else:
-      if currentBranch:
+            self._printCommitOverview(opt, args)
-        self.heading('Current branch: ')
-        self.headtext(currentBranch)
+    def printSeparator(self):
+        self.text("----------------------------")
        self.out.nl()
-      self.heading("Manifest revision: ")
+    def _printDiffInfo(self, opt, args):
-      self.headtext(p.revisionExpr)
+        # We let exceptions bubble up to main as they'll be well structured.
-      self.out.nl()
+        projs = self.GetProjects(args, all_manifests=not opt.this_manifest_only)
-      localBranches = list(p.GetBranches().keys())
+        for p in projs:
-      self.heading("Local Branches: ")
+            self.heading("Project: ")
-      self.redtext(str(len(localBranches)))
+            self.headtext(p.name)
-      if localBranches:
+            self.out.nl()
-        self.text(" [")
-        self.text(", ".join(localBranches))
+            self.heading("Mount path: ")
-        self.text("]")
+            self.headtext(p.worktree)
-      self.out.nl()
+            self.out.nl()
-      if self.opt.all:
+            self.heading("Current revision: ")
-        self.findRemoteLocalDiff(p)
+            self.headtext(p.GetRevisionId())
+            self.out.nl()
-      self.printSeparator()
+            currentBranch = p.CurrentBranch
-  def findRemoteLocalDiff(self, project):
+            if currentBranch:
-    # Fetch all the latest commits.
+                self.heading("Current branch: ")
-    if not self.opt.local:
+                self.headtext(currentBranch)
-      project.Sync_NetworkHalf(quiet=True, current_branch_only=True)
+                self.out.nl()
-    branch = self.manifest.manifestProject.config.GetBranch('default').merge
+            self.heading("Manifest revision: ")
-    if branch.startswith(R_HEADS):
+            self.headtext(p.revisionExpr)
-      branch = branch[len(R_HEADS):]
+            self.out.nl()
-    logTarget = R_M + branch
+            localBranches = list(p.GetBranches().keys())
-    bareTmp = project.bare_git._bare
+            self.heading("Local Branches: ")
-    project.bare_git._bare = False
+            self.redtext(str(len(localBranches)))
-    localCommits = project.bare_git.rev_list(
+            if localBranches:
-        '--abbrev=8',
+                self.text(" [")
-        '--abbrev-commit',
+                self.text(", ".join(localBranches))
-        '--pretty=oneline',
+                self.text("]")
-        logTarget + "..",
+            self.out.nl()
-        '--')
+            if self.opt.all:
-    originCommits = project.bare_git.rev_list(
+                self.findRemoteLocalDiff(p)
-        '--abbrev=8',
-        '--abbrev-commit',
+            self.printSeparator()
-        '--pretty=oneline',
-        ".." + logTarget,
+    def findRemoteLocalDiff(self, project):
-        '--')
+        # Fetch all the latest commits.
-    project.bare_git._bare = bareTmp
+        if not self.opt.local:
+            project.Sync_NetworkHalf(quiet=True, current_branch_only=True)
-    self.heading("Local Commits: ")
-    self.redtext(str(len(localCommits)))
+        branch = self.manifest.manifestProject.config.GetBranch("default").merge
-    self.dimtext(" (on current branch)")
+        if branch.startswith(R_HEADS):
-    self.out.nl()
+            branch = branch[len(R_HEADS) :]
+        logTarget = R_M + branch
-    for c in localCommits:
-      split = c.split()
+        bareTmp = project.bare_git._bare
-      self.sha(split[0] + " ")
+        project.bare_git._bare = False
-      self.text(" ".join(split[1:]))
+        localCommits = project.bare_git.rev_list(
-      self.out.nl()
+            "--abbrev=8",
+            "--abbrev-commit",
-    self.printSeparator()
+            "--pretty=oneline",
+            logTarget + "..",
-    self.heading("Remote Commits: ")
+            "--",
-    self.redtext(str(len(originCommits)))
+        )
-    self.out.nl()
+        originCommits = project.bare_git.rev_list(
-    for c in originCommits:
+            "--abbrev=8",
-      split = c.split()
+            "--abbrev-commit",
-      self.sha(split[0] + " ")
+            "--pretty=oneline",
-      self.text(" ".join(split[1:]))
+            ".." + logTarget,
-      self.out.nl()
+            "--",
+        )
-  def _printCommitOverview(self, opt, args):
+        project.bare_git._bare = bareTmp
-    all_branches = []
-    for project in self.GetProjects(args, all_manifests=not opt.this_manifest_only):
+        self.heading("Local Commits: ")
-      br = [project.GetUploadableBranch(x)
+        self.redtext(str(len(localCommits)))
-            for x in project.GetBranches()]
+        self.dimtext(" (on current branch)")
-      br = [x for x in br if x]
-      if self.opt.current_branch:
-        br = [x for x in br if x.name == project.CurrentBranch]
-      all_branches.extend(br)
-    if not all_branches:
-      return
-    self.out.nl()
-    self.heading('Projects Overview')
-    project = None
-    for branch in all_branches:
-      if project != branch.project:
-        project = branch.project
        self.out.nl()
-        self.headtext(project.RelPath(local=opt.this_manifest_only))
+        for c in localCommits:
+            split = c.split()
+            self.sha(split[0] + " ")
+            self.text(" ".join(split[1:]))
+            self.out.nl()
+        self.printSeparator()
+        self.heading("Remote Commits: ")
+        self.redtext(str(len(originCommits)))
        self.out.nl()
-      commits = branch.commits
+        for c in originCommits:
-      date = branch.date
+            split = c.split()
-      self.text('%s %-33s (%2d commit%s, %s)' % (
+            self.sha(split[0] + " ")
-          branch.name == project.CurrentBranch and '*' or ' ',
+            self.text(" ".join(split[1:]))
-          branch.name,
+            self.out.nl()
-          len(commits),
-          len(commits) != 1 and 's' or '',
+    def _printCommitOverview(self, opt, args):
-          date))
+        all_branches = []
-      self.out.nl()
+        for project in self.GetProjects(
+            args, all_manifests=not opt.this_manifest_only
-      for commit in commits:
+        ):
-        split = commit.split()
+            br = [project.GetUploadableBranch(x) for x in project.GetBranches()]
-        self.text('{0:38}{1} '.format('', '-'))
+            br = [x for x in br if x]
-        self.sha(split[0] + " ")
+            if self.opt.current_branch:
-        self.text(" ".join(split[1:]))
+                br = [x for x in br if x.name == project.CurrentBranch]
+            all_branches.extend(br)
+        if not all_branches:
+            return
        self.out.nl()
+        self.heading("Projects Overview")
+        project = None
+        for branch in all_branches:
+            if project != branch.project:
+                project = branch.project
+                self.out.nl()
+                self.headtext(project.RelPath(local=opt.this_manifest_only))
+                self.out.nl()
+            commits = branch.commits
+            date = branch.date
+            self.text(
+                "%s %-33s (%2d commit%s, %s)"
+                % (
+                    branch.name == project.CurrentBranch and "*" or " ",
+                    branch.name,
+                    len(commits),
+                    len(commits) != 1 and "s" or "",
+                    date,
+                )
+            )
+            self.out.nl()
+            for commit in commits:
+                split = commit.split()
+                self.text("{0:38}{1} ".format("", "-"))
+                self.sha(split[0] + " ")
+                self.text(" ".join(split[1:]))
+                self.out.nl()
diff --git a/subcmds/init.py b/subcmds/init.py
index 813fa590..b5c2e3b5 100644
--- a/subcmds/init.py
+++ b/subcmds/init.py
@@ -22,13 +22,13 @@ from wrapper import Wrapper
 class Init(InteractiveCommand, MirrorSafeCommand):
-  COMMON = True
+    COMMON = True
-  MULTI_MANIFEST_SUPPORT = True
+    MULTI_MANIFEST_SUPPORT = True
-  helpSummary = "Initialize a repo client checkout in the current directory"
+    helpSummary = "Initialize a repo client checkout in the current directory"
-  helpUsage = """
+    helpUsage = """
 %prog [options] [manifest url]
 """
-  helpDescription = """
+    helpDescription = """
 The '%prog' command is run once to install and initialize repo.
 The latest repo source code and manifest collection is downloaded
 from the server and is installed in the .repo/ directory in the
@@ -77,243 +77,303 @@ manifest, a subsequent `repo sync` (or `repo sync -d`) is necessary
 to update the working directory files.
 """
-  def _CommonOptions(self, p):
+    def _CommonOptions(self, p):
-    """Disable due to re-use of Wrapper()."""
+        """Disable due to re-use of Wrapper()."""
-  def _Options(self, p, gitc_init=False):
+    def _Options(self, p, gitc_init=False):
-    Wrapper().InitParser(p, gitc_init=gitc_init)
+        Wrapper().InitParser(p, gitc_init=gitc_init)
-    m = p.add_option_group('Multi-manifest')
+        m = p.add_option_group("Multi-manifest")
-    m.add_option('--outer-manifest', action='store_true', default=True,
+        m.add_option(
-                 help='operate starting at the outermost manifest')
+            "--outer-manifest",
-    m.add_option('--no-outer-manifest', dest='outer_manifest',
+            action="store_true",
-                 action='store_false', help='do not operate on outer manifests')
+            default=True,
-    m.add_option('--this-manifest-only', action='store_true', default=None,
+            help="operate starting at the outermost manifest",
-                 help='only operate on this (sub)manifest')
+        )
-    m.add_option('--no-this-manifest-only', '--all-manifests',
+        m.add_option(
-                 dest='this_manifest_only', action='store_false',
+            "--no-outer-manifest",
-                 help='operate on this manifest and its submanifests')
+            dest="outer_manifest",
+            action="store_false",
-  def _RegisteredEnvironmentOptions(self):
+            help="do not operate on outer manifests",
-    return {'REPO_MANIFEST_URL': 'manifest_url',
+        )
-            'REPO_MIRROR_LOCATION': 'reference'}
+        m.add_option(
+            "--this-manifest-only",
-  def _SyncManifest(self, opt):
+            action="store_true",
-    """Call manifestProject.Sync with arguments from opt.
+            default=None,
+            help="only operate on this (sub)manifest",
-    Args:
+        )
-      opt: options from optparse.
+        m.add_option(
-    """
+            "--no-this-manifest-only",
-    # Normally this value is set when instantiating the project, but the
+            "--all-manifests",
-    # manifest project is special and is created when instantiating the
+            dest="this_manifest_only",
-    # manifest which happens before we parse options.
+            action="store_false",
-    self.manifest.manifestProject.clone_depth = opt.manifest_depth
+            help="operate on this manifest and its submanifests",
-    if not self.manifest.manifestProject.Sync(
+        )
-        manifest_url=opt.manifest_url,
-        manifest_branch=opt.manifest_branch,
+    def _RegisteredEnvironmentOptions(self):
-        standalone_manifest=opt.standalone_manifest,
+        return {
-        groups=opt.groups,
+            "REPO_MANIFEST_URL": "manifest_url",
-        platform=opt.platform,
+            "REPO_MIRROR_LOCATION": "reference",
-        mirror=opt.mirror,
+        }
-        dissociate=opt.dissociate,
-        reference=opt.reference,
+    def _SyncManifest(self, opt):
-        worktree=opt.worktree,
+        """Call manifestProject.Sync with arguments from opt.
-        submodules=opt.submodules,
-        archive=opt.archive,
+        Args:
-        partial_clone=opt.partial_clone,
+            opt: options from optparse.
-        clone_filter=opt.clone_filter,
+        """
-        partial_clone_exclude=opt.partial_clone_exclude,
+        # Normally this value is set when instantiating the project, but the
-        clone_bundle=opt.clone_bundle,
+        # manifest project is special and is created when instantiating the
-        git_lfs=opt.git_lfs,
+        # manifest which happens before we parse options.
-        use_superproject=opt.use_superproject,
+        self.manifest.manifestProject.clone_depth = opt.manifest_depth
-        verbose=opt.verbose,
+        if not self.manifest.manifestProject.Sync(
-        current_branch_only=opt.current_branch_only,
+            manifest_url=opt.manifest_url,
-        tags=opt.tags,
+            manifest_branch=opt.manifest_branch,
-        depth=opt.depth,
+            standalone_manifest=opt.standalone_manifest,
-        git_event_log=self.git_event_log,
+            groups=opt.groups,
-        manifest_name=opt.manifest_name):
+            platform=opt.platform,
-      sys.exit(1)
+            mirror=opt.mirror,
+            dissociate=opt.dissociate,
-  def _Prompt(self, prompt, value):
+            reference=opt.reference,
-    print('%-10s [%s]: ' % (prompt, value), end='', flush=True)
+            worktree=opt.worktree,
-    a = sys.stdin.readline().strip()
+            submodules=opt.submodules,
-    if a == '':
+            archive=opt.archive,
-      return value
+            partial_clone=opt.partial_clone,
-    return a
+            clone_filter=opt.clone_filter,
+            partial_clone_exclude=opt.partial_clone_exclude,
-  def _ShouldConfigureUser(self, opt, existing_checkout):
+            clone_bundle=opt.clone_bundle,
-    gc = self.client.globalConfig
+            git_lfs=opt.git_lfs,
-    mp = self.manifest.manifestProject
+            use_superproject=opt.use_superproject,
+            verbose=opt.verbose,
-    # If we don't have local settings, get from global.
+            current_branch_only=opt.current_branch_only,
-    if not mp.config.Has('user.name') or not mp.config.Has('user.email'):
+            tags=opt.tags,
-      if not gc.Has('user.name') or not gc.Has('user.email'):
+            depth=opt.depth,
-        return True
+            git_event_log=self.git_event_log,
+            manifest_name=opt.manifest_name,
-      mp.config.SetString('user.name', gc.GetString('user.name'))
+        ):
-      mp.config.SetString('user.email', gc.GetString('user.email'))
+            sys.exit(1)
-    if not opt.quiet and not existing_checkout or opt.verbose:
+    def _Prompt(self, prompt, value):
-      print()
+        print("%-10s [%s]: " % (prompt, value), end="", flush=True)
-      print('Your identity is: %s <%s>' % (mp.config.GetString('user.name'),
+        a = sys.stdin.readline().strip()
-                                           mp.config.GetString('user.email')))
+        if a == "":
-      print("If you want to change this, please re-run 'repo init' with --config-name")
+            return value
-    return False
+        return a
-  def _ConfigureUser(self, opt):
+    def _ShouldConfigureUser(self, opt, existing_checkout):
-    mp = self.manifest.manifestProject
+        gc = self.client.globalConfig
+        mp = self.manifest.manifestProject
-    while True:
-      if not opt.quiet:
+        # If we don't have local settings, get from global.
+        if not mp.config.Has("user.name") or not mp.config.Has("user.email"):
+            if not gc.Has("user.name") or not gc.Has("user.email"):
+                return True
+            mp.config.SetString("user.name", gc.GetString("user.name"))
+            mp.config.SetString("user.email", gc.GetString("user.email"))
+        if not opt.quiet and not existing_checkout or opt.verbose:
+            print()
+            print(
+                "Your identity is: %s <%s>"
+                % (
+                    mp.config.GetString("user.name"),
+                    mp.config.GetString("user.email"),
+                )
+            )
+            print(
+                "If you want to change this, please re-run 'repo init' with "
+                "--config-name"
+            )
+        return False
+    def _ConfigureUser(self, opt):
+        mp = self.manifest.manifestProject
+        while True:
+            if not opt.quiet:
+                print()
+            name = self._Prompt("Your Name", mp.UserName)
+            email = self._Prompt("Your Email", mp.UserEmail)
+            if not opt.quiet:
+                print()
+            print("Your identity is: %s <%s>" % (name, email))
+            print("is this correct [y/N]? ", end="", flush=True)
+            a = sys.stdin.readline().strip().lower()
+            if a in ("yes", "y", "t", "true"):
+                break
+        if name != mp.UserName:
+            mp.config.SetString("user.name", name)
+        if email != mp.UserEmail:
+            mp.config.SetString("user.email", email)
+    def _HasColorSet(self, gc):
+        for n in ["ui", "diff", "status"]:
+            if gc.Has("color.%s" % n):
+                return True
+        return False
+    def _ConfigureColor(self):
+        gc = self.client.globalConfig
+        if self._HasColorSet(gc):
+            return
+        class _Test(Coloring):
+            def __init__(self):
+                Coloring.__init__(self, gc, "test color display")
+                self._on = True
+        out = _Test()
        print()
-      name = self._Prompt('Your Name', mp.UserName)
+        print("Testing colorized output (for 'repo diff', 'repo status'):")
-      email = self._Prompt('Your Email', mp.UserEmail)
+        for c in ["black", "red", "green", "yellow", "blue", "magenta", "cyan"]:
+            out.write(" ")
+            out.printer(fg=c)(" %-6s ", c)
+        out.write(" ")
+        out.printer(fg="white", bg="black")(" %s " % "white")
+        out.nl()
+        for c in ["bold", "dim", "ul", "reverse"]:
+            out.write(" ")
+            out.printer(fg="black", attr=c)(" %-6s ", c)
+        out.nl()
+        print(
+            "Enable color display in this user account (y/N)? ",
+            end="",
+            flush=True,
+        )
+        a = sys.stdin.readline().strip().lower()
+        if a in ("y", "yes", "t", "true", "on"):
+            gc.SetString("color.ui", "auto")
+    def _DisplayResult(self):
+        if self.manifest.IsMirror:
+            init_type = "mirror "
+        else:
+            init_type = ""
-      if not opt.quiet:
        print()
-      print('Your identity is: %s <%s>' % (name, email))
+        print(
-      print('is this correct [y/N]? ', end='', flush=True)
+            "repo %shas been initialized in %s"
-      a = sys.stdin.readline().strip().lower()
+            % (init_type, self.manifest.topdir)
-      if a in ('yes', 'y', 't', 'true'):
+        )
-        break
+        current_dir = os.getcwd()
-    if name != mp.UserName:
+        if current_dir != self.manifest.topdir:
-      mp.config.SetString('user.name', name)
+            print(
-    if email != mp.UserEmail:
+                "If this is not the directory in which you want to initialize "
-      mp.config.SetString('user.email', email)
+                "repo, please run:"
+            )
-  def _HasColorSet(self, gc):
+            print("   rm -r %s" % os.path.join(self.manifest.topdir, ".repo"))
-    for n in ['ui', 'diff', 'status']:
+            print("and try again.")
-      if gc.Has('color.%s' % n):
-        return True
+    def ValidateOptions(self, opt, args):
-    return False
+        if opt.reference:
+            opt.reference = os.path.expanduser(opt.reference)
-  def _ConfigureColor(self):
-    gc = self.client.globalConfig
+        # Check this here, else manifest will be tagged "not new" and init won't
-    if self._HasColorSet(gc):
+        # be possible anymore without removing the .repo/manifests directory.
-      return
+        if opt.mirror:
+            if opt.archive:
-    class _Test(Coloring):
+                self.OptionParser.error(
-      def __init__(self):
+                    "--mirror and --archive cannot be used " "together."
-        Coloring.__init__(self, gc, 'test color display')
+                )
-        self._on = True
+            if opt.use_superproject is not None:
-    out = _Test()
+                self.OptionParser.error(
+                    "--mirror and --use-superproject cannot be "
-    print()
+                    "used together."
-    print("Testing colorized output (for 'repo diff', 'repo status'):")
+                )
+        if opt.archive and opt.use_superproject is not None:
-    for c in ['black', 'red', 'green', 'yellow', 'blue', 'magenta', 'cyan']:
+            self.OptionParser.error(
-      out.write(' ')
+                "--archive and --use-superproject cannot be used " "together."
-      out.printer(fg=c)(' %-6s ', c)
+            )
-    out.write(' ')
-    out.printer(fg='white', bg='black')(' %s ' % 'white')
+        if opt.standalone_manifest and (
-    out.nl()
+            opt.manifest_branch or opt.manifest_name != "default.xml"
+        ):
-    for c in ['bold', 'dim', 'ul', 'reverse']:
+            self.OptionParser.error(
-      out.write(' ')
+                "--manifest-branch and --manifest-name cannot"
-      out.printer(fg='black', attr=c)(' %-6s ', c)
+                " be used with --standalone-manifest."
-    out.nl()
+            )
-    print('Enable color display in this user account (y/N)? ', end='', flush=True)
+        if args:
-    a = sys.stdin.readline().strip().lower()
+            if opt.manifest_url:
-    if a in ('y', 'yes', 't', 'true', 'on'):
+                self.OptionParser.error(
-      gc.SetString('color.ui', 'auto')
+                    "--manifest-url option and URL argument both specified: "
+                    "only use one to select the manifest URL."
-  def _DisplayResult(self):
+                )
-    if self.manifest.IsMirror:
-      init_type = 'mirror '
+            opt.manifest_url = args.pop(0)
-    else:
-      init_type = ''
+            if args:
+                self.OptionParser.error("too many arguments to init")
-    print()
-    print('repo %shas been initialized in %s' % (init_type, self.manifest.topdir))
+    def Execute(self, opt, args):
+        git_require(MIN_GIT_VERSION_HARD, fail=True)
-    current_dir = os.getcwd()
+        if not git_require(MIN_GIT_VERSION_SOFT):
-    if current_dir != self.manifest.topdir:
+            print(
-      print('If this is not the directory in which you want to initialize '
+                "repo: warning: git-%s+ will soon be required; please upgrade "
-            'repo, please run:')
+                "your version of git to maintain support."
-      print('   rm -r %s' % os.path.join(self.manifest.topdir, '.repo'))
+                % (".".join(str(x) for x in MIN_GIT_VERSION_SOFT),),
-      print('and try again.')
+                file=sys.stderr,
+            )
-  def ValidateOptions(self, opt, args):
-    if opt.reference:
+        rp = self.manifest.repoProject
-      opt.reference = os.path.expanduser(opt.reference)
+        # Handle new --repo-url requests.
-    # Check this here, else manifest will be tagged "not new" and init won't be
+        if opt.repo_url:
-    # possible anymore without removing the .repo/manifests directory.
+            remote = rp.GetRemote("origin")
-    if opt.mirror:
+            remote.url = opt.repo_url
-      if opt.archive:
+            remote.Save()
-        self.OptionParser.error('--mirror and --archive cannot be used '
-                                'together.')
+        # Handle new --repo-rev requests.
-      if opt.use_superproject is not None:
+        if opt.repo_rev:
-        self.OptionParser.error('--mirror and --use-superproject cannot be '
+            wrapper = Wrapper()
-                                'used together.')
+            try:
-    if opt.archive and opt.use_superproject is not None:
+                remote_ref, rev = wrapper.check_repo_rev(
-      self.OptionParser.error('--archive and --use-superproject cannot be used '
+                    rp.gitdir,
-                              'together.')
+                    opt.repo_rev,
+                    repo_verify=opt.repo_verify,
-    if opt.standalone_manifest and (opt.manifest_branch or
+                    quiet=opt.quiet,
-                                    opt.manifest_name != 'default.xml'):
+                )
-      self.OptionParser.error('--manifest-branch and --manifest-name cannot'
+            except wrapper.CloneFailure:
-                              ' be used with --standalone-manifest.')
+                print(
+                    "fatal: double check your --repo-rev setting.",
-    if args:
+                    file=sys.stderr,
-      if opt.manifest_url:
+                )
-        self.OptionParser.error(
+                sys.exit(1)
-            '--manifest-url option and URL argument both specified: only use '
+            branch = rp.GetBranch("default")
-            'one to select the manifest URL.')
+            branch.merge = remote_ref
+            rp.work_git.reset("--hard", rev)
-      opt.manifest_url = args.pop(0)
+            branch.Save()
-      if args:
+        if opt.worktree:
-        self.OptionParser.error('too many arguments to init')
+            # Older versions of git supported worktree, but had dangerous gc
+            # bugs.
-  def Execute(self, opt, args):
+            git_require((2, 15, 0), fail=True, msg="git gc worktree corruption")
-    git_require(MIN_GIT_VERSION_HARD, fail=True)
-    if not git_require(MIN_GIT_VERSION_SOFT):
+        # Provide a short notice that we're reinitializing an existing checkout.
-      print('repo: warning: git-%s+ will soon be required; please upgrade your '
+        # Sometimes developers might not realize that they're in one, or that
-            'version of git to maintain support.'
+        # repo doesn't do nested checkouts.
-            % ('.'.join(str(x) for x in MIN_GIT_VERSION_SOFT),),
+        existing_checkout = self.manifest.manifestProject.Exists
-            file=sys.stderr)
+        if not opt.quiet and existing_checkout:
+            print(
-    rp = self.manifest.repoProject
+                "repo: reusing existing repo client checkout in",
+                self.manifest.topdir,
-    # Handle new --repo-url requests.
+            )
-    if opt.repo_url:
-      remote = rp.GetRemote('origin')
+        self._SyncManifest(opt)
-      remote.url = opt.repo_url
-      remote.Save()
+        if os.isatty(0) and os.isatty(1) and not self.manifest.IsMirror:
+            if opt.config_name or self._ShouldConfigureUser(
-    # Handle new --repo-rev requests.
+                opt, existing_checkout
-    if opt.repo_rev:
+            ):
-      wrapper = Wrapper()
+                self._ConfigureUser(opt)
-      try:
+            self._ConfigureColor()
-        remote_ref, rev = wrapper.check_repo_rev(
-            rp.gitdir, opt.repo_rev, repo_verify=opt.repo_verify, quiet=opt.quiet)
+        if not opt.quiet:
-      except wrapper.CloneFailure:
+            self._DisplayResult()
-        print('fatal: double check your --repo-rev setting.', file=sys.stderr)
-        sys.exit(1)
-      branch = rp.GetBranch('default')
-      branch.merge = remote_ref
-      rp.work_git.reset('--hard', rev)
-      branch.Save()
-    if opt.worktree:
-      # Older versions of git supported worktree, but had dangerous gc bugs.
-      git_require((2, 15, 0), fail=True, msg='git gc worktree corruption')
-    # Provide a short notice that we're reinitializing an existing checkout.
-    # Sometimes developers might not realize that they're in one, or that
-    # repo doesn't do nested checkouts.
-    existing_checkout = self.manifest.manifestProject.Exists
-    if not opt.quiet and existing_checkout:
-      print('repo: reusing existing repo client checkout in', self.manifest.topdir)
-    self._SyncManifest(opt)
-    if os.isatty(0) and os.isatty(1) and not self.manifest.IsMirror:
-      if opt.config_name or self._ShouldConfigureUser(opt, existing_checkout):
-        self._ConfigureUser(opt)
-      self._ConfigureColor()
-    if not opt.quiet:
-      self._DisplayResult()
diff --git a/subcmds/list.py b/subcmds/list.py
index ad8036ee..24e3e1fc 100644
--- a/subcmds/list.py
+++ b/subcmds/list.py
@@ -18,13 +18,13 @@ from command import Command, MirrorSafeCommand
 class List(Command, MirrorSafeCommand):
-  COMMON = True
+    COMMON = True
-  helpSummary = "List projects and their associated directories"
+    helpSummary = "List projects and their associated directories"
-  helpUsage = """
+    helpUsage = """
 %prog [-f] [<project>...]
 %prog [-f] -r str1 [str2]...
 """
-  helpDescription = """
+    helpDescription = """
 List all projects; pass '.' to list the project for the cwd.
 By default, only projects that currently exist in the checkout are shown.  If
@@ -35,69 +35,103 @@ groups, then also pass --groups all.
 This is similar to running: repo forall -c 'echo "$REPO_PATH : $REPO_PROJECT"'.
 """
-  def _Options(self, p):
+    def _Options(self, p):
-    p.add_option('-r', '--regex',
+        p.add_option(
-                 dest='regex', action='store_true',
+            "-r",
-                 help='filter the project list based on regex or wildcard matching of strings')
+            "--regex",
-    p.add_option('-g', '--groups',
+            dest="regex",
-                 dest='groups',
+            action="store_true",
-                 help='filter the project list based on the groups the project is in')
+            help="filter the project list based on regex or wildcard matching "
-    p.add_option('-a', '--all',
+            "of strings",
-                 action='store_true',
+        )
-                 help='show projects regardless of checkout state')
+        p.add_option(
-    p.add_option('-n', '--name-only',
+            "-g",
-                 dest='name_only', action='store_true',
+            "--groups",
-                 help='display only the name of the repository')
+            dest="groups",
-    p.add_option('-p', '--path-only',
+            help="filter the project list based on the groups the project is "
-                 dest='path_only', action='store_true',
+            "in",
-                 help='display only the path of the repository')
+        )
-    p.add_option('-f', '--fullpath',
+        p.add_option(
-                 dest='fullpath', action='store_true',
+            "-a",
-                 help='display the full work tree path instead of the relative path')
+            "--all",
-    p.add_option('--relative-to', metavar='PATH',
+            action="store_true",
-                 help='display paths relative to this one (default: top of repo client checkout)')
+            help="show projects regardless of checkout state",
+        )
+        p.add_option(
+            "-n",
+            "--name-only",
+            dest="name_only",
+            action="store_true",
+            help="display only the name of the repository",
+        )
+        p.add_option(
+            "-p",
+            "--path-only",
+            dest="path_only",
+            action="store_true",
+            help="display only the path of the repository",
+        )
+        p.add_option(
+            "-f",
+            "--fullpath",
+            dest="fullpath",
+            action="store_true",
+            help="display the full work tree path instead of the relative path",
+        )
+        p.add_option(
+            "--relative-to",
+            metavar="PATH",
+            help="display paths relative to this one (default: top of repo "
+            "client checkout)",
+        )
-  def ValidateOptions(self, opt, args):
+    def ValidateOptions(self, opt, args):
-    if opt.fullpath and opt.name_only:
+        if opt.fullpath and opt.name_only:
-      self.OptionParser.error('cannot combine -f and -n')
+            self.OptionParser.error("cannot combine -f and -n")
-    # Resolve any symlinks so the output is stable.
+        # Resolve any symlinks so the output is stable.
-    if opt.relative_to:
+        if opt.relative_to:
-      opt.relative_to = os.path.realpath(opt.relative_to)
+            opt.relative_to = os.path.realpath(opt.relative_to)
-  def Execute(self, opt, args):
+    def Execute(self, opt, args):
-    """List all projects and the associated directories.
+        """List all projects and the associated directories.
-    This may be possible to do with 'repo forall', but repo newbies have
+        This may be possible to do with 'repo forall', but repo newbies have
-    trouble figuring that out.  The idea here is that it should be more
+        trouble figuring that out.  The idea here is that it should be more
-    discoverable.
+        discoverable.
-    Args:
+        Args:
-      opt: The options.
+            opt: The options.
-      args: Positional args.  Can be a list of projects to list, or empty.
+            args: Positional args.  Can be a list of projects to list, or empty.
-    """
+        """
-    if not opt.regex:
+        if not opt.regex:
-      projects = self.GetProjects(args, groups=opt.groups, missing_ok=opt.all,
+            projects = self.GetProjects(
-                                  all_manifests=not opt.this_manifest_only)
+                args,
-    else:
+                groups=opt.groups,
-      projects = self.FindProjects(args, all_manifests=not opt.this_manifest_only)
+                missing_ok=opt.all,
+                all_manifests=not opt.this_manifest_only,
+            )
+        else:
+            projects = self.FindProjects(
+                args, all_manifests=not opt.this_manifest_only
+            )
-    def _getpath(x):
+        def _getpath(x):
-      if opt.fullpath:
+            if opt.fullpath:
-        return x.worktree
+                return x.worktree
-      if opt.relative_to:
+            if opt.relative_to:
-        return os.path.relpath(x.worktree, opt.relative_to)
+                return os.path.relpath(x.worktree, opt.relative_to)
-      return x.RelPath(local=opt.this_manifest_only)
+            return x.RelPath(local=opt.this_manifest_only)
-    lines = []
+        lines = []
-    for project in projects:
+        for project in projects:
-      if opt.name_only and not opt.path_only:
+            if opt.name_only and not opt.path_only:
-        lines.append("%s" % (project.name))
+                lines.append("%s" % (project.name))
-      elif opt.path_only and not opt.name_only:
+            elif opt.path_only and not opt.name_only:
-        lines.append("%s" % (_getpath(project)))
+                lines.append("%s" % (_getpath(project)))
-      else:
+            else:
-        lines.append("%s : %s" % (_getpath(project), project.name))
+                lines.append("%s : %s" % (_getpath(project), project.name))
-    if lines:
+        if lines:
-      lines.sort()
+            lines.sort()
-      print('\n'.join(lines))
+            print("\n".join(lines))
diff --git a/subcmds/manifest.py b/subcmds/manifest.py
index f4602a59..f72df348 100644
--- a/subcmds/manifest.py
+++ b/subcmds/manifest.py
@@ -20,12 +20,12 @@ from command import PagedCommand
 class Manifest(PagedCommand):
-  COMMON = False
+    COMMON = False
-  helpSummary = "Manifest inspection utility"
+    helpSummary = "Manifest inspection utility"
-  helpUsage = """
+    helpUsage = """
 %prog [-o {-|NAME.xml}] [-m MANIFEST.xml] [-r]
 """
-  _helpDescription = """
+    _helpDescription = """
 With the -o option, exports the current manifest for inspection.
 The manifest and (if present) local_manifests/ are combined
@@ -40,92 +40,136 @@ when the manifest was generated.  The 'dest-branch' attribute is set
 to indicate the remote ref to push changes to via 'repo upload'.
 """
-  @property
+    @property
-  def helpDescription(self):
+    def helpDescription(self):
-    helptext = self._helpDescription + '\n'
+        helptext = self._helpDescription + "\n"
-    r = os.path.dirname(__file__)
+        r = os.path.dirname(__file__)
-    r = os.path.dirname(r)
+        r = os.path.dirname(r)
-    with open(os.path.join(r, 'docs', 'manifest-format.md')) as fd:
+        with open(os.path.join(r, "docs", "manifest-format.md")) as fd:
-      for line in fd:
+            for line in fd:
-        helptext += line
+                helptext += line
-    return helptext
+        return helptext
-  def _Options(self, p):
+    def _Options(self, p):
-    p.add_option('-r', '--revision-as-HEAD',
+        p.add_option(
-                 dest='peg_rev', action='store_true',
+            "-r",
-                 help='save revisions as current HEAD')
+            "--revision-as-HEAD",
-    p.add_option('-m', '--manifest-name',
+            dest="peg_rev",
-                 help='temporary manifest to use for this sync', metavar='NAME.xml')
+            action="store_true",
-    p.add_option('--suppress-upstream-revision', dest='peg_rev_upstream',
+            help="save revisions as current HEAD",
-                 default=True, action='store_false',
+        )
-                 help='if in -r mode, do not write the upstream field '
+        p.add_option(
-                 '(only of use if the branch names for a sha1 manifest are '
+            "-m",
-                 'sensitive)')
+            "--manifest-name",
-    p.add_option('--suppress-dest-branch', dest='peg_rev_dest_branch',
+            help="temporary manifest to use for this sync",
-                 default=True, action='store_false',
+            metavar="NAME.xml",
-                 help='if in -r mode, do not write the dest-branch field '
+        )
-                 '(only of use if the branch names for a sha1 manifest are '
+        p.add_option(
-                 'sensitive)')
+            "--suppress-upstream-revision",
-    p.add_option('--json', default=False, action='store_true',
+            dest="peg_rev_upstream",
-                 help='output manifest in JSON format (experimental)')
+            default=True,
-    p.add_option('--pretty', default=False, action='store_true',
+            action="store_false",
-                 help='format output for humans to read')
+            help="if in -r mode, do not write the upstream field "
-    p.add_option('--no-local-manifests', default=False, action='store_true',
+            "(only of use if the branch names for a sha1 manifest are "
-                 dest='ignore_local_manifests', help='ignore local manifests')
+            "sensitive)",
-    p.add_option('-o', '--output-file',
+        )
-                 dest='output_file',
+        p.add_option(
-                 default='-',
+            "--suppress-dest-branch",
-                 help='file to save the manifest to. (Filename prefix for multi-tree.)',
+            dest="peg_rev_dest_branch",
-                 metavar='-|NAME.xml')
+            default=True,
+            action="store_false",
-  def _Output(self, opt):
+            help="if in -r mode, do not write the dest-branch field "
-    # If alternate manifest is specified, override the manifest file that we're using.
+            "(only of use if the branch names for a sha1 manifest are "
-    if opt.manifest_name:
+            "sensitive)",
-      self.manifest.Override(opt.manifest_name, False)
+        )
+        p.add_option(
-    for manifest in self.ManifestList(opt):
+            "--json",
-      output_file = opt.output_file
+            default=False,
-      if output_file == '-':
+            action="store_true",
-        fd = sys.stdout
+            help="output manifest in JSON format (experimental)",
-      else:
+        )
-        if manifest.path_prefix:
+        p.add_option(
-          output_file = f'{opt.output_file}:{manifest.path_prefix.replace("/", "%2f")}'
+            "--pretty",
-        fd = open(output_file, 'w')
+            default=False,
+            action="store_true",
-      manifest.SetUseLocalManifests(not opt.ignore_local_manifests)
+            help="format output for humans to read",
+        )
-      if opt.json:
+        p.add_option(
-        print('warning: --json is experimental!', file=sys.stderr)
+            "--no-local-manifests",
-        doc = manifest.ToDict(peg_rev=opt.peg_rev,
+            default=False,
-                                   peg_rev_upstream=opt.peg_rev_upstream,
+            action="store_true",
-                                   peg_rev_dest_branch=opt.peg_rev_dest_branch)
+            dest="ignore_local_manifests",
+            help="ignore local manifests",
-        json_settings = {
+        )
-            # JSON style guide says Uunicode characters are fully allowed.
+        p.add_option(
-            'ensure_ascii': False,
+            "-o",
-            # We use 2 space indent to match JSON style guide.
+            "--output-file",
-            'indent': 2 if opt.pretty else None,
+            dest="output_file",
-            'separators': (',', ': ') if opt.pretty else (',', ':'),
+            default="-",
-            'sort_keys': True,
+            help="file to save the manifest to. (Filename prefix for "
-        }
+            "multi-tree.)",
-        fd.write(json.dumps(doc, **json_settings))
+            metavar="-|NAME.xml",
-      else:
+        )
-        manifest.Save(fd,
-                      peg_rev=opt.peg_rev,
+    def _Output(self, opt):
-                      peg_rev_upstream=opt.peg_rev_upstream,
+        # If alternate manifest is specified, override the manifest file that
-                      peg_rev_dest_branch=opt.peg_rev_dest_branch)
+        # we're using.
-      if output_file != '-':
+        if opt.manifest_name:
-        fd.close()
+            self.manifest.Override(opt.manifest_name, False)
-        if manifest.path_prefix:
-          print(f'Saved {manifest.path_prefix} submanifest to {output_file}',
+        for manifest in self.ManifestList(opt):
-                file=sys.stderr)
+            output_file = opt.output_file
-        else:
+            if output_file == "-":
-          print(f'Saved manifest to {output_file}', file=sys.stderr)
+                fd = sys.stdout
+            else:
+                if manifest.path_prefix:
-  def ValidateOptions(self, opt, args):
+                    output_file = (
-    if args:
+                        f"{opt.output_file}:"
-      self.Usage()
+                        f'{manifest.path_prefix.replace("/", "%2f")}'
+                    )
-  def Execute(self, opt, args):
+                fd = open(output_file, "w")
-    self._Output(opt)
+            manifest.SetUseLocalManifests(not opt.ignore_local_manifests)
+            if opt.json:
+                print("warning: --json is experimental!", file=sys.stderr)
+                doc = manifest.ToDict(
+                    peg_rev=opt.peg_rev,
+                    peg_rev_upstream=opt.peg_rev_upstream,
+                    peg_rev_dest_branch=opt.peg_rev_dest_branch,
+                )
+                json_settings = {
+                    # JSON style guide says Unicode characters are fully
+                    # allowed.
+                    "ensure_ascii": False,
+                    # We use 2 space indent to match JSON style guide.
+                    "indent": 2 if opt.pretty else None,
+                    "separators": (",", ": ") if opt.pretty else (",", ":"),
+                    "sort_keys": True,
+                }
+                fd.write(json.dumps(doc, **json_settings))
+            else:
+                manifest.Save(
+                    fd,
+                    peg_rev=opt.peg_rev,
+                    peg_rev_upstream=opt.peg_rev_upstream,
+                    peg_rev_dest_branch=opt.peg_rev_dest_branch,
+                )
+            if output_file != "-":
+                fd.close()
+                if manifest.path_prefix:
+                    print(
+                        f"Saved {manifest.path_prefix} submanifest to "
+                        f"{output_file}",
+                        file=sys.stderr,
+                    )
+                else:
+                    print(f"Saved manifest to {output_file}", file=sys.stderr)
+    def ValidateOptions(self, opt, args):
+        if args:
+            self.Usage()
+    def Execute(self, opt, args):
+        self._Output(opt)
diff --git a/subcmds/overview.py b/subcmds/overview.py
index 11dba95f..8ccad611 100644
--- a/subcmds/overview.py
+++ b/subcmds/overview.py
@@ -19,12 +19,12 @@ from command import PagedCommand
 class Overview(PagedCommand):
-  COMMON = True
+    COMMON = True
-  helpSummary = "Display overview of unmerged project branches"
+    helpSummary = "Display overview of unmerged project branches"
-  helpUsage = """
+    helpUsage = """
 %prog [--current-branch] [<project>...]
 """
-  helpDescription = """
+    helpDescription = """
 The '%prog' command is used to display an overview of the projects branches,
 and list any local commits that have not yet been merged into the project.
@@ -33,59 +33,77 @@ branches currently checked out in each project.  By default, all branches
 are displayed.
 """
-  def _Options(self, p):
+    def _Options(self, p):
-    p.add_option('-c', '--current-branch',
+        p.add_option(
-                 dest="current_branch", action="store_true",
+            "-c",
-                 help="consider only checked out branches")
+            "--current-branch",
-    p.add_option('--no-current-branch',
+            dest="current_branch",
-                 dest='current_branch', action='store_false',
+            action="store_true",
-                 help='consider all local branches')
+            help="consider only checked out branches",
-    # Turn this into a warning & remove this someday.
+        )
-    p.add_option('-b',
+        p.add_option(
-                 dest='current_branch', action='store_true',
+            "--no-current-branch",
-                 help=optparse.SUPPRESS_HELP)
+            dest="current_branch",
+            action="store_false",
+            help="consider all local branches",
+        )
+        # Turn this into a warning & remove this someday.
+        p.add_option(
+            "-b",
+            dest="current_branch",
+            action="store_true",
+            help=optparse.SUPPRESS_HELP,
+        )
-  def Execute(self, opt, args):
+    def Execute(self, opt, args):
-    all_branches = []
+        all_branches = []
-    for project in self.GetProjects(args, all_manifests=not opt.this_manifest_only):
+        for project in self.GetProjects(
-      br = [project.GetUploadableBranch(x)
+            args, all_manifests=not opt.this_manifest_only
-            for x in project.GetBranches()]
+        ):
-      br = [x for x in br if x]
+            br = [project.GetUploadableBranch(x) for x in project.GetBranches()]
-      if opt.current_branch:
+            br = [x for x in br if x]
-        br = [x for x in br if x.name == project.CurrentBranch]
+            if opt.current_branch:
-      all_branches.extend(br)
+                br = [x for x in br if x.name == project.CurrentBranch]
+            all_branches.extend(br)
-    if not all_branches:
+        if not all_branches:
-      return
+            return
-    class Report(Coloring):
+        class Report(Coloring):
-      def __init__(self, config):
+            def __init__(self, config):
-        Coloring.__init__(self, config, 'status')
+                Coloring.__init__(self, config, "status")
-        self.project = self.printer('header', attr='bold')
+                self.project = self.printer("header", attr="bold")
-        self.text = self.printer('text')
+                self.text = self.printer("text")
-    out = Report(all_branches[0].project.config)
+        out = Report(all_branches[0].project.config)
-    out.text("Deprecated. See repo info -o.")
+        out.text("Deprecated. See repo info -o.")
-    out.nl()
-    out.project('Projects Overview')
-    out.nl()
-    project = None
-    for branch in all_branches:
-      if project != branch.project:
-        project = branch.project
        out.nl()
-        out.project('project %s/' % project.RelPath(local=opt.this_manifest_only))
+        out.project("Projects Overview")
        out.nl()
-      commits = branch.commits
+        project = None
-      date = branch.date
-      print('%s %-33s (%2d commit%s, %s)' % (
+        for branch in all_branches:
-            branch.name == project.CurrentBranch and '*' or ' ',
+            if project != branch.project:
-            branch.name,
+                project = branch.project
-            len(commits),
+                out.nl()
-            len(commits) != 1 and 's' or ' ',
+                out.project(
-            date))
+                    "project %s/"
-      for commit in commits:
+                    % project.RelPath(local=opt.this_manifest_only)
-        print('%-35s   - %s' % ('', commit))
+                )
+                out.nl()
+            commits = branch.commits
+            date = branch.date
+            print(
+                "%s %-33s (%2d commit%s, %s)"
+                % (
+                    branch.name == project.CurrentBranch and "*" or " ",
+                    branch.name,
+                    len(commits),
+                    len(commits) != 1 and "s" or " ",
+                    date,
+                )
+            )
+            for commit in commits:
+                print("%-35s   - %s" % ("", commit))
diff --git a/subcmds/prune.py b/subcmds/prune.py
index 251accaa..5a68c14a 100644
--- a/subcmds/prune.py
+++ b/subcmds/prune.py
@@ -19,63 +19,76 @@ from command import DEFAULT_LOCAL_JOBS, PagedCommand
 class Prune(PagedCommand):
-  COMMON = True
+    COMMON = True
-  helpSummary = "Prune (delete) already merged topics"
+    helpSummary = "Prune (delete) already merged topics"
-  helpUsage = """
+    helpUsage = """
 %prog [<project>...]
 """
-  PARALLEL_JOBS = DEFAULT_LOCAL_JOBS
+    PARALLEL_JOBS = DEFAULT_LOCAL_JOBS
-  def _ExecuteOne(self, project):
+    def _ExecuteOne(self, project):
-    """Process one project."""
+        """Process one project."""
-    return project.PruneHeads()
+        return project.PruneHeads()
-  def Execute(self, opt, args):
+    def Execute(self, opt, args):
-    projects = self.GetProjects(args, all_manifests=not opt.this_manifest_only)
+        projects = self.GetProjects(
+            args, all_manifests=not opt.this_manifest_only
+        )
-    # NB: Should be able to refactor this module to display summary as results
+        # NB: Should be able to refactor this module to display summary as
-    # come back from children.
+        # results come back from children.
-    def _ProcessResults(_pool, _output, results):
+        def _ProcessResults(_pool, _output, results):
-      return list(itertools.chain.from_iterable(results))
+            return list(itertools.chain.from_iterable(results))
-    all_branches = self.ExecuteInParallel(
+        all_branches = self.ExecuteInParallel(
-        opt.jobs,
+            opt.jobs,
-        self._ExecuteOne,
+            self._ExecuteOne,
-        projects,
+            projects,
-        callback=_ProcessResults,
+            callback=_ProcessResults,
-        ordered=True)
+            ordered=True,
+        )
-    if not all_branches:
+        if not all_branches:
-      return
+            return
-    class Report(Coloring):
+        class Report(Coloring):
-      def __init__(self, config):
+            def __init__(self, config):
-        Coloring.__init__(self, config, 'status')
+                Coloring.__init__(self, config, "status")
-        self.project = self.printer('header', attr='bold')
+                self.project = self.printer("header", attr="bold")
-    out = Report(all_branches[0].project.config)
+        out = Report(all_branches[0].project.config)
-    out.project('Pending Branches')
+        out.project("Pending Branches")
-    out.nl()
+        out.nl()
-    project = None
+        project = None
-    for branch in all_branches:
+        for branch in all_branches:
-      if project != branch.project:
+            if project != branch.project:
-        project = branch.project
+                project = branch.project
-        out.nl()
+                out.nl()
-        out.project('project %s/' % project.RelPath(local=opt.this_manifest_only))
+                out.project(
-        out.nl()
+                    "project %s/"
+                    % project.RelPath(local=opt.this_manifest_only)
+                )
+                out.nl()
-      print('%s %-33s ' % (
+            print(
-            branch.name == project.CurrentBranch and '*' or ' ',
+                "%s %-33s "
-            branch.name), end='')
+                % (
+                    branch.name == project.CurrentBranch and "*" or " ",
+                    branch.name,
+                ),
+                end="",
+            )
-      if not branch.base_exists:
+            if not branch.base_exists:
-        print('(ignoring: tracking branch is gone: %s)' % (branch.base,))
+                print(
-      else:
+                    "(ignoring: tracking branch is gone: %s)" % (branch.base,)
-        commits = branch.commits
+                )
-        date = branch.date
+            else:
-        print('(%2d commit%s, %s)' % (
+                commits = branch.commits
-            len(commits),
+                date = branch.date
-            len(commits) != 1 and 's' or ' ',
+                print(
-            date))
+                    "(%2d commit%s, %s)"
+                    % (len(commits), len(commits) != 1 and "s" or " ", date)
+                )
diff --git a/subcmds/rebase.py b/subcmds/rebase.py
index 3d1a63e4..dc4f5805 100644
--- a/subcmds/rebase.py
+++ b/subcmds/rebase.py
@@ -20,146 +20,193 @@ from git_command import GitCommand
 class RebaseColoring(Coloring):
-  def __init__(self, config):
+    def __init__(self, config):
-    Coloring.__init__(self, config, 'rebase')
+        Coloring.__init__(self, config, "rebase")
-    self.project = self.printer('project', attr='bold')
+        self.project = self.printer("project", attr="bold")
-    self.fail = self.printer('fail', fg='red')
+        self.fail = self.printer("fail", fg="red")
 class Rebase(Command):
-  COMMON = True
+    COMMON = True
-  helpSummary = "Rebase local branches on upstream branch"
+    helpSummary = "Rebase local branches on upstream branch"
-  helpUsage = """
+    helpUsage = """
 %prog {[<project>...] | -i <project>...}
 """
-  helpDescription = """
+    helpDescription = """
 '%prog' uses git rebase to move local changes in the current topic branch to
 the HEAD of the upstream history, useful when you have made commits in a topic
 branch but need to incorporate new upstream changes "underneath" them.
 """
-  def _Options(self, p):
+    def _Options(self, p):
-    g = p.get_option_group('--quiet')
+        g = p.get_option_group("--quiet")
-    g.add_option('-i', '--interactive',
+        g.add_option(
-                 dest="interactive", action="store_true",
+            "-i",
-                 help="interactive rebase (single project only)")
+            "--interactive",
+            dest="interactive",
-    p.add_option('--fail-fast',
+            action="store_true",
-                 dest='fail_fast', action='store_true',
+            help="interactive rebase (single project only)",
-                 help='stop rebasing after first error is hit')
+        )
-    p.add_option('-f', '--force-rebase',
-                 dest='force_rebase', action='store_true',
+        p.add_option(
-                 help='pass --force-rebase to git rebase')
+            "--fail-fast",
-    p.add_option('--no-ff',
+            dest="fail_fast",
-                 dest='ff', default=True, action='store_false',
+            action="store_true",
-                 help='pass --no-ff to git rebase')
+            help="stop rebasing after first error is hit",
-    p.add_option('--autosquash',
+        )
-                 dest='autosquash', action='store_true',
+        p.add_option(
-                 help='pass --autosquash to git rebase')
+            "-f",
-    p.add_option('--whitespace',
+            "--force-rebase",
-                 dest='whitespace', action='store', metavar='WS',
+            dest="force_rebase",
-                 help='pass --whitespace to git rebase')
+            action="store_true",
-    p.add_option('--auto-stash',
+            help="pass --force-rebase to git rebase",
-                 dest='auto_stash', action='store_true',
+        )
-                 help='stash local modifications before starting')
+        p.add_option(
-    p.add_option('-m', '--onto-manifest',
+            "--no-ff",
-                 dest='onto_manifest', action='store_true',
+            dest="ff",
-                 help='rebase onto the manifest version instead of upstream '
+            default=True,
-                      'HEAD (this helps to make sure the local tree stays '
+            action="store_false",
-                      'consistent if you previously synced to a manifest)')
+            help="pass --no-ff to git rebase",
+        )
-  def Execute(self, opt, args):
+        p.add_option(
-    all_projects = self.GetProjects(args, all_manifests=not opt.this_manifest_only)
+            "--autosquash",
-    one_project = len(all_projects) == 1
+            dest="autosquash",
+            action="store_true",
-    if opt.interactive and not one_project:
+            help="pass --autosquash to git rebase",
-      print('error: interactive rebase not supported with multiple projects',
+        )
-            file=sys.stderr)
+        p.add_option(
-      if len(args) == 1:
+            "--whitespace",
-        print('note: project %s is mapped to more than one path' % (args[0],),
+            dest="whitespace",
-              file=sys.stderr)
+            action="store",
-      return 1
+            metavar="WS",
+            help="pass --whitespace to git rebase",
-    # Setup the common git rebase args that we use for all projects.
+        )
-    common_args = ['rebase']
+        p.add_option(
-    if opt.whitespace:
+            "--auto-stash",
-      common_args.append('--whitespace=%s' % opt.whitespace)
+            dest="auto_stash",
-    if opt.quiet:
+            action="store_true",
-      common_args.append('--quiet')
+            help="stash local modifications before starting",
-    if opt.force_rebase:
+        )
-      common_args.append('--force-rebase')
+        p.add_option(
-    if not opt.ff:
+            "-m",
-      common_args.append('--no-ff')
+            "--onto-manifest",
-    if opt.autosquash:
+            dest="onto_manifest",
-      common_args.append('--autosquash')
+            action="store_true",
-    if opt.interactive:
+            help="rebase onto the manifest version instead of upstream "
-      common_args.append('-i')
+            "HEAD (this helps to make sure the local tree stays "
+            "consistent if you previously synced to a manifest)",
-    config = self.manifest.manifestProject.config
+        )
-    out = RebaseColoring(config)
-    out.redirect(sys.stdout)
+    def Execute(self, opt, args):
-    _RelPath = lambda p: p.RelPath(local=opt.this_manifest_only)
+        all_projects = self.GetProjects(
+            args, all_manifests=not opt.this_manifest_only
-    ret = 0
+        )
-    for project in all_projects:
+        one_project = len(all_projects) == 1
-      if ret and opt.fail_fast:
-        break
+        if opt.interactive and not one_project:
+            print(
-      cb = project.CurrentBranch
+                "error: interactive rebase not supported with multiple "
-      if not cb:
+                "projects",
-        if one_project:
+                file=sys.stderr,
-          print("error: project %s has a detached HEAD" % _RelPath(project),
+            )
-                file=sys.stderr)
+            if len(args) == 1:
-          return 1
+                print(
-        # ignore branches with detatched HEADs
+                    "note: project %s is mapped to more than one path"
-        continue
+                    % (args[0],),
+                    file=sys.stderr,
-      upbranch = project.GetBranch(cb)
+                )
-      if not upbranch.LocalMerge:
+            return 1
-        if one_project:
-          print("error: project %s does not track any remote branches"
+        # Setup the common git rebase args that we use for all projects.
-                % _RelPath(project), file=sys.stderr)
+        common_args = ["rebase"]
-          return 1
+        if opt.whitespace:
-        # ignore branches without remotes
+            common_args.append("--whitespace=%s" % opt.whitespace)
-        continue
+        if opt.quiet:
+            common_args.append("--quiet")
-      args = common_args[:]
+        if opt.force_rebase:
-      if opt.onto_manifest:
+            common_args.append("--force-rebase")
-        args.append('--onto')
+        if not opt.ff:
-        args.append(project.revisionExpr)
+            common_args.append("--no-ff")
+        if opt.autosquash:
-      args.append(upbranch.LocalMerge)
+            common_args.append("--autosquash")
+        if opt.interactive:
-      out.project('project %s: rebasing %s -> %s',
+            common_args.append("-i")
-                  _RelPath(project), cb, upbranch.LocalMerge)
-      out.nl()
+        config = self.manifest.manifestProject.config
-      out.flush()
+        out = RebaseColoring(config)
+        out.redirect(sys.stdout)
-      needs_stash = False
+        _RelPath = lambda p: p.RelPath(local=opt.this_manifest_only)
-      if opt.auto_stash:
-        stash_args = ["update-index", "--refresh", "-q"]
+        ret = 0
+        for project in all_projects:
-        if GitCommand(project, stash_args).Wait() != 0:
+            if ret and opt.fail_fast:
-          needs_stash = True
+                break
-          # Dirty index, requires stash...
-          stash_args = ["stash"]
+            cb = project.CurrentBranch
+            if not cb:
-          if GitCommand(project, stash_args).Wait() != 0:
+                if one_project:
-            ret += 1
+                    print(
-            continue
+                        "error: project %s has a detached HEAD"
+                        % _RelPath(project),
-      if GitCommand(project, args).Wait() != 0:
+                        file=sys.stderr,
-        ret += 1
+                    )
-        continue
+                    return 1
+                # Ignore branches with detached HEADs.
-      if needs_stash:
+                continue
-        stash_args.append('pop')
-        stash_args.append('--quiet')
+            upbranch = project.GetBranch(cb)
-        if GitCommand(project, stash_args).Wait() != 0:
+            if not upbranch.LocalMerge:
-          ret += 1
+                if one_project:
+                    print(
-    if ret:
+                        "error: project %s does not track any remote branches"
-      out.fail('%i projects had errors', ret)
+                        % _RelPath(project),
-      out.nl()
+                        file=sys.stderr,
+                    )
-    return ret
+                    return 1
+                # Ignore branches without remotes.
+                continue
+            args = common_args[:]
+            if opt.onto_manifest:
+                args.append("--onto")
+                args.append(project.revisionExpr)
+            args.append(upbranch.LocalMerge)
+            out.project(
+                "project %s: rebasing %s -> %s",
+                _RelPath(project),
+                cb,
+                upbranch.LocalMerge,
+            )
+            out.nl()
+            out.flush()
+            needs_stash = False
+            if opt.auto_stash:
+                stash_args = ["update-index", "--refresh", "-q"]
+                if GitCommand(project, stash_args).Wait() != 0:
+                    needs_stash = True
+                    # Dirty index, requires stash...
+                    stash_args = ["stash"]
+                    if GitCommand(project, stash_args).Wait() != 0:
+                        ret += 1
+                        continue
+            if GitCommand(project, args).Wait() != 0:
+                ret += 1
+                continue
+            if needs_stash:
+                stash_args.append("pop")
+                stash_args.append("--quiet")
+                if GitCommand(project, stash_args).Wait() != 0:
+                    ret += 1
+        if ret:
+            out.fail("%i projects had errors", ret)
+            out.nl()
+        return ret
diff --git a/subcmds/selfupdate.py b/subcmds/selfupdate.py
index 898bc3f2..d5d0a838 100644
--- a/subcmds/selfupdate.py
+++ b/subcmds/selfupdate.py
@@ -21,12 +21,12 @@ from subcmds.sync import _PostRepoFetch
 class Selfupdate(Command, MirrorSafeCommand):
-  COMMON = False
+    COMMON = False
-  helpSummary = "Update repo to the latest version"
+    helpSummary = "Update repo to the latest version"
-  helpUsage = """
+    helpUsage = """
 %prog
 """
-  helpDescription = """
+    helpDescription = """
 The '%prog' command upgrades repo to the latest version, if a
 newer version is available.
@@ -34,28 +34,33 @@ Normally this is done automatically by 'repo sync' and does not
 need to be performed by an end-user.
 """
-  def _Options(self, p):
+    def _Options(self, p):
-    g = p.add_option_group('repo Version options')
+        g = p.add_option_group("repo Version options")
-    g.add_option('--no-repo-verify',
+        g.add_option(
-                 dest='repo_verify', default=True, action='store_false',
+            "--no-repo-verify",
-                 help='do not verify repo source code')
+            dest="repo_verify",
-    g.add_option('--repo-upgraded',
+            default=True,
-                 dest='repo_upgraded', action='store_true',
+            action="store_false",
-                 help=SUPPRESS_HELP)
+            help="do not verify repo source code",
+        )
-  def Execute(self, opt, args):
+        g.add_option(
-    rp = self.manifest.repoProject
+            "--repo-upgraded",
-    rp.PreSync()
+            dest="repo_upgraded",
+            action="store_true",
-    if opt.repo_upgraded:
+            help=SUPPRESS_HELP,
-      _PostRepoUpgrade(self.manifest)
+        )
-    else:
+    def Execute(self, opt, args):
-      if not rp.Sync_NetworkHalf().success:
+        rp = self.manifest.repoProject
-        print("error: can't update repo", file=sys.stderr)
+        rp.PreSync()
-        sys.exit(1)
+        if opt.repo_upgraded:
-      rp.bare_git.gc('--auto')
+            _PostRepoUpgrade(self.manifest)
-      _PostRepoFetch(rp,
-                     repo_verify=opt.repo_verify,
+        else:
-                     verbose=True)
+            if not rp.Sync_NetworkHalf().success:
+                print("error: can't update repo", file=sys.stderr)
+                sys.exit(1)
+            rp.bare_git.gc("--auto")
+            _PostRepoFetch(rp, repo_verify=opt.repo_verify, verbose=True)
diff --git a/subcmds/smartsync.py b/subcmds/smartsync.py
index d91d59c6..49d09972 100644
--- a/subcmds/smartsync.py
+++ b/subcmds/smartsync.py
@@ -16,18 +16,18 @@ from subcmds.sync import Sync
 class Smartsync(Sync):
-  COMMON = True
+    COMMON = True
-  helpSummary = "Update working tree to the latest known good revision"
+    helpSummary = "Update working tree to the latest known good revision"
-  helpUsage = """
+    helpUsage = """
 %prog [<project>...]
 """
-  helpDescription = """
+    helpDescription = """
 The '%prog' command is a shortcut for sync -s.
 """
-  def _Options(self, p):
+    def _Options(self, p):
-    Sync._Options(self, p, show_smart=False)
+        Sync._Options(self, p, show_smart=False)
-  def Execute(self, opt, args):
+    def Execute(self, opt, args):
-    opt.smart_sync = True
+        opt.smart_sync = True
-    Sync.Execute(self, opt, args)
+        Sync.Execute(self, opt, args)
diff --git a/subcmds/stage.py b/subcmds/stage.py
index bdb72012..4d54eb19 100644
--- a/subcmds/stage.py
+++ b/subcmds/stage.py
@@ -20,98 +20,111 @@ from git_command import GitCommand
 class _ProjectList(Coloring):
-  def __init__(self, gc):
+    def __init__(self, gc):
-    Coloring.__init__(self, gc, 'interactive')
+        Coloring.__init__(self, gc, "interactive")
-    self.prompt = self.printer('prompt', fg='blue', attr='bold')
+        self.prompt = self.printer("prompt", fg="blue", attr="bold")
-    self.header = self.printer('header', attr='bold')
+        self.header = self.printer("header", attr="bold")
-    self.help = self.printer('help', fg='red', attr='bold')
+        self.help = self.printer("help", fg="red", attr="bold")
 class Stage(InteractiveCommand):
-  COMMON = True
+    COMMON = True
-  helpSummary = "Stage file(s) for commit"
+    helpSummary = "Stage file(s) for commit"
-  helpUsage = """
+    helpUsage = """
 %prog -i [<project>...]
 """
-  helpDescription = """
+    helpDescription = """
 The '%prog' command stages files to prepare the next commit.
 """
-  def _Options(self, p):
+    def _Options(self, p):
-    g = p.get_option_group('--quiet')
+        g = p.get_option_group("--quiet")
-    g.add_option('-i', '--interactive',
+        g.add_option(
-                 dest='interactive', action='store_true',
+            "-i",
-                 help='use interactive staging')
+            "--interactive",
+            dest="interactive",
-  def Execute(self, opt, args):
+            action="store_true",
-    if opt.interactive:
+            help="use interactive staging",
-      self._Interactive(opt, args)
+        )
-    else:
-      self.Usage()
+    def Execute(self, opt, args):
+        if opt.interactive:
-  def _Interactive(self, opt, args):
+            self._Interactive(opt, args)
-    all_projects = [
+        else:
-        p for p in self.GetProjects(args, all_manifests=not opt.this_manifest_only)
+            self.Usage()
-        if p.IsDirty()]
-    if not all_projects:
+    def _Interactive(self, opt, args):
-      print('no projects have uncommitted modifications', file=sys.stderr)
+        all_projects = [
-      return
+            p
+            for p in self.GetProjects(
-    out = _ProjectList(self.manifest.manifestProject.config)
+                args, all_manifests=not opt.this_manifest_only
-    while True:
+            )
-      out.header('        %s', 'project')
+            if p.IsDirty()
-      out.nl()
+        ]
+        if not all_projects:
-      for i in range(len(all_projects)):
+            print("no projects have uncommitted modifications", file=sys.stderr)
-        project = all_projects[i]
+            return
-        out.write('%3d:    %s', i + 1,
-                  project.RelPath(local=opt.this_manifest_only) + '/')
+        out = _ProjectList(self.manifest.manifestProject.config)
-        out.nl()
+        while True:
-      out.nl()
+            out.header("        %s", "project")
+            out.nl()
-      out.write('%3d: (', 0)
-      out.prompt('q')
+            for i in range(len(all_projects)):
-      out.write('uit)')
+                project = all_projects[i]
-      out.nl()
+                out.write(
+                    "%3d:    %s",
-      out.prompt('project> ')
+                    i + 1,
-      out.flush()
+                    project.RelPath(local=opt.this_manifest_only) + "/",
-      try:
+                )
-        a = sys.stdin.readline()
+                out.nl()
-      except KeyboardInterrupt:
+            out.nl()
-        out.nl()
-        break
+            out.write("%3d: (", 0)
-      if a == '':
+            out.prompt("q")
-        out.nl()
+            out.write("uit)")
-        break
+            out.nl()
-      a = a.strip()
+            out.prompt("project> ")
-      if a.lower() in ('q', 'quit', 'exit'):
+            out.flush()
-        break
+            try:
-      if not a:
+                a = sys.stdin.readline()
-        continue
+            except KeyboardInterrupt:
+                out.nl()
-      try:
+                break
-        a_index = int(a)
+            if a == "":
-      except ValueError:
+                out.nl()
-        a_index = None
+                break
-      if a_index is not None:
+            a = a.strip()
-        if a_index == 0:
+            if a.lower() in ("q", "quit", "exit"):
-          break
+                break
-        if 0 < a_index and a_index <= len(all_projects):
+            if not a:
-          _AddI(all_projects[a_index - 1])
+                continue
-          continue
+            try:
-      projects = [
+                a_index = int(a)
-          p for p in all_projects
+            except ValueError:
-          if a in [p.name, p.RelPath(local=opt.this_manifest_only)]]
+                a_index = None
-      if len(projects) == 1:
-        _AddI(projects[0])
+            if a_index is not None:
-        continue
+                if a_index == 0:
-    print('Bye.')
+                    break
+                if 0 < a_index and a_index <= len(all_projects):
+                    _AddI(all_projects[a_index - 1])
+                    continue
+            projects = [
+                p
+                for p in all_projects
+                if a in [p.name, p.RelPath(local=opt.this_manifest_only)]
+            ]
+            if len(projects) == 1:
+                _AddI(projects[0])
+                continue
+        print("Bye.")
 def _AddI(project):
-  p = GitCommand(project, ['add', '--interactive'], bare=False)
+    p = GitCommand(project, ["add", "--interactive"], bare=False)
-  p.Wait()
+    p.Wait()
diff --git a/subcmds/start.py b/subcmds/start.py
index 809df963..d7772b33 100644
--- a/subcmds/start.py
+++ b/subcmds/start.py
@@ -25,119 +25,147 @@ from project import SyncBuffer
 class Start(Command):
-  COMMON = True
+    COMMON = True
-  helpSummary = "Start a new branch for development"
+    helpSummary = "Start a new branch for development"
-  helpUsage = """
+    helpUsage = """
 %prog <newbranchname> [--all | <project>...]
 """
-  helpDescription = """
+    helpDescription = """
 '%prog' begins a new branch of development, starting from the
 revision specified in the manifest.
 """
-  PARALLEL_JOBS = DEFAULT_LOCAL_JOBS
+    PARALLEL_JOBS = DEFAULT_LOCAL_JOBS
-  def _Options(self, p):
+    def _Options(self, p):
-    p.add_option('--all',
+        p.add_option(
-                 dest='all', action='store_true',
+            "--all",
-                 help='begin branch in all projects')
+            dest="all",
-    p.add_option('-r', '--rev', '--revision', dest='revision',
+            action="store_true",
-                 help='point branch at this revision instead of upstream')
+            help="begin branch in all projects",
-    p.add_option('--head', '--HEAD',
+        )
-                 dest='revision', action='store_const', const='HEAD',
+        p.add_option(
-                 help='abbreviation for --rev HEAD')
+            "-r",
+            "--rev",
-  def ValidateOptions(self, opt, args):
+            "--revision",
-    if not args:
+            dest="revision",
-      self.Usage()
+            help="point branch at this revision instead of upstream",
+        )
-    nb = args[0]
+        p.add_option(
-    if not git.check_ref_format('heads/%s' % nb):
+            "--head",
-      self.OptionParser.error("'%s' is not a valid name" % nb)
+            "--HEAD",
+            dest="revision",
-  def _ExecuteOne(self, revision, nb, project):
+            action="store_const",
-    """Start one project."""
+            const="HEAD",
-    # If the current revision is immutable, such as a SHA1, a tag or
+            help="abbreviation for --rev HEAD",
-    # a change, then we can't push back to it. Substitute with
+        )
-    # dest_branch, if defined; or with manifest default revision instead.
-    branch_merge = ''
+    def ValidateOptions(self, opt, args):
-    if IsImmutable(project.revisionExpr):
+        if not args:
-      if project.dest_branch:
+            self.Usage()
-        branch_merge = project.dest_branch
-      else:
+        nb = args[0]
-        branch_merge = self.manifest.default.revisionExpr
+        if not git.check_ref_format("heads/%s" % nb):
+            self.OptionParser.error("'%s' is not a valid name" % nb)
-    try:
-      ret = project.StartBranch(
+    def _ExecuteOne(self, revision, nb, project):
-          nb, branch_merge=branch_merge, revision=revision)
+        """Start one project."""
-    except Exception as e:
+        # If the current revision is immutable, such as a SHA1, a tag or
-      print('error: unable to checkout %s: %s' % (project.name, e), file=sys.stderr)
+        # a change, then we can't push back to it. Substitute with
-      ret = False
+        # dest_branch, if defined; or with manifest default revision instead.
-    return (ret, project)
+        branch_merge = ""
+        if IsImmutable(project.revisionExpr):
-  def Execute(self, opt, args):
+            if project.dest_branch:
-    nb = args[0]
+                branch_merge = project.dest_branch
-    err = []
+            else:
-    projects = []
+                branch_merge = self.manifest.default.revisionExpr
-    if not opt.all:
-      projects = args[1:]
+        try:
-      if len(projects) < 1:
+            ret = project.StartBranch(
-        projects = ['.']  # start it in the local project by default
+                nb, branch_merge=branch_merge, revision=revision
+            )
-    all_projects = self.GetProjects(projects,
+        except Exception as e:
-                                    missing_ok=bool(self.gitc_manifest),
+            print(
-                                    all_manifests=not opt.this_manifest_only)
+                "error: unable to checkout %s: %s" % (project.name, e),
+                file=sys.stderr,
-    # This must happen after we find all_projects, since GetProjects may need
+            )
-    # the local directory, which will disappear once we save the GITC manifest.
+            ret = False
-    if self.gitc_manifest:
+        return (ret, project)
-      gitc_projects = self.GetProjects(projects, manifest=self.gitc_manifest,
-                                       missing_ok=True)
+    def Execute(self, opt, args):
-      for project in gitc_projects:
+        nb = args[0]
-        if project.old_revision:
+        err = []
-          project.already_synced = True
+        projects = []
-        else:
+        if not opt.all:
-          project.already_synced = False
+            projects = args[1:]
-          project.old_revision = project.revisionExpr
+            if len(projects) < 1:
-        project.revisionExpr = None
+                projects = ["."]  # start it in the local project by default
-      # Save the GITC manifest.
-      gitc_utils.save_manifest(self.gitc_manifest)
+        all_projects = self.GetProjects(
+            projects,
-      # Make sure we have a valid CWD
+            missing_ok=bool(self.gitc_manifest),
-      if not os.path.exists(os.getcwd()):
+            all_manifests=not opt.this_manifest_only,
-        os.chdir(self.manifest.topdir)
+        )
-      pm = Progress('Syncing %s' % nb, len(all_projects), quiet=opt.quiet)
+        # This must happen after we find all_projects, since GetProjects may
-      for project in all_projects:
+        # need the local directory, which will disappear once we save the GITC
-        gitc_project = self.gitc_manifest.paths[project.relpath]
+        # manifest.
-        # Sync projects that have not been opened.
+        if self.gitc_manifest:
-        if not gitc_project.already_synced:
+            gitc_projects = self.GetProjects(
-          proj_localdir = os.path.join(self.gitc_manifest.gitc_client_dir,
+                projects, manifest=self.gitc_manifest, missing_ok=True
-                                       project.relpath)
+            )
-          project.worktree = proj_localdir
+            for project in gitc_projects:
-          if not os.path.exists(proj_localdir):
+                if project.old_revision:
-            os.makedirs(proj_localdir)
+                    project.already_synced = True
-          project.Sync_NetworkHalf()
+                else:
-          sync_buf = SyncBuffer(self.manifest.manifestProject.config)
+                    project.already_synced = False
-          project.Sync_LocalHalf(sync_buf)
+                    project.old_revision = project.revisionExpr
-          project.revisionId = gitc_project.old_revision
+                project.revisionExpr = None
-        pm.update()
+            # Save the GITC manifest.
-      pm.end()
+            gitc_utils.save_manifest(self.gitc_manifest)
-    def _ProcessResults(_pool, pm, results):
+            # Make sure we have a valid CWD.
-      for (result, project) in results:
+            if not os.path.exists(os.getcwd()):
-        if not result:
+                os.chdir(self.manifest.topdir)
-          err.append(project)
-        pm.update()
+            pm = Progress("Syncing %s" % nb, len(all_projects), quiet=opt.quiet)
+            for project in all_projects:
-    self.ExecuteInParallel(
+                gitc_project = self.gitc_manifest.paths[project.relpath]
-        opt.jobs,
+                # Sync projects that have not been opened.
-        functools.partial(self._ExecuteOne, opt.revision, nb),
+                if not gitc_project.already_synced:
-        all_projects,
+                    proj_localdir = os.path.join(
-        callback=_ProcessResults,
+                        self.gitc_manifest.gitc_client_dir, project.relpath
-        output=Progress('Starting %s' % (nb,), len(all_projects), quiet=opt.quiet))
+                    )
+                    project.worktree = proj_localdir
-    if err:
+                    if not os.path.exists(proj_localdir):
-      for p in err:
+                        os.makedirs(proj_localdir)
-        print("error: %s/: cannot start %s" % (p.RelPath(local=opt.this_manifest_only), nb),
+                    project.Sync_NetworkHalf()
-              file=sys.stderr)
+                    sync_buf = SyncBuffer(self.manifest.manifestProject.config)
-      sys.exit(1)
+                    project.Sync_LocalHalf(sync_buf)
+                    project.revisionId = gitc_project.old_revision
+                pm.update()
+            pm.end()
+        def _ProcessResults(_pool, pm, results):
+            for result, project in results:
+                if not result:
+                    err.append(project)
+                pm.update()
+        self.ExecuteInParallel(
+            opt.jobs,
+            functools.partial(self._ExecuteOne, opt.revision, nb),
+            all_projects,
+            callback=_ProcessResults,
+            output=Progress(
+                "Starting %s" % (nb,), len(all_projects), quiet=opt.quiet
+            ),
+        )
+        if err:
+            for p in err:
+                print(
+                    "error: %s/: cannot start %s"
+                    % (p.RelPath(local=opt.this_manifest_only), nb),
+                    file=sys.stderr,
+                )
+            sys.exit(1)
diff --git a/subcmds/status.py b/subcmds/status.py
index 572c72f7..6e0026f9 100644
--- a/subcmds/status.py
+++ b/subcmds/status.py
@@ -24,12 +24,12 @@ import platform_utils
 class Status(PagedCommand):
-  COMMON = True
+    COMMON = True
-  helpSummary = "Show the working tree status"
+    helpSummary = "Show the working tree status"
-  helpUsage = """
+    helpUsage = """
 %prog [<project>...]
 """
-  helpDescription = """
+    helpDescription = """
 '%prog' compares the working tree to the staging area (aka index),
 and the most recent commit on this branch (HEAD), in each project
 specified.  A summary is displayed, one line per file where there
@@ -76,109 +76,128 @@ the following meanings:
 d:  deleted       (    in index, not in work tree                )
 """
-  PARALLEL_JOBS = DEFAULT_LOCAL_JOBS
+    PARALLEL_JOBS = DEFAULT_LOCAL_JOBS
-  def _Options(self, p):
+    def _Options(self, p):
-    p.add_option('-o', '--orphans',
+        p.add_option(
-                 dest='orphans', action='store_true',
+            "-o",
-                 help="include objects in working directory outside of repo projects")
+            "--orphans",
+            dest="orphans",
-  def _StatusHelper(self, quiet, local, project):
+            action="store_true",
-    """Obtains the status for a specific project.
+            help="include objects in working directory outside of repo "
+            "projects",
-    Obtains the status for a project, redirecting the output to
+        )
-    the specified object.
+    def _StatusHelper(self, quiet, local, project):
-    Args:
+        """Obtains the status for a specific project.
-      quiet: Where to output the status.
-      local: a boolean, if True, the path is relative to the local
+        Obtains the status for a project, redirecting the output to
-             (sub)manifest.  If false, the path is relative to the
+        the specified object.
-             outermost manifest.
-      project: Project to get status of.
+        Args:
+            quiet: Where to output the status.
-    Returns:
+            local: a boolean, if True, the path is relative to the local
-      The status of the project.
+                (sub)manifest.  If false, the path is relative to the outermost
-    """
+                manifest.
-    buf = io.StringIO()
+            project: Project to get status of.
-    ret = project.PrintWorkTreeStatus(quiet=quiet, output_redir=buf,
-                                      local=local)
+        Returns:
-    return (ret, buf.getvalue())
+            The status of the project.
+        """
-  def _FindOrphans(self, dirs, proj_dirs, proj_dirs_parents, outstring):
+        buf = io.StringIO()
-    """find 'dirs' that are present in 'proj_dirs_parents' but not in 'proj_dirs'"""
+        ret = project.PrintWorkTreeStatus(
-    status_header = ' --\t'
+            quiet=quiet, output_redir=buf, local=local
-    for item in dirs:
+        )
-      if not platform_utils.isdir(item):
+        return (ret, buf.getvalue())
-        outstring.append(''.join([status_header, item]))
-        continue
+    def _FindOrphans(self, dirs, proj_dirs, proj_dirs_parents, outstring):
-      if item in proj_dirs:
+        """find 'dirs' that are present in 'proj_dirs_parents' but not in 'proj_dirs'"""  # noqa: E501
-        continue
+        status_header = " --\t"
-      if item in proj_dirs_parents:
+        for item in dirs:
-        self._FindOrphans(glob.glob('%s/.*' % item) +
+            if not platform_utils.isdir(item):
-                          glob.glob('%s/*' % item),
+                outstring.append("".join([status_header, item]))
-                          proj_dirs, proj_dirs_parents, outstring)
+                continue
-        continue
+            if item in proj_dirs:
-      outstring.append(''.join([status_header, item, '/']))
+                continue
+            if item in proj_dirs_parents:
-  def Execute(self, opt, args):
+                self._FindOrphans(
-    all_projects = self.GetProjects(args, all_manifests=not opt.this_manifest_only)
+                    glob.glob("%s/.*" % item) + glob.glob("%s/*" % item),
+                    proj_dirs,
-    def _ProcessResults(_pool, _output, results):
+                    proj_dirs_parents,
-      ret = 0
+                    outstring,
-      for (state, output) in results:
+                )
-        if output:
+                continue
-          print(output, end='')
+            outstring.append("".join([status_header, item, "/"]))
-        if state == 'CLEAN':
-          ret += 1
+    def Execute(self, opt, args):
-      return ret
+        all_projects = self.GetProjects(
+            args, all_manifests=not opt.this_manifest_only
-    counter = self.ExecuteInParallel(
+        )
-        opt.jobs,
-        functools.partial(self._StatusHelper, opt.quiet, opt.this_manifest_only),
+        def _ProcessResults(_pool, _output, results):
-        all_projects,
+            ret = 0
-        callback=_ProcessResults,
+            for state, output in results:
-        ordered=True)
+                if output:
+                    print(output, end="")
-    if not opt.quiet and len(all_projects) == counter:
+                if state == "CLEAN":
-      print('nothing to commit (working directory clean)')
+                    ret += 1
+            return ret
-    if opt.orphans:
-      proj_dirs = set()
+        counter = self.ExecuteInParallel(
-      proj_dirs_parents = set()
+            opt.jobs,
-      for project in self.GetProjects(None, missing_ok=True, all_manifests=not opt.this_manifest_only):
+            functools.partial(
-        relpath = project.RelPath(local=opt.this_manifest_only)
+                self._StatusHelper, opt.quiet, opt.this_manifest_only
-        proj_dirs.add(relpath)
+            ),
-        (head, _tail) = os.path.split(relpath)
+            all_projects,
-        while head != "":
+            callback=_ProcessResults,
-          proj_dirs_parents.add(head)
+            ordered=True,
-          (head, _tail) = os.path.split(head)
+        )
-      proj_dirs.add('.repo')
+        if not opt.quiet and len(all_projects) == counter:
-      class StatusColoring(Coloring):
+            print("nothing to commit (working directory clean)")
-        def __init__(self, config):
-          Coloring.__init__(self, config, 'status')
+        if opt.orphans:
-          self.project = self.printer('header', attr='bold')
+            proj_dirs = set()
-          self.untracked = self.printer('untracked', fg='red')
+            proj_dirs_parents = set()
+            for project in self.GetProjects(
-      orig_path = os.getcwd()
+                None, missing_ok=True, all_manifests=not opt.this_manifest_only
-      try:
+            ):
-        os.chdir(self.manifest.topdir)
+                relpath = project.RelPath(local=opt.this_manifest_only)
+                proj_dirs.add(relpath)
-        outstring = []
+                (head, _tail) = os.path.split(relpath)
-        self._FindOrphans(glob.glob('.*') +
+                while head != "":
-                          glob.glob('*'),
+                    proj_dirs_parents.add(head)
-                          proj_dirs, proj_dirs_parents, outstring)
+                    (head, _tail) = os.path.split(head)
+            proj_dirs.add(".repo")
-        if outstring:
-          output = StatusColoring(self.client.globalConfig)
+            class StatusColoring(Coloring):
-          output.project('Objects not within a project (orphans)')
+                def __init__(self, config):
-          output.nl()
+                    Coloring.__init__(self, config, "status")
-          for entry in outstring:
+                    self.project = self.printer("header", attr="bold")
-            output.untracked(entry)
+                    self.untracked = self.printer("untracked", fg="red")
-            output.nl()
-        else:
+            orig_path = os.getcwd()
-          print('No orphan files or directories')
+            try:
+                os.chdir(self.manifest.topdir)
-      finally:
-        # Restore CWD.
+                outstring = []
-        os.chdir(orig_path)
+                self._FindOrphans(
+                    glob.glob(".*") + glob.glob("*"),
+                    proj_dirs,
+                    proj_dirs_parents,
+                    outstring,
+                )
+                if outstring:
+                    output = StatusColoring(self.client.globalConfig)
+                    output.project("Objects not within a project (orphans)")
+                    output.nl()
+                    for entry in outstring:
+                        output.untracked(entry)
+                        output.nl()
+                else:
+                    print("No orphan files or directories")
+            finally:
+                # Restore CWD.
+                os.chdir(orig_path)
diff --git a/subcmds/sync.py b/subcmds/sync.py
index 9a8ca8f7..eabaa68b 100644
--- a/subcmds/sync.py
+++ b/subcmds/sync.py
@@ -33,18 +33,21 @@ import xml.parsers.expat
 import xmlrpc.client
 try:
-  import threading as _threading
+    import threading as _threading
 except ImportError:
-  import dummy_threading as _threading
+    import dummy_threading as _threading
 try:
-  import resource
+    import resource
+    def _rlimit_nofile():
+        return resource.getrlimit(resource.RLIMIT_NOFILE)
-  def _rlimit_nofile():
-    return resource.getrlimit(resource.RLIMIT_NOFILE)
 except ImportError:
-  def _rlimit_nofile():
-    return (256, 256)
+    def _rlimit_nofile():
+        return (256, 256)
 import event_log
 from git_command import git_require
@@ -54,7 +57,12 @@ import git_superproject
 import gitc_utils
 from project import Project
 from project import RemoteSpec
-from command import Command, DEFAULT_LOCAL_JOBS, MirrorSafeCommand, WORKER_BATCH_SIZE
+from command import (
+    Command,
+    DEFAULT_LOCAL_JOBS,
+    MirrorSafeCommand,
+    WORKER_BATCH_SIZE,
+)
 from error import RepoChangedException, GitError
 import platform_utils
 from project import SyncBuffer
@@ -68,70 +76,74 @@ _ONE_DAY_S = 24 * 60 * 60
 # Env var to implicitly turn auto-gc back on.  This was added to allow a user to
 # revert a change in default behavior in v2.29.9.  Remove after 2023-04-01.
-_REPO_AUTO_GC = 'REPO_AUTO_GC'
+_REPO_AUTO_GC = "REPO_AUTO_GC"
-_AUTO_GC = os.environ.get(_REPO_AUTO_GC) == '1'
+_AUTO_GC = os.environ.get(_REPO_AUTO_GC) == "1"
 class _FetchOneResult(NamedTuple):
-  """_FetchOne return value.
+    """_FetchOne return value.
-  Attributes:
+    Attributes:
-    success (bool): True if successful.
+      success (bool): True if successful.
-    project (Project): The fetched project.
+      project (Project): The fetched project.
-    start (float): The starting time.time().
+      start (float): The starting time.time().
-    finish (float): The ending time.time().
+      finish (float): The ending time.time().
-    remote_fetched (bool): True if the remote was actually queried.
+      remote_fetched (bool): True if the remote was actually queried.
-  """
+    """
-  success: bool
-  project: Project
+    success: bool
-  start: float
+    project: Project
-  finish: float
+    start: float
-  remote_fetched: bool
+    finish: float
+    remote_fetched: bool
 class _FetchResult(NamedTuple):
-  """_Fetch return value.
+    """_Fetch return value.
+    Attributes:
+      success (bool): True if successful.
+      projects (Set[str]): The names of the git directories of fetched projects.
+    """
-  Attributes:
+    success: bool
-    success (bool): True if successful.
+    projects: Set[str]
-    projects (Set[str]): The names of the git directories of fetched projects.
-  """
-  success: bool
-  projects: Set[str]
 class _FetchMainResult(NamedTuple):
-  """_FetchMain return value.
+    """_FetchMain return value.
+    Attributes:
+      all_projects (List[Project]): The fetched projects.
+    """
-  Attributes:
+    all_projects: List[Project]
-    all_projects (List[Project]): The fetched projects.
-  """
-  all_projects: List[Project]
 class _CheckoutOneResult(NamedTuple):
-  """_CheckoutOne return value.
+    """_CheckoutOne return value.
+    Attributes:
+      success (bool): True if successful.
+      project (Project): The project.
+      start (float): The starting time.time().
+      finish (float): The ending time.time().
+    """
-  Attributes:
+    success: bool
-    success (bool): True if successful.
+    project: Project
-    project (Project): The project.
+    start: float
-    start (float): The starting time.time().
+    finish: float
-    finish (float): The ending time.time().
-  """
-  success: bool
-  project: Project
-  start: float
-  finish: float
 class Sync(Command, MirrorSafeCommand):
-  COMMON = True
+    COMMON = True
-  MULTI_MANIFEST_SUPPORT = True
+    MULTI_MANIFEST_SUPPORT = True
-  helpSummary = "Update working tree to the latest revision"
+    helpSummary = "Update working tree to the latest revision"
-  helpUsage = """
+    helpUsage = """
 %prog [<project>...]
 """
-  helpDescription = """
+    helpDescription = """
 The '%prog' command synchronizes local project directories
 with the remote repositories specified in the manifest.  If a local
 project does not yet exist, it will clone a new local directory from
@@ -230,1293 +242,1604 @@ If the remote SSH daemon is Gerrit Code Review, version 2.0.10 or
 later is required to fix a server side protocol bug.
 """
-  # A value of 0 means we want parallel jobs, but we'll determine the default
+    # A value of 0 means we want parallel jobs, but we'll determine the default
-  # value later on.
+    # value later on.
-  PARALLEL_JOBS = 0
+    PARALLEL_JOBS = 0
-  def _Options(self, p, show_smart=True):
+    def _Options(self, p, show_smart=True):
-    p.add_option('--jobs-network', default=None, type=int, metavar='JOBS',
+        p.add_option(
-                 help='number of network jobs to run in parallel (defaults to --jobs or 1)')
+            "--jobs-network",
-    p.add_option('--jobs-checkout', default=None, type=int, metavar='JOBS',
+            default=None,
-                 help='number of local checkout jobs to run in parallel (defaults to --jobs or '
+            type=int,
-                      f'{DEFAULT_LOCAL_JOBS})')
+            metavar="JOBS",
+            help="number of network jobs to run in parallel (defaults to "
-    p.add_option('-f', '--force-broken',
+            "--jobs or 1)",
-                 dest='force_broken', action='store_true',
+        )
-                 help='obsolete option (to be deleted in the future)')
+        p.add_option(
-    p.add_option('--fail-fast',
+            "--jobs-checkout",
-                 dest='fail_fast', action='store_true',
+            default=None,
-                 help='stop syncing after first error is hit')
+            type=int,
-    p.add_option('--force-sync',
+            metavar="JOBS",
-                 dest='force_sync', action='store_true',
+            help="number of local checkout jobs to run in parallel (defaults "
-                 help="overwrite an existing git directory if it needs to "
+            f"to --jobs or {DEFAULT_LOCAL_JOBS})",
-                      "point to a different object directory. WARNING: this "
+        )
-                      "may cause loss of data")
-    p.add_option('--force-remove-dirty',
+        p.add_option(
-                 dest='force_remove_dirty', action='store_true',
+            "-f",
-                 help="force remove projects with uncommitted modifications if "
+            "--force-broken",
-                      "projects no longer exist in the manifest. "
+            dest="force_broken",
-                      "WARNING: this may cause loss of data")
+            action="store_true",
-    p.add_option('-l', '--local-only',
+            help="obsolete option (to be deleted in the future)",
-                 dest='local_only', action='store_true',
+        )
-                 help="only update working tree, don't fetch")
+        p.add_option(
-    p.add_option('--no-manifest-update', '--nmu',
+            "--fail-fast",
-                 dest='mp_update', action='store_false', default='true',
+            dest="fail_fast",
-                 help='use the existing manifest checkout as-is. '
+            action="store_true",
-                      '(do not update to the latest revision)')
+            help="stop syncing after first error is hit",
-    p.add_option('-n', '--network-only',
+        )
-                 dest='network_only', action='store_true',
+        p.add_option(
-                 help="fetch only, don't update working tree")
+            "--force-sync",
-    p.add_option('-d', '--detach',
+            dest="force_sync",
-                 dest='detach_head', action='store_true',
+            action="store_true",
-                 help='detach projects back to manifest revision')
+            help="overwrite an existing git directory if it needs to "
-    p.add_option('-c', '--current-branch',
+            "point to a different object directory. WARNING: this "
-                 dest='current_branch_only', action='store_true',
+            "may cause loss of data",
-                 help='fetch only current branch from server')
+        )
-    p.add_option('--no-current-branch',
+        p.add_option(
-                 dest='current_branch_only', action='store_false',
+            "--force-remove-dirty",
-                 help='fetch all branches from server')
+            dest="force_remove_dirty",
-    p.add_option('-m', '--manifest-name',
+            action="store_true",
-                 dest='manifest_name',
+            help="force remove projects with uncommitted modifications if "
-                 help='temporary manifest to use for this sync', metavar='NAME.xml')
+            "projects no longer exist in the manifest. "
-    p.add_option('--clone-bundle', action='store_true',
+            "WARNING: this may cause loss of data",
-                 help='enable use of /clone.bundle on HTTP/HTTPS')
+        )
-    p.add_option('--no-clone-bundle', dest='clone_bundle', action='store_false',
+        p.add_option(
-                 help='disable use of /clone.bundle on HTTP/HTTPS')
+            "-l",
-    p.add_option('-u', '--manifest-server-username', action='store',
+            "--local-only",
-                 dest='manifest_server_username',
+            dest="local_only",
-                 help='username to authenticate with the manifest server')
+            action="store_true",
-    p.add_option('-p', '--manifest-server-password', action='store',
+            help="only update working tree, don't fetch",
-                 dest='manifest_server_password',
+        )
-                 help='password to authenticate with the manifest server')
+        p.add_option(
-    p.add_option('--fetch-submodules',
+            "--no-manifest-update",
-                 dest='fetch_submodules', action='store_true',
+            "--nmu",
-                 help='fetch submodules from server')
+            dest="mp_update",
-    p.add_option('--use-superproject', action='store_true',
+            action="store_false",
-                 help='use the manifest superproject to sync projects; implies -c')
+            default="true",
-    p.add_option('--no-use-superproject', action='store_false',
+            help="use the existing manifest checkout as-is. "
-                 dest='use_superproject',
+            "(do not update to the latest revision)",
-                 help='disable use of manifest superprojects')
+        )
-    p.add_option('--tags', action='store_true',
+        p.add_option(
-                 help='fetch tags')
+            "-n",
-    p.add_option('--no-tags',
+            "--network-only",
-                 dest='tags', action='store_false',
+            dest="network_only",
-                 help="don't fetch tags (default)")
+            action="store_true",
-    p.add_option('--optimized-fetch',
+            help="fetch only, don't update working tree",
-                 dest='optimized_fetch', action='store_true',
+        )
-                 help='only fetch projects fixed to sha1 if revision does not exist locally')
+        p.add_option(
-    p.add_option('--retry-fetches',
+            "-d",
-                 default=0, action='store', type='int',
+            "--detach",
-                 help='number of times to retry fetches on transient errors')
+            dest="detach_head",
-    p.add_option('--prune', action='store_true',
+            action="store_true",
-                 help='delete refs that no longer exist on the remote (default)')
+            help="detach projects back to manifest revision",
-    p.add_option('--no-prune', dest='prune', action='store_false',
+        )
-                 help='do not delete refs that no longer exist on the remote')
+        p.add_option(
-    p.add_option('--auto-gc', action='store_true', default=None,
+            "-c",
-                 help='run garbage collection on all synced projects')
+            "--current-branch",
-    p.add_option('--no-auto-gc', dest='auto_gc', action='store_false',
+            dest="current_branch_only",
-                 help='do not run garbage collection on any projects (default)')
+            action="store_true",
-    if show_smart:
+            help="fetch only current branch from server",
-      p.add_option('-s', '--smart-sync',
+        )
-                   dest='smart_sync', action='store_true',
+        p.add_option(
-                   help='smart sync using manifest from the latest known good build')
+            "--no-current-branch",
-      p.add_option('-t', '--smart-tag',
+            dest="current_branch_only",
-                   dest='smart_tag', action='store',
+            action="store_false",
-                   help='smart sync using manifest from a known tag')
+            help="fetch all branches from server",
+        )
-    g = p.add_option_group('repo Version options')
+        p.add_option(
-    g.add_option('--no-repo-verify',
+            "-m",
-                 dest='repo_verify', default=True, action='store_false',
+            "--manifest-name",
-                 help='do not verify repo source code')
+            dest="manifest_name",
-    g.add_option('--repo-upgraded',
+            help="temporary manifest to use for this sync",
-                 dest='repo_upgraded', action='store_true',
+            metavar="NAME.xml",
-                 help=SUPPRESS_HELP)
+        )
+        p.add_option(
-  def _GetBranch(self, manifest_project):
+            "--clone-bundle",
-    """Returns the branch name for getting the approved smartsync manifest.
+            action="store_true",
+            help="enable use of /clone.bundle on HTTP/HTTPS",
-    Args:
+        )
-      manifest_project: the manifestProject to query.
+        p.add_option(
-    """
+            "--no-clone-bundle",
-    b = manifest_project.GetBranch(manifest_project.CurrentBranch)
+            dest="clone_bundle",
-    branch = b.merge
+            action="store_false",
-    if branch.startswith(R_HEADS):
+            help="disable use of /clone.bundle on HTTP/HTTPS",
-      branch = branch[len(R_HEADS):]
+        )
-    return branch
+        p.add_option(
+            "-u",
-  def _GetCurrentBranchOnly(self, opt, manifest):
+            "--manifest-server-username",
-    """Returns whether current-branch or use-superproject options are enabled.
+            action="store",
+            dest="manifest_server_username",
-    Args:
+            help="username to authenticate with the manifest server",
-      opt: Program options returned from optparse.  See _Options().
+        )
-      manifest: The manifest to use.
+        p.add_option(
+            "-p",
-    Returns:
+            "--manifest-server-password",
-      True if a superproject is requested, otherwise the value of the
+            action="store",
-      current_branch option (True, False or None).
+            dest="manifest_server_password",
-    """
+            help="password to authenticate with the manifest server",
-    return git_superproject.UseSuperproject(opt.use_superproject, manifest) or opt.current_branch_only
+        )
+        p.add_option(
-  def _UpdateProjectsRevisionId(self, opt, args, superproject_logging_data,
+            "--fetch-submodules",
-                                manifest):
+            dest="fetch_submodules",
-    """Update revisionId of projects with the commit hash from the superproject.
+            action="store_true",
+            help="fetch submodules from server",
-    This function updates each project's revisionId with the commit hash from
+        )
-    the superproject.  It writes the updated manifest into a file and reloads
+        p.add_option(
-    the manifest from it.  When appropriate, sub manifests are also processed.
+            "--use-superproject",
+            action="store_true",
-    Args:
+            help="use the manifest superproject to sync projects; implies -c",
-      opt: Program options returned from optparse.  See _Options().
+        )
-      args: Arguments to pass to GetProjects. See the GetProjects
+        p.add_option(
-          docstring for details.
+            "--no-use-superproject",
-      superproject_logging_data: A dictionary of superproject data to log.
+            action="store_false",
-      manifest: The manifest to use.
+            dest="use_superproject",
-    """
+            help="disable use of manifest superprojects",
-    have_superproject = manifest.superproject or any(
+        )
-        m.superproject for m in manifest.all_children)
+        p.add_option("--tags", action="store_true", help="fetch tags")
-    if not have_superproject:
+        p.add_option(
-      return
+            "--no-tags",
+            dest="tags",
-    if opt.local_only and manifest.superproject:
+            action="store_false",
-      manifest_path = manifest.superproject.manifest_path
+            help="don't fetch tags (default)",
-      if manifest_path:
+        )
-        self._ReloadManifest(manifest_path, manifest)
+        p.add_option(
-      return
+            "--optimized-fetch",
+            dest="optimized_fetch",
-    all_projects = self.GetProjects(args,
+            action="store_true",
-                                    missing_ok=True,
+            help="only fetch projects fixed to sha1 if revision does not exist "
-                                    submodules_ok=opt.fetch_submodules,
+            "locally",
-                                    manifest=manifest,
+        )
-                                    all_manifests=not opt.this_manifest_only)
+        p.add_option(
+            "--retry-fetches",
-    per_manifest = collections.defaultdict(list)
+            default=0,
-    manifest_paths = {}
+            action="store",
-    if opt.this_manifest_only:
+            type="int",
-      per_manifest[manifest.path_prefix] = all_projects
+            help="number of times to retry fetches on transient errors",
-    else:
+        )
-      for p in all_projects:
+        p.add_option(
-        per_manifest[p.manifest.path_prefix].append(p)
+            "--prune",
+            action="store_true",
-    superproject_logging_data = {}
+            help="delete refs that no longer exist on the remote (default)",
-    need_unload = False
+        )
-    for m in self.ManifestList(opt):
+        p.add_option(
-      if not m.path_prefix in per_manifest:
+            "--no-prune",
-        continue
+            dest="prune",
-      use_super = git_superproject.UseSuperproject(opt.use_superproject, m)
+            action="store_false",
-      if superproject_logging_data:
+            help="do not delete refs that no longer exist on the remote",
-        superproject_logging_data['multimanifest'] = True
+        )
-      superproject_logging_data.update(
+        p.add_option(
-          superproject=use_super,
+            "--auto-gc",
-          haslocalmanifests=bool(m.HasLocalManifests),
+            action="store_true",
-          hassuperprojecttag=bool(m.superproject),
+            default=None,
-      )
+            help="run garbage collection on all synced projects",
-      if use_super and (m.IsMirror or m.IsArchive):
+        )
-        # Don't use superproject, because we have no working tree.
+        p.add_option(
-        use_super = False
+            "--no-auto-gc",
-        superproject_logging_data['superproject'] = False
+            dest="auto_gc",
-        superproject_logging_data['noworktree'] = True
+            action="store_false",
-        if opt.use_superproject is not False:
+            help="do not run garbage collection on any projects (default)",
-          print(f'{m.path_prefix}: not using superproject because there is no '
+        )
-                'working tree.')
+        if show_smart:
+            p.add_option(
-      if not use_super:
+                "-s",
-        continue
+                "--smart-sync",
-      m.superproject.SetQuiet(opt.quiet)
+                dest="smart_sync",
-      print_messages = git_superproject.PrintMessages(opt.use_superproject, m)
+                action="store_true",
-      m.superproject.SetPrintMessages(print_messages)
+                help="smart sync using manifest from the latest known good "
-      update_result = m.superproject.UpdateProjectsRevisionId(
+                "build",
-          per_manifest[m.path_prefix], git_event_log=self.git_event_log)
+            )
-      manifest_path = update_result.manifest_path
+            p.add_option(
-      superproject_logging_data['updatedrevisionid'] = bool(manifest_path)
+                "-t",
-      if manifest_path:
+                "--smart-tag",
-        m.SetManifestOverride(manifest_path)
+                dest="smart_tag",
-        need_unload = True
+                action="store",
-      else:
+                help="smart sync using manifest from a known tag",
-        if print_messages:
+            )
-          print(f'{m.path_prefix}: warning: Update of revisionId from '
-                'superproject has failed, repo sync will not use superproject '
+        g = p.add_option_group("repo Version options")
-                'to fetch the source. ',
+        g.add_option(
-                'Please resync with the --no-use-superproject option to avoid '
+            "--no-repo-verify",
-                'this repo warning.',
+            dest="repo_verify",
-                file=sys.stderr)
+            default=True,
-        if update_result.fatal and opt.use_superproject is not None:
+            action="store_false",
-          sys.exit(1)
+            help="do not verify repo source code",
-    if need_unload:
+        )
-      m.outer_client.manifest.Unload()
+        g.add_option(
+            "--repo-upgraded",
-  def _FetchProjectList(self, opt, projects):
+            dest="repo_upgraded",
-    """Main function of the fetch worker.
+            action="store_true",
+            help=SUPPRESS_HELP,
-    The projects we're given share the same underlying git object store, so we
+        )
-    have to fetch them in serial.
-    Delegates most of the work to _FetchHelper.
-    Args:
-      opt: Program options returned from optparse.  See _Options().
-      projects: Projects to fetch.
-    """
-    return [self._FetchOne(opt, x) for x in projects]
-  def _FetchOne(self, opt, project):
+    def _GetBranch(self, manifest_project):
-    """Fetch git objects for a single project.
+        """Returns the branch name for getting the approved smartsync manifest.
+        Args:
+            manifest_project: The manifestProject to query.
+        """
+        b = manifest_project.GetBranch(manifest_project.CurrentBranch)
+        branch = b.merge
+        if branch.startswith(R_HEADS):
+            branch = branch[len(R_HEADS) :]
+        return branch
+    def _GetCurrentBranchOnly(self, opt, manifest):
+        """Returns whether current-branch or use-superproject options are
+        enabled.
+        Args:
+            opt: Program options returned from optparse.  See _Options().
+            manifest: The manifest to use.
+        Returns:
+            True if a superproject is requested, otherwise the value of the
+            current_branch option (True, False or None).
+        """
+        return (
+            git_superproject.UseSuperproject(opt.use_superproject, manifest)
+            or opt.current_branch_only
+        )
-    Args:
+    def _UpdateProjectsRevisionId(
-      opt: Program options returned from optparse.  See _Options().
+        self, opt, args, superproject_logging_data, manifest
-      project: Project object for the project to fetch.
+    ):
+        """Update revisionId of projects with the commit from the superproject.
+        This function updates each project's revisionId with the commit hash
+        from the superproject.  It writes the updated manifest into a file and
+        reloads the manifest from it.  When appropriate, sub manifests are also
+        processed.
+        Args:
+            opt: Program options returned from optparse.  See _Options().
+            args: Arguments to pass to GetProjects. See the GetProjects
+                docstring for details.
+            superproject_logging_data: A dictionary of superproject data to log.
+            manifest: The manifest to use.
+        """
+        have_superproject = manifest.superproject or any(
+            m.superproject for m in manifest.all_children
+        )
+        if not have_superproject:
+            return
+        if opt.local_only and manifest.superproject:
+            manifest_path = manifest.superproject.manifest_path
+            if manifest_path:
+                self._ReloadManifest(manifest_path, manifest)
+            return
+        all_projects = self.GetProjects(
+            args,
+            missing_ok=True,
+            submodules_ok=opt.fetch_submodules,
+            manifest=manifest,
+            all_manifests=not opt.this_manifest_only,
+        )
-    Returns:
+        per_manifest = collections.defaultdict(list)
-      Whether the fetch was successful.
+        if opt.this_manifest_only:
-    """
+            per_manifest[manifest.path_prefix] = all_projects
-    start = time.time()
+        else:
-    success = False
+            for p in all_projects:
-    remote_fetched = False
+                per_manifest[p.manifest.path_prefix].append(p)
-    buf = io.StringIO()
-    try:
+        superproject_logging_data = {}
-      sync_result = project.Sync_NetworkHalf(
+        need_unload = False
-          quiet=opt.quiet,
+        for m in self.ManifestList(opt):
-          verbose=opt.verbose,
+            if m.path_prefix not in per_manifest:
-          output_redir=buf,
+                continue
-          current_branch_only=self._GetCurrentBranchOnly(opt, project.manifest),
+            use_super = git_superproject.UseSuperproject(
-          force_sync=opt.force_sync,
+                opt.use_superproject, m
-          clone_bundle=opt.clone_bundle,
+            )
-          tags=opt.tags, archive=project.manifest.IsArchive,
+            if superproject_logging_data:
-          optimized_fetch=opt.optimized_fetch,
+                superproject_logging_data["multimanifest"] = True
-          retry_fetches=opt.retry_fetches,
+            superproject_logging_data.update(
-          prune=opt.prune,
+                superproject=use_super,
-          ssh_proxy=self.ssh_proxy,
+                haslocalmanifests=bool(m.HasLocalManifests),
-          clone_filter=project.manifest.CloneFilter,
+                hassuperprojecttag=bool(m.superproject),
-          partial_clone_exclude=project.manifest.PartialCloneExclude)
+            )
-      success = sync_result.success
+            if use_super and (m.IsMirror or m.IsArchive):
-      remote_fetched = sync_result.remote_fetched
+                # Don't use superproject, because we have no working tree.
+                use_super = False
-      output = buf.getvalue()
+                superproject_logging_data["superproject"] = False
-      if (opt.verbose or not success) and output:
+                superproject_logging_data["noworktree"] = True
-        print('\n' + output.rstrip())
+                if opt.use_superproject is not False:
+                    print(
-      if not success:
+                        f"{m.path_prefix}: not using superproject because "
-        print('error: Cannot fetch %s from %s'
+                        "there is no working tree."
-              % (project.name, project.remote.url),
+                    )
-              file=sys.stderr)
-    except KeyboardInterrupt:
+            if not use_super:
-      print(f'Keyboard interrupt while processing {project.name}')
+                continue
-    except GitError as e:
+            m.superproject.SetQuiet(opt.quiet)
-      print('error.GitError: Cannot fetch %s' % str(e), file=sys.stderr)
+            print_messages = git_superproject.PrintMessages(
-    except Exception as e:
+                opt.use_superproject, m
-      print('error: Cannot fetch %s (%s: %s)'
+            )
-            % (project.name, type(e).__name__, str(e)), file=sys.stderr)
+            m.superproject.SetPrintMessages(print_messages)
-      raise
+            update_result = m.superproject.UpdateProjectsRevisionId(
+                per_manifest[m.path_prefix], git_event_log=self.git_event_log
-    finish = time.time()
+            )
-    return _FetchOneResult(success, project, start, finish, remote_fetched)
+            manifest_path = update_result.manifest_path
+            superproject_logging_data["updatedrevisionid"] = bool(manifest_path)
-  @classmethod
+            if manifest_path:
-  def _FetchInitChild(cls, ssh_proxy):
+                m.SetManifestOverride(manifest_path)
-    cls.ssh_proxy = ssh_proxy
+                need_unload = True
+            else:
-  def _Fetch(self, projects, opt, err_event, ssh_proxy):
+                if print_messages:
-    ret = True
+                    print(
+                        f"{m.path_prefix}: warning: Update of revisionId from "
-    jobs = opt.jobs_network
+                        "superproject has failed, repo sync will not use "
-    fetched = set()
+                        "superproject to fetch the source. ",
-    remote_fetched = set()
+                        "Please resync with the --no-use-superproject option "
-    pm = Progress('Fetching', len(projects), delay=False, quiet=opt.quiet)
+                        "to avoid this repo warning.",
+                        file=sys.stderr,
-    objdir_project_map = dict()
+                    )
-    for project in projects:
+                if update_result.fatal and opt.use_superproject is not None:
-      objdir_project_map.setdefault(project.objdir, []).append(project)
+                    sys.exit(1)
-    projects_list = list(objdir_project_map.values())
+        if need_unload:
+            m.outer_client.manifest.Unload()
-    def _ProcessResults(results_sets):
-      ret = True
+    def _FetchProjectList(self, opt, projects):
-      for results in results_sets:
+        """Main function of the fetch worker.
-        for result in results:
-          success = result.success
+        The projects we're given share the same underlying git object store, so
-          project = result.project
+        we have to fetch them in serial.
-          start = result.start
-          finish = result.finish
+        Delegates most of the work to _FetchHelper.
-          self._fetch_times.Set(project, finish - start)
-          self.event_log.AddSync(project, event_log.TASK_SYNC_NETWORK,
+        Args:
-                                 start, finish, success)
+            opt: Program options returned from optparse.  See _Options().
-          if result.remote_fetched:
+            projects: Projects to fetch.
-            remote_fetched.add(project)
+        """
-          # Check for any errors before running any more tasks.
+        return [self._FetchOne(opt, x) for x in projects]
-          # ...we'll let existing jobs finish, though.
-          if not success:
+    def _FetchOne(self, opt, project):
-            ret = False
+        """Fetch git objects for a single project.
-          else:
-            fetched.add(project.gitdir)
+        Args:
-          pm.update(msg=f'Last synced: {project.name}')
+            opt: Program options returned from optparse.  See _Options().
-        if not ret and opt.fail_fast:
+            project: Project object for the project to fetch.
-          break
-      return ret
+        Returns:
+            Whether the fetch was successful.
-    # We pass the ssh proxy settings via the class.  This allows multiprocessing
+        """
-    # to pickle it up when spawning children.  We can't pass it as an argument
+        start = time.time()
-    # to _FetchProjectList below as multiprocessing is unable to pickle those.
+        success = False
-    Sync.ssh_proxy = None
+        remote_fetched = False
+        buf = io.StringIO()
-    # NB: Multiprocessing is heavy, so don't spin it up for one job.
+        try:
-    if len(projects_list) == 1 or jobs == 1:
+            sync_result = project.Sync_NetworkHalf(
-      self._FetchInitChild(ssh_proxy)
+                quiet=opt.quiet,
-      if not _ProcessResults(self._FetchProjectList(opt, x) for x in projects_list):
+                verbose=opt.verbose,
-        ret = False
+                output_redir=buf,
-    else:
+                current_branch_only=self._GetCurrentBranchOnly(
-      # Favor throughput over responsiveness when quiet.  It seems that imap()
+                    opt, project.manifest
-      # will yield results in batches relative to chunksize, so even as the
+                ),
-      # children finish a sync, we won't see the result until one child finishes
+                force_sync=opt.force_sync,
-      # ~chunksize jobs.  When using a large --jobs with large chunksize, this
+                clone_bundle=opt.clone_bundle,
-      # can be jarring as there will be a large initial delay where repo looks
+                tags=opt.tags,
-      # like it isn't doing anything and sits at 0%, but then suddenly completes
+                archive=project.manifest.IsArchive,
-      # a lot of jobs all at once.  Since this code is more network bound, we
+                optimized_fetch=opt.optimized_fetch,
-      # can accept a bit more CPU overhead with a smaller chunksize so that the
+                retry_fetches=opt.retry_fetches,
-      # user sees more immediate & continuous feedback.
+                prune=opt.prune,
-      if opt.quiet:
+                ssh_proxy=self.ssh_proxy,
-        chunksize = WORKER_BATCH_SIZE
+                clone_filter=project.manifest.CloneFilter,
-      else:
+                partial_clone_exclude=project.manifest.PartialCloneExclude,
-        pm.update(inc=0, msg='warming up')
+            )
-        chunksize = 4
+            success = sync_result.success
-      with multiprocessing.Pool(jobs, initializer=self._FetchInitChild,
+            remote_fetched = sync_result.remote_fetched
-                                initargs=(ssh_proxy,)) as pool:
-        results = pool.imap_unordered(
+            output = buf.getvalue()
-            functools.partial(self._FetchProjectList, opt),
+            if (opt.verbose or not success) and output:
-            projects_list,
+                print("\n" + output.rstrip())
-            chunksize=chunksize)
-        if not _ProcessResults(results):
+            if not success:
-          ret = False
+                print(
-          pool.close()
+                    "error: Cannot fetch %s from %s"
+                    % (project.name, project.remote.url),
-    # Cleanup the reference now that we're done with it, and we're going to
+                    file=sys.stderr,
-    # release any resources it points to.  If we don't, later multiprocessing
+                )
-    # usage (e.g. checkouts) will try to pickle and then crash.
+        except KeyboardInterrupt:
-    del Sync.ssh_proxy
+            print(f"Keyboard interrupt while processing {project.name}")
+        except GitError as e:
-    pm.end()
+            print("error.GitError: Cannot fetch %s" % str(e), file=sys.stderr)
-    self._fetch_times.Save()
+        except Exception as e:
+            print(
-    if not self.outer_client.manifest.IsArchive:
+                "error: Cannot fetch %s (%s: %s)"
-      self._GCProjects(projects, opt, err_event)
+                % (project.name, type(e).__name__, str(e)),
+                file=sys.stderr,
-    return _FetchResult(ret, fetched)
+            )
+            raise
-  def _FetchMain(self, opt, args, all_projects, err_event,
-                 ssh_proxy, manifest):
+        finish = time.time()
-    """The main network fetch loop.
+        return _FetchOneResult(success, project, start, finish, remote_fetched)
-    Args:
+    @classmethod
-      opt: Program options returned from optparse.  See _Options().
+    def _FetchInitChild(cls, ssh_proxy):
-      args: Command line args used to filter out projects.
+        cls.ssh_proxy = ssh_proxy
-      all_projects: List of all projects that should be fetched.
-      err_event: Whether an error was hit while processing.
+    def _Fetch(self, projects, opt, err_event, ssh_proxy):
-      ssh_proxy: SSH manager for clients & masters.
+        ret = True
-      manifest: The manifest to use.
+        jobs = opt.jobs_network
-    Returns:
+        fetched = set()
-      List of all projects that should be checked out.
+        remote_fetched = set()
-    """
+        pm = Progress("Fetching", len(projects), delay=False, quiet=opt.quiet)
-    rp = manifest.repoProject
+        objdir_project_map = dict()
-    to_fetch = []
+        for project in projects:
-    now = time.time()
+            objdir_project_map.setdefault(project.objdir, []).append(project)
-    if _ONE_DAY_S <= (now - rp.LastFetch):
+        projects_list = list(objdir_project_map.values())
-      to_fetch.append(rp)
-    to_fetch.extend(all_projects)
+        def _ProcessResults(results_sets):
-    to_fetch.sort(key=self._fetch_times.Get, reverse=True)
+            ret = True
+            for results in results_sets:
-    result = self._Fetch(to_fetch, opt, err_event, ssh_proxy)
+                for result in results:
-    success = result.success
+                    success = result.success
-    fetched = result.projects
+                    project = result.project
-    if not success:
+                    start = result.start
-      err_event.set()
+                    finish = result.finish
+                    self._fetch_times.Set(project, finish - start)
-    _PostRepoFetch(rp, opt.repo_verify)
+                    self.event_log.AddSync(
-    if opt.network_only:
+                        project,
-      # bail out now; the rest touches the working tree
+                        event_log.TASK_SYNC_NETWORK,
-      if err_event.is_set():
+                        start,
-        print('\nerror: Exited sync due to fetch errors.\n', file=sys.stderr)
+                        finish,
-        sys.exit(1)
+                        success,
-      return _FetchMainResult([])
+                    )
+                    if result.remote_fetched:
-    # Iteratively fetch missing and/or nested unregistered submodules
+                        remote_fetched.add(project)
-    previously_missing_set = set()
+                    # Check for any errors before running any more tasks.
-    while True:
+                    # ...we'll let existing jobs finish, though.
-      self._ReloadManifest(None, manifest)
+                    if not success:
-      all_projects = self.GetProjects(args,
+                        ret = False
-                                      missing_ok=True,
+                    else:
-                                      submodules_ok=opt.fetch_submodules,
+                        fetched.add(project.gitdir)
-                                      manifest=manifest,
+                    pm.update(msg=f"Last synced: {project.name}")
-                                      all_manifests=not opt.this_manifest_only)
+                if not ret and opt.fail_fast:
-      missing = []
+                    break
-      for project in all_projects:
+            return ret
-        if project.gitdir not in fetched:
-          missing.append(project)
-      if not missing:
-        break
-      # Stop us from non-stopped fetching actually-missing repos: If set of
-      # missing repos has not been changed from last fetch, we break.
-      missing_set = set(p.name for p in missing)
-      if previously_missing_set == missing_set:
-        break
-      previously_missing_set = missing_set
-      result = self._Fetch(missing, opt, err_event, ssh_proxy)
-      success = result.success
-      new_fetched = result.projects
-      if not success:
-        err_event.set()
-      fetched.update(new_fetched)
-    return _FetchMainResult(all_projects)
-  def _CheckoutOne(self, detach_head, force_sync, project):
-    """Checkout work tree for one project
-    Args:
-      detach_head: Whether to leave a detached HEAD.
-      force_sync: Force checking out of the repo.
-      project: Project object for the project to checkout.
-    Returns:
-      Whether the fetch was successful.
-    """
-    start = time.time()
-    syncbuf = SyncBuffer(project.manifest.manifestProject.config,
-                         detach_head=detach_head)
-    success = False
-    try:
-      project.Sync_LocalHalf(syncbuf, force_sync=force_sync)
-      success = syncbuf.Finish()
-    except GitError as e:
-      print('error.GitError: Cannot checkout %s: %s' %
-            (project.name, str(e)), file=sys.stderr)
-    except Exception as e:
-      print('error: Cannot checkout %s: %s: %s' %
-            (project.name, type(e).__name__, str(e)),
-            file=sys.stderr)
-      raise
-    if not success:
-      print('error: Cannot checkout %s' % (project.name), file=sys.stderr)
-    finish = time.time()
-    return _CheckoutOneResult(success, project, start, finish)
-  def _Checkout(self, all_projects, opt, err_results):
-    """Checkout projects listed in all_projects
-    Args:
-      all_projects: List of all projects that should be checked out.
-      opt: Program options returned from optparse.  See _Options().
-      err_results: A list of strings, paths to git repos where checkout failed.
-    """
-    # Only checkout projects with worktrees.
-    all_projects = [x for x in all_projects if x.worktree]
-    def _ProcessResults(pool, pm, results):
+        # We pass the ssh proxy settings via the class.  This allows
-      ret = True
+        # multiprocessing to pickle it up when spawning children.  We can't pass
-      for result in results:
+        # it as an argument to _FetchProjectList below as multiprocessing is
+        # unable to pickle those.
+        Sync.ssh_proxy = None
+        # NB: Multiprocessing is heavy, so don't spin it up for one job.
+        if len(projects_list) == 1 or jobs == 1:
+            self._FetchInitChild(ssh_proxy)
+            if not _ProcessResults(
+                self._FetchProjectList(opt, x) for x in projects_list
+            ):
+                ret = False
+        else:
+            # Favor throughput over responsiveness when quiet.  It seems that
+            # imap() will yield results in batches relative to chunksize, so
+            # even as the children finish a sync, we won't see the result until
+            # one child finishes ~chunksize jobs.  When using a large --jobs
+            # with large chunksize, this can be jarring as there will be a large
+            # initial delay where repo looks like it isn't doing anything and
+            # sits at 0%, but then suddenly completes a lot of jobs all at once.
+            # Since this code is more network bound, we can accept a bit more
+            # CPU overhead with a smaller chunksize so that the user sees more
+            # immediate & continuous feedback.
+            if opt.quiet:
+                chunksize = WORKER_BATCH_SIZE
+            else:
+                pm.update(inc=0, msg="warming up")
+                chunksize = 4
+            with multiprocessing.Pool(
+                jobs, initializer=self._FetchInitChild, initargs=(ssh_proxy,)
+            ) as pool:
+                results = pool.imap_unordered(
+                    functools.partial(self._FetchProjectList, opt),
+                    projects_list,
+                    chunksize=chunksize,
+                )
+                if not _ProcessResults(results):
+                    ret = False
+                    pool.close()
+        # Cleanup the reference now that we're done with it, and we're going to
+        # release any resources it points to.  If we don't, later
+        # multiprocessing usage (e.g. checkouts) will try to pickle and then
+        # crash.
+        del Sync.ssh_proxy
+        pm.end()
+        self._fetch_times.Save()
+        if not self.outer_client.manifest.IsArchive:
+            self._GCProjects(projects, opt, err_event)
+        return _FetchResult(ret, fetched)
+    def _FetchMain(
+        self, opt, args, all_projects, err_event, ssh_proxy, manifest
+    ):
+        """The main network fetch loop.
+        Args:
+            opt: Program options returned from optparse.  See _Options().
+            args: Command line args used to filter out projects.
+            all_projects: List of all projects that should be fetched.
+            err_event: Whether an error was hit while processing.
+            ssh_proxy: SSH manager for clients & masters.
+            manifest: The manifest to use.
+        Returns:
+            List of all projects that should be checked out.
+        """
+        rp = manifest.repoProject
+        to_fetch = []
+        now = time.time()
+        if _ONE_DAY_S <= (now - rp.LastFetch):
+            to_fetch.append(rp)
+        to_fetch.extend(all_projects)
+        to_fetch.sort(key=self._fetch_times.Get, reverse=True)
+        result = self._Fetch(to_fetch, opt, err_event, ssh_proxy)
        success = result.success
-        project = result.project
+        fetched = result.projects
-        start = result.start
-        finish = result.finish
-        self.event_log.AddSync(project, event_log.TASK_SYNC_LOCAL,
-                               start, finish, success)
-        # Check for any errors before running any more tasks.
-        # ...we'll let existing jobs finish, though.
        if not success:
-          ret = False
+            err_event.set()
-          err_results.append(project.RelPath(local=opt.this_manifest_only))
-          if opt.fail_fast:
+        _PostRepoFetch(rp, opt.repo_verify)
-            if pool:
+        if opt.network_only:
-              pool.close()
+            # Bail out now; the rest touches the working tree.
+            if err_event.is_set():
+                print(
+                    "\nerror: Exited sync due to fetch errors.\n",
+                    file=sys.stderr,
+                )
+                sys.exit(1)
+            return _FetchMainResult([])
+        # Iteratively fetch missing and/or nested unregistered submodules.
+        previously_missing_set = set()
+        while True:
+            self._ReloadManifest(None, manifest)
+            all_projects = self.GetProjects(
+                args,
+                missing_ok=True,
+                submodules_ok=opt.fetch_submodules,
+                manifest=manifest,
+                all_manifests=not opt.this_manifest_only,
+            )
+            missing = []
+            for project in all_projects:
+                if project.gitdir not in fetched:
+                    missing.append(project)
+            if not missing:
+                break
+            # Stop us from non-stopped fetching actually-missing repos: If set
+            # of missing repos has not been changed from last fetch, we break.
+            missing_set = set(p.name for p in missing)
+            if previously_missing_set == missing_set:
+                break
+            previously_missing_set = missing_set
+            result = self._Fetch(missing, opt, err_event, ssh_proxy)
+            success = result.success
+            new_fetched = result.projects
+            if not success:
+                err_event.set()
+            fetched.update(new_fetched)
+        return _FetchMainResult(all_projects)
+    def _CheckoutOne(self, detach_head, force_sync, project):
+        """Checkout work tree for one project
+        Args:
+            detach_head: Whether to leave a detached HEAD.
+            force_sync: Force checking out of the repo.
+            project: Project object for the project to checkout.
+        Returns:
+            Whether the fetch was successful.
+        """
+        start = time.time()
+        syncbuf = SyncBuffer(
+            project.manifest.manifestProject.config, detach_head=detach_head
+        )
+        success = False
+        try:
+            project.Sync_LocalHalf(syncbuf, force_sync=force_sync)
+            success = syncbuf.Finish()
+        except GitError as e:
+            print(
+                "error.GitError: Cannot checkout %s: %s"
+                % (project.name, str(e)),
+                file=sys.stderr,
+            )
+        except Exception as e:
+            print(
+                "error: Cannot checkout %s: %s: %s"
+                % (project.name, type(e).__name__, str(e)),
+                file=sys.stderr,
+            )
+            raise
+        if not success:
+            print("error: Cannot checkout %s" % (project.name), file=sys.stderr)
+        finish = time.time()
+        return _CheckoutOneResult(success, project, start, finish)
+    def _Checkout(self, all_projects, opt, err_results):
+        """Checkout projects listed in all_projects
+        Args:
+            all_projects: List of all projects that should be checked out.
+            opt: Program options returned from optparse.  See _Options().
+            err_results: A list of strings, paths to git repos where checkout
+                failed.
+        """
+        # Only checkout projects with worktrees.
+        all_projects = [x for x in all_projects if x.worktree]
+        def _ProcessResults(pool, pm, results):
+            ret = True
+            for result in results:
+                success = result.success
+                project = result.project
+                start = result.start
+                finish = result.finish
+                self.event_log.AddSync(
+                    project, event_log.TASK_SYNC_LOCAL, start, finish, success
+                )
+                # Check for any errors before running any more tasks.
+                # ...we'll let existing jobs finish, though.
+                if not success:
+                    ret = False
+                    err_results.append(
+                        project.RelPath(local=opt.this_manifest_only)
+                    )
+                    if opt.fail_fast:
+                        if pool:
+                            pool.close()
+                        return ret
+                pm.update(msg=project.name)
            return ret
-        pm.update(msg=project.name)
-      return ret
-    return self.ExecuteInParallel(
-        opt.jobs_checkout,
-        functools.partial(self._CheckoutOne, opt.detach_head, opt.force_sync),
-        all_projects,
-        callback=_ProcessResults,
-        output=Progress('Checking out', len(all_projects), quiet=opt.quiet)) and not err_results
-  @staticmethod
-  def _GetPreciousObjectsState(project: Project, opt):
-    """Get the preciousObjects state for the project.
-    Args:
-      project (Project): the project to examine, and possibly correct.
-      opt (optparse.Values): options given to sync.
-    Returns:
-      Expected state of extensions.preciousObjects:
-        False: Should be disabled. (not present)
-        True: Should be enabled.
-    """
-    if project.use_git_worktrees:
-      return False
-    projects = project.manifest.GetProjectsWithName(project.name,
-                                                    all_manifests=True)
-    if len(projects) == 1:
-      return False
-    relpath = project.RelPath(local=opt.this_manifest_only)
-    if len(projects) > 1:
-      # Objects are potentially shared with another project.
-      # See the logic in Project.Sync_NetworkHalf regarding UseAlternates.
-      # - When False, shared projects share (via symlink)
-      #   .repo/project-objects/{PROJECT_NAME}.git as the one-and-only objects
-      #   directory.  All objects are precious, since there is no project with a
-      #   complete set of refs.
-      # - When True, shared projects share (via info/alternates)
-      #   .repo/project-objects/{PROJECT_NAME}.git as an alternate object store,
-      #   which is written only on the first clone of the project, and is not
-      #   written subsequently.  (When Sync_NetworkHalf sees that it exists, it
-      #   makes sure that the alternates file points there, and uses a
-      #   project-local .git/objects directory for all syncs going forward.
-      # We do not support switching between the options.  The environment
-      # variable is present for testing and migration only.
-      return not project.UseAlternates
-    return False
-  def _SetPreciousObjectsState(self, project: Project, opt):
-    """Correct the preciousObjects state for the project.
-    Args:
-      project: the project to examine, and possibly correct.
-      opt: options given to sync.
-    """
-    expected = self._GetPreciousObjectsState(project, opt)
-    actual = project.config.GetBoolean('extensions.preciousObjects') or False
-    relpath = project.RelPath(local=opt.this_manifest_only)
-    if expected != actual:
-      # If this is unexpected, log it and repair.
-      Trace(f'{relpath} expected preciousObjects={expected}, got {actual}')
-      if expected:
-        if not opt.quiet:
-          print('\r%s: Shared project %s found, disabling pruning.' %
-                (relpath, project.name))
-        if git_require((2, 7, 0)):
-          project.EnableRepositoryExtension('preciousObjects')
-        else:
-          # This isn't perfect, but it's the best we can do with old git.
-          print('\r%s: WARNING: shared projects are unreliable when using '
-                'old versions of git; please upgrade to git-2.7.0+.'
-                % (relpath,),
-                file=sys.stderr)
-          project.config.SetString('gc.pruneExpire', 'never')
-      else:
-        if not opt.quiet:
-          print(f'\r{relpath}: not shared, disabling pruning.')
-        project.config.SetString('extensions.preciousObjects', None)
-        project.config.SetString('gc.pruneExpire', None)
-  def _GCProjects(self, projects, opt, err_event):
+        return (
-    """Perform garbage collection.
+            self.ExecuteInParallel(
+                opt.jobs_checkout,
+                functools.partial(
+                    self._CheckoutOne, opt.detach_head, opt.force_sync
+                ),
+                all_projects,
+                callback=_ProcessResults,
+                output=Progress(
+                    "Checking out", len(all_projects), quiet=opt.quiet
+                ),
+            )
+            and not err_results
+        )
-    If We are skipping garbage collection (opt.auto_gc not set), we still want
+    @staticmethod
-    to potentially mark objects precious, so that `git gc` does not discard
+    def _GetPreciousObjectsState(project: Project, opt):
-    shared objects.
+        """Get the preciousObjects state for the project.
-    """
-    if not opt.auto_gc:
+        Args:
-      # Just repair preciousObjects state, and return.
+            project (Project): the project to examine, and possibly correct.
-      for project in projects:
+            opt (optparse.Values): options given to sync.
-        self._SetPreciousObjectsState(project, opt)
-      return
+        Returns:
+            Expected state of extensions.preciousObjects:
-    pm = Progress('Garbage collecting', len(projects), delay=False,
+                False: Should be disabled. (not present)
-                  quiet=opt.quiet)
+                True: Should be enabled.
-    pm.update(inc=0, msg='prescan')
+        """
+        if project.use_git_worktrees:
-    tidy_dirs = {}
+            return False
-    for project in projects:
+        projects = project.manifest.GetProjectsWithName(
-      self._SetPreciousObjectsState(project, opt)
+            project.name, all_manifests=True
-      project.config.SetString('gc.autoDetach', 'false')
-      # Only call git gc once per objdir, but call pack-refs for the remainder.
-      if project.objdir not in tidy_dirs:
-        tidy_dirs[project.objdir] = (
-            True,  # Run a full gc.
-            project.bare_git,
        )
-      elif project.gitdir not in tidy_dirs:
+        if len(projects) == 1:
-        tidy_dirs[project.gitdir] = (
+            return False
-            False,  # Do not run a full gc; just run pack-refs.
+        if len(projects) > 1:
-            project.bare_git,
+            # Objects are potentially shared with another project.
+            # See the logic in Project.Sync_NetworkHalf regarding UseAlternates.
+            # - When False, shared projects share (via symlink)
+            #   .repo/project-objects/{PROJECT_NAME}.git as the one-and-only
+            #   objects directory.  All objects are precious, since there is no
+            #   project with a complete set of refs.
+            # - When True, shared projects share (via info/alternates)
+            #   .repo/project-objects/{PROJECT_NAME}.git as an alternate object
+            #   store, which is written only on the first clone of the project,
+            #   and is not written subsequently. (When Sync_NetworkHalf sees
+            #   that it exists, it makes sure that the alternates file points
+            #   there, and uses a project-local .git/objects directory for all
+            #   syncs going forward.
+            # We do not support switching between the options.  The environment
+            # variable is present for testing and migration only.
+            return not project.UseAlternates
+        return False
+    def _SetPreciousObjectsState(self, project: Project, opt):
+        """Correct the preciousObjects state for the project.
+        Args:
+            project: the project to examine, and possibly correct.
+            opt: options given to sync.
+        """
+        expected = self._GetPreciousObjectsState(project, opt)
+        actual = (
+            project.config.GetBoolean("extensions.preciousObjects") or False
        )
+        relpath = project.RelPath(local=opt.this_manifest_only)
-    jobs = opt.jobs
+        if expected != actual:
-    if jobs < 2:
+            # If this is unexpected, log it and repair.
-      for (run_gc, bare_git) in tidy_dirs.values():
+            Trace(
-        pm.update(msg=bare_git._project.name)
+                f"{relpath} expected preciousObjects={expected}, got {actual}"
+            )
-        if run_gc:
+            if expected:
-          bare_git.gc('--auto')
+                if not opt.quiet:
+                    print(
+                        "\r%s: Shared project %s found, disabling pruning."
+                        % (relpath, project.name)
+                    )
+                if git_require((2, 7, 0)):
+                    project.EnableRepositoryExtension("preciousObjects")
+                else:
+                    # This isn't perfect, but it's the best we can do with old
+                    # git.
+                    print(
+                        "\r%s: WARNING: shared projects are unreliable when "
+                        "using old versions of git; please upgrade to "
+                        "git-2.7.0+." % (relpath,),
+                        file=sys.stderr,
+                    )
+                    project.config.SetString("gc.pruneExpire", "never")
+            else:
+                if not opt.quiet:
+                    print(f"\r{relpath}: not shared, disabling pruning.")
+                project.config.SetString("extensions.preciousObjects", None)
+                project.config.SetString("gc.pruneExpire", None)
+    def _GCProjects(self, projects, opt, err_event):
+        """Perform garbage collection.
+        If We are skipping garbage collection (opt.auto_gc not set), we still
+        want to potentially mark objects precious, so that `git gc` does not
+        discard shared objects.
+        """
+        if not opt.auto_gc:
+            # Just repair preciousObjects state, and return.
+            for project in projects:
+                self._SetPreciousObjectsState(project, opt)
+            return
+        pm = Progress(
+            "Garbage collecting", len(projects), delay=False, quiet=opt.quiet
+        )
+        pm.update(inc=0, msg="prescan")
+        tidy_dirs = {}
+        for project in projects:
+            self._SetPreciousObjectsState(project, opt)
+            project.config.SetString("gc.autoDetach", "false")
+            # Only call git gc once per objdir, but call pack-refs for the
+            # remainder.
+            if project.objdir not in tidy_dirs:
+                tidy_dirs[project.objdir] = (
+                    True,  # Run a full gc.
+                    project.bare_git,
+                )
+            elif project.gitdir not in tidy_dirs:
+                tidy_dirs[project.gitdir] = (
+                    False,  # Do not run a full gc; just run pack-refs.
+                    project.bare_git,
+                )
+        jobs = opt.jobs
+        if jobs < 2:
+            for run_gc, bare_git in tidy_dirs.values():
+                pm.update(msg=bare_git._project.name)
+                if run_gc:
+                    bare_git.gc("--auto")
+                else:
+                    bare_git.pack_refs()
+            pm.end()
+            return
+        cpu_count = os.cpu_count()
+        config = {"pack.threads": cpu_count // jobs if cpu_count > jobs else 1}
+        threads = set()
+        sem = _threading.Semaphore(jobs)
+        def tidy_up(run_gc, bare_git):
+            pm.start(bare_git._project.name)
+            try:
+                try:
+                    if run_gc:
+                        bare_git.gc("--auto", config=config)
+                    else:
+                        bare_git.pack_refs(config=config)
+                except GitError:
+                    err_event.set()
+                except Exception:
+                    err_event.set()
+                    raise
+            finally:
+                pm.finish(bare_git._project.name)
+                sem.release()
+        for run_gc, bare_git in tidy_dirs.values():
+            if err_event.is_set() and opt.fail_fast:
+                break
+            sem.acquire()
+            t = _threading.Thread(
+                target=tidy_up,
+                args=(
+                    run_gc,
+                    bare_git,
+                ),
+            )
+            t.daemon = True
+            threads.add(t)
+            t.start()
+        for t in threads:
+            t.join()
+        pm.end()
+    def _ReloadManifest(self, manifest_name, manifest):
+        """Reload the manfiest from the file specified by the |manifest_name|.
+        It unloads the manifest if |manifest_name| is None.
+        Args:
+            manifest_name: Manifest file to be reloaded.
+            manifest: The manifest to use.
+        """
+        if manifest_name:
+            # Override calls Unload already.
+            manifest.Override(manifest_name)
        else:
-          bare_git.pack_refs()
+            manifest.Unload()
-      pm.end()
-      return
+    def UpdateProjectList(self, opt, manifest):
+        """Update the cached projects list for |manifest|
-    cpu_count = os.cpu_count()
-    config = {'pack.threads': cpu_count // jobs if cpu_count > jobs else 1}
+        In a multi-manifest checkout, each manifest has its own project.list.
-    threads = set()
+        Args:
-    sem = _threading.Semaphore(jobs)
+            opt: Program options returned from optparse.  See _Options().
+            manifest: The manifest to use.
+        Returns:
+            0: success
+            1: failure
+        """
+        new_project_paths = []
+        for project in self.GetProjects(
+            None, missing_ok=True, manifest=manifest, all_manifests=False
+        ):
+            if project.relpath:
+                new_project_paths.append(project.relpath)
+        file_name = "project.list"
+        file_path = os.path.join(manifest.subdir, file_name)
+        old_project_paths = []
+        if os.path.exists(file_path):
+            with open(file_path, "r") as fd:
+                old_project_paths = fd.read().split("\n")
+            # In reversed order, so subfolders are deleted before parent folder.
+            for path in sorted(old_project_paths, reverse=True):
+                if not path:
+                    continue
+                if path not in new_project_paths:
+                    # If the path has already been deleted, we don't need to do
+                    # it.
+                    gitdir = os.path.join(manifest.topdir, path, ".git")
+                    if os.path.exists(gitdir):
+                        project = Project(
+                            manifest=manifest,
+                            name=path,
+                            remote=RemoteSpec("origin"),
+                            gitdir=gitdir,
+                            objdir=gitdir,
+                            use_git_worktrees=os.path.isfile(gitdir),
+                            worktree=os.path.join(manifest.topdir, path),
+                            relpath=path,
+                            revisionExpr="HEAD",
+                            revisionId=None,
+                            groups=None,
+                        )
+                        if not project.DeleteWorktree(
+                            quiet=opt.quiet, force=opt.force_remove_dirty
+                        ):
+                            return 1
+        new_project_paths.sort()
+        with open(file_path, "w") as fd:
+            fd.write("\n".join(new_project_paths))
+            fd.write("\n")
+        return 0
+    def UpdateCopyLinkfileList(self, manifest):
+        """Save all dests of copyfile and linkfile, and update them if needed.
+        Returns:
+            Whether update was successful.
+        """
+        new_paths = {}
+        new_linkfile_paths = []
+        new_copyfile_paths = []
+        for project in self.GetProjects(
+            None, missing_ok=True, manifest=manifest, all_manifests=False
+        ):
+            new_linkfile_paths.extend(x.dest for x in project.linkfiles)
+            new_copyfile_paths.extend(x.dest for x in project.copyfiles)
+        new_paths = {
+            "linkfile": new_linkfile_paths,
+            "copyfile": new_copyfile_paths,
+        }
+        copylinkfile_name = "copy-link-files.json"
+        copylinkfile_path = os.path.join(manifest.subdir, copylinkfile_name)
+        old_copylinkfile_paths = {}
+        if os.path.exists(copylinkfile_path):
+            with open(copylinkfile_path, "rb") as fp:
+                try:
+                    old_copylinkfile_paths = json.load(fp)
+                except Exception:
+                    print(
+                        "error: %s is not a json formatted file."
+                        % copylinkfile_path,
+                        file=sys.stderr,
+                    )
+                    platform_utils.remove(copylinkfile_path)
+                    return False
+            need_remove_files = []
+            need_remove_files.extend(
+                set(old_copylinkfile_paths.get("linkfile", []))
+                - set(new_linkfile_paths)
+            )
+            need_remove_files.extend(
+                set(old_copylinkfile_paths.get("copyfile", []))
+                - set(new_copyfile_paths)
+            )
+            for need_remove_file in need_remove_files:
+                # Try to remove the updated copyfile or linkfile.
+                # So, if the file is not exist, nothing need to do.
+                platform_utils.remove(need_remove_file, missing_ok=True)
+        # Create copy-link-files.json, save dest path of "copyfile" and
+        # "linkfile".
+        with open(copylinkfile_path, "w", encoding="utf-8") as fp:
+            json.dump(new_paths, fp)
+        return True
+    def _SmartSyncSetup(self, opt, smart_sync_manifest_path, manifest):
+        if not manifest.manifest_server:
+            print(
+                "error: cannot smart sync: no manifest server defined in "
+                "manifest",
+                file=sys.stderr,
+            )
+            sys.exit(1)
+        manifest_server = manifest.manifest_server
+        if not opt.quiet:
+            print("Using manifest server %s" % manifest_server)
+        if "@" not in manifest_server:
+            username = None
+            password = None
+            if opt.manifest_server_username and opt.manifest_server_password:
+                username = opt.manifest_server_username
+                password = opt.manifest_server_password
+            else:
+                try:
+                    info = netrc.netrc()
+                except IOError:
+                    # .netrc file does not exist or could not be opened.
+                    pass
+                else:
+                    try:
+                        parse_result = urllib.parse.urlparse(manifest_server)
+                        if parse_result.hostname:
+                            auth = info.authenticators(parse_result.hostname)
+                            if auth:
+                                username, _account, password = auth
+                            else:
+                                print(
+                                    "No credentials found for %s in .netrc"
+                                    % parse_result.hostname,
+                                    file=sys.stderr,
+                                )
+                    except netrc.NetrcParseError as e:
+                        print(
+                            "Error parsing .netrc file: %s" % e, file=sys.stderr
+                        )
+            if username and password:
+                manifest_server = manifest_server.replace(
+                    "://", "://%s:%s@" % (username, password), 1
+                )
+        transport = PersistentTransport(manifest_server)
+        if manifest_server.startswith("persistent-"):
+            manifest_server = manifest_server[len("persistent-") :]
-    def tidy_up(run_gc, bare_git):
-      pm.start(bare_git._project.name)
-      try:
        try:
-          if run_gc:
+            server = xmlrpc.client.Server(manifest_server, transport=transport)
-            bare_git.gc('--auto', config=config)
+            if opt.smart_sync:
-          else:
+                branch = self._GetBranch(manifest.manifestProject)
-            bare_git.pack_refs(config=config)
-        except GitError:
+                if "SYNC_TARGET" in os.environ:
-          err_event.set()
+                    target = os.environ["SYNC_TARGET"]
-        except Exception:
+                    [success, manifest_str] = server.GetApprovedManifest(
-          err_event.set()
+                        branch, target
-          raise
+                    )
-      finally:
+                elif (
-        pm.finish(bare_git._project.name)
+                    "TARGET_PRODUCT" in os.environ
-        sem.release()
+                    and "TARGET_BUILD_VARIANT" in os.environ
+                ):
-    for (run_gc, bare_git) in tidy_dirs.values():
+                    target = "%s-%s" % (
-      if err_event.is_set() and opt.fail_fast:
+                        os.environ["TARGET_PRODUCT"],
-        break
+                        os.environ["TARGET_BUILD_VARIANT"],
-      sem.acquire()
+                    )
-      t = _threading.Thread(target=tidy_up, args=(run_gc, bare_git,))
+                    [success, manifest_str] = server.GetApprovedManifest(
-      t.daemon = True
+                        branch, target
-      threads.add(t)
+                    )
-      t.start()
+                else:
+                    [success, manifest_str] = server.GetApprovedManifest(branch)
-    for t in threads:
+            else:
-      t.join()
+                assert opt.smart_tag
-    pm.end()
+                [success, manifest_str] = server.GetManifest(opt.smart_tag)
-  def _ReloadManifest(self, manifest_name, manifest):
+            if success:
-    """Reload the manfiest from the file specified by the |manifest_name|.
+                manifest_name = os.path.basename(smart_sync_manifest_path)
+                try:
-    It unloads the manifest if |manifest_name| is None.
+                    with open(smart_sync_manifest_path, "w") as f:
+                        f.write(manifest_str)
-    Args:
+                except IOError as e:
-      manifest_name: Manifest file to be reloaded.
+                    print(
-      manifest: The manifest to use.
+                        "error: cannot write manifest to %s:\n%s"
-    """
+                        % (smart_sync_manifest_path, e),
-    if manifest_name:
+                        file=sys.stderr,
-      # Override calls Unload already
+                    )
-      manifest.Override(manifest_name)
+                    sys.exit(1)
-    else:
+                self._ReloadManifest(manifest_name, manifest)
-      manifest.Unload()
+            else:
+                print(
-  def UpdateProjectList(self, opt, manifest):
+                    "error: manifest server RPC call failed: %s" % manifest_str,
-    """Update the cached projects list for |manifest|
+                    file=sys.stderr,
+                )
-    In a multi-manifest checkout, each manifest has its own project.list.
+                sys.exit(1)
+        except (socket.error, IOError, xmlrpc.client.Fault) as e:
+            print(
+                "error: cannot connect to manifest server %s:\n%s"
+                % (manifest.manifest_server, e),
+                file=sys.stderr,
+            )
+            sys.exit(1)
+        except xmlrpc.client.ProtocolError as e:
+            print(
+                "error: cannot connect to manifest server %s:\n%d %s"
+                % (manifest.manifest_server, e.errcode, e.errmsg),
+                file=sys.stderr,
+            )
+            sys.exit(1)
+        return manifest_name
+    def _UpdateAllManifestProjects(self, opt, mp, manifest_name):
+        """Fetch & update the local manifest project.
+        After syncing the manifest project, if the manifest has any sub
+        manifests, those are recursively processed.
+        Args:
+            opt: Program options returned from optparse.  See _Options().
+            mp: the manifestProject to query.
+            manifest_name: Manifest file to be reloaded.
+        """
+        if not mp.standalone_manifest_url:
+            self._UpdateManifestProject(opt, mp, manifest_name)
+        if mp.manifest.submanifests:
+            for submanifest in mp.manifest.submanifests.values():
+                child = submanifest.repo_client.manifest
+                child.manifestProject.SyncWithPossibleInit(
+                    submanifest,
+                    current_branch_only=self._GetCurrentBranchOnly(opt, child),
+                    verbose=opt.verbose,
+                    tags=opt.tags,
+                    git_event_log=self.git_event_log,
+                )
+                self._UpdateAllManifestProjects(
+                    opt, child.manifestProject, None
+                )
+    def _UpdateManifestProject(self, opt, mp, manifest_name):
+        """Fetch & update the local manifest project.
+        Args:
+            opt: Program options returned from optparse.  See _Options().
+            mp: the manifestProject to query.
+            manifest_name: Manifest file to be reloaded.
+        """
+        if not opt.local_only:
+            start = time.time()
+            success = mp.Sync_NetworkHalf(
+                quiet=opt.quiet,
+                verbose=opt.verbose,
+                current_branch_only=self._GetCurrentBranchOnly(
+                    opt, mp.manifest
+                ),
+                force_sync=opt.force_sync,
+                tags=opt.tags,
+                optimized_fetch=opt.optimized_fetch,
+                retry_fetches=opt.retry_fetches,
+                submodules=mp.manifest.HasSubmodules,
+                clone_filter=mp.manifest.CloneFilter,
+                partial_clone_exclude=mp.manifest.PartialCloneExclude,
+            )
+            finish = time.time()
+            self.event_log.AddSync(
+                mp, event_log.TASK_SYNC_NETWORK, start, finish, success
+            )
+        if mp.HasChanges:
+            syncbuf = SyncBuffer(mp.config)
+            start = time.time()
+            mp.Sync_LocalHalf(syncbuf, submodules=mp.manifest.HasSubmodules)
+            clean = syncbuf.Finish()
+            self.event_log.AddSync(
+                mp, event_log.TASK_SYNC_LOCAL, start, time.time(), clean
+            )
+            if not clean:
+                sys.exit(1)
+            self._ReloadManifest(manifest_name, mp.manifest)
+    def ValidateOptions(self, opt, args):
+        if opt.force_broken:
+            print(
+                "warning: -f/--force-broken is now the default behavior, and "
+                "the options are deprecated",
+                file=sys.stderr,
+            )
+        if opt.network_only and opt.detach_head:
+            self.OptionParser.error("cannot combine -n and -d")
+        if opt.network_only and opt.local_only:
+            self.OptionParser.error("cannot combine -n and -l")
+        if opt.manifest_name and opt.smart_sync:
+            self.OptionParser.error("cannot combine -m and -s")
+        if opt.manifest_name and opt.smart_tag:
+            self.OptionParser.error("cannot combine -m and -t")
+        if opt.manifest_server_username or opt.manifest_server_password:
+            if not (opt.smart_sync or opt.smart_tag):
+                self.OptionParser.error(
+                    "-u and -p may only be combined with -s or -t"
+                )
+            if None in [
+                opt.manifest_server_username,
+                opt.manifest_server_password,
+            ]:
+                self.OptionParser.error("both -u and -p must be given")
+        if opt.prune is None:
+            opt.prune = True
+        if opt.auto_gc is None and _AUTO_GC:
+            print(
+                f"Will run `git gc --auto` because {_REPO_AUTO_GC} is set.",
+                f"{_REPO_AUTO_GC} is deprecated and will be removed in a ",
+                "future release.  Use `--auto-gc` instead.",
+                file=sys.stderr,
+            )
+            opt.auto_gc = True
+    def _ValidateOptionsWithManifest(self, opt, mp):
+        """Like ValidateOptions, but after we've updated the manifest.
+        Needed to handle sync-xxx option defaults in the manifest.
+        Args:
+            opt: The options to process.
+            mp: The manifest project to pull defaults from.
+        """
+        if not opt.jobs:
+            # If the user hasn't made a choice, use the manifest value.
+            opt.jobs = mp.manifest.default.sync_j
+        if opt.jobs:
+            # If --jobs has a non-default value, propagate it as the default for
+            # --jobs-xxx flags too.
+            if not opt.jobs_network:
+                opt.jobs_network = opt.jobs
+            if not opt.jobs_checkout:
+                opt.jobs_checkout = opt.jobs
+        else:
+            # Neither user nor manifest have made a choice, so setup defaults.
+            if not opt.jobs_network:
+                opt.jobs_network = 1
+            if not opt.jobs_checkout:
+                opt.jobs_checkout = DEFAULT_LOCAL_JOBS
+            opt.jobs = os.cpu_count()
+        # Try to stay under user rlimit settings.
+        #
+        # Since each worker requires at 3 file descriptors to run `git fetch`,
+        # use that to scale down the number of jobs.  Unfortunately there isn't
+        # an easy way to determine this reliably as systems change, but it was
+        # last measured by hand in 2011.
+        soft_limit, _ = _rlimit_nofile()
+        jobs_soft_limit = max(1, (soft_limit - 5) // 3)
+        opt.jobs = min(opt.jobs, jobs_soft_limit)
+        opt.jobs_network = min(opt.jobs_network, jobs_soft_limit)
+        opt.jobs_checkout = min(opt.jobs_checkout, jobs_soft_limit)
+    def Execute(self, opt, args):
+        manifest = self.outer_manifest
+        if not opt.outer_manifest:
+            manifest = self.manifest
+        if opt.manifest_name:
+            manifest.Override(opt.manifest_name)
+        manifest_name = opt.manifest_name
+        smart_sync_manifest_path = os.path.join(
+            manifest.manifestProject.worktree, "smart_sync_override.xml"
+        )
-    Args:
+        if opt.clone_bundle is None:
-      opt: Program options returned from optparse.  See _Options().
+            opt.clone_bundle = manifest.CloneBundle
-      manifest: The manifest to use.
-    Returns:
+        if opt.smart_sync or opt.smart_tag:
-      0: success
+            manifest_name = self._SmartSyncSetup(
-      1: failure
+                opt, smart_sync_manifest_path, manifest
-    """
+            )
-    new_project_paths = []
-    for project in self.GetProjects(None, missing_ok=True, manifest=manifest,
-                                    all_manifests=False):
-      if project.relpath:
-        new_project_paths.append(project.relpath)
-    file_name = 'project.list'
-    file_path = os.path.join(manifest.subdir, file_name)
-    old_project_paths = []
-    if os.path.exists(file_path):
-      with open(file_path, 'r') as fd:
-        old_project_paths = fd.read().split('\n')
-      # In reversed order, so subfolders are deleted before parent folder.
-      for path in sorted(old_project_paths, reverse=True):
-        if not path:
-          continue
-        if path not in new_project_paths:
-          # If the path has already been deleted, we don't need to do it
-          gitdir = os.path.join(manifest.topdir, path, '.git')
-          if os.path.exists(gitdir):
-            project = Project(
-                manifest=manifest,
-                name=path,
-                remote=RemoteSpec('origin'),
-                gitdir=gitdir,
-                objdir=gitdir,
-                use_git_worktrees=os.path.isfile(gitdir),
-                worktree=os.path.join(manifest.topdir, path),
-                relpath=path,
-                revisionExpr='HEAD',
-                revisionId=None,
-                groups=None)
-            if not project.DeleteWorktree(
-                    quiet=opt.quiet,
-                    force=opt.force_remove_dirty):
-              return 1
-    new_project_paths.sort()
-    with open(file_path, 'w') as fd:
-      fd.write('\n'.join(new_project_paths))
-      fd.write('\n')
-    return 0
-  def UpdateCopyLinkfileList(self, manifest):
-    """Save all dests of copyfile and linkfile, and update them if needed.
-    Returns:
-      Whether update was successful.
-    """
-    new_paths = {}
-    new_linkfile_paths = []
-    new_copyfile_paths = []
-    for project in self.GetProjects(None, missing_ok=True,
-                                    manifest=manifest, all_manifests=False):
-      new_linkfile_paths.extend(x.dest for x in project.linkfiles)
-      new_copyfile_paths.extend(x.dest for x in project.copyfiles)
-    new_paths = {
-        'linkfile': new_linkfile_paths,
-        'copyfile': new_copyfile_paths,
-    }
-    copylinkfile_name = 'copy-link-files.json'
-    copylinkfile_path = os.path.join(manifest.subdir, copylinkfile_name)
-    old_copylinkfile_paths = {}
-    if os.path.exists(copylinkfile_path):
-      with open(copylinkfile_path, 'rb') as fp:
-        try:
-          old_copylinkfile_paths = json.load(fp)
-        except Exception:
-          print('error: %s is not a json formatted file.' %
-                copylinkfile_path, file=sys.stderr)
-          platform_utils.remove(copylinkfile_path)
-          return False
-      need_remove_files = []
-      need_remove_files.extend(
-          set(old_copylinkfile_paths.get('linkfile', [])) -
-          set(new_linkfile_paths))
-      need_remove_files.extend(
-          set(old_copylinkfile_paths.get('copyfile', [])) -
-          set(new_copyfile_paths))
-      for need_remove_file in need_remove_files:
-        # Try to remove the updated copyfile or linkfile.
-        # So, if the file is not exist, nothing need to do.
-        platform_utils.remove(need_remove_file, missing_ok=True)
-    # Create copy-link-files.json, save dest path of "copyfile" and "linkfile".
-    with open(copylinkfile_path, 'w', encoding='utf-8') as fp:
-      json.dump(new_paths, fp)
-    return True
-  def _SmartSyncSetup(self, opt, smart_sync_manifest_path, manifest):
-    if not manifest.manifest_server:
-      print('error: cannot smart sync: no manifest server defined in '
-            'manifest', file=sys.stderr)
-      sys.exit(1)
-    manifest_server = manifest.manifest_server
-    if not opt.quiet:
-      print('Using manifest server %s' % manifest_server)
-    if '@' not in manifest_server:
-      username = None
-      password = None
-      if opt.manifest_server_username and opt.manifest_server_password:
-        username = opt.manifest_server_username
-        password = opt.manifest_server_password
-      else:
-        try:
-          info = netrc.netrc()
-        except IOError:
-          # .netrc file does not exist or could not be opened
-          pass
        else:
-          try:
+            if os.path.isfile(smart_sync_manifest_path):
-            parse_result = urllib.parse.urlparse(manifest_server)
+                try:
-            if parse_result.hostname:
+                    platform_utils.remove(smart_sync_manifest_path)
-              auth = info.authenticators(parse_result.hostname)
+                except OSError as e:
-              if auth:
+                    print(
-                username, _account, password = auth
+                        "error: failed to remove existing smart sync override "
-              else:
+                        "manifest: %s" % e,
-                print('No credentials found for %s in .netrc'
+                        file=sys.stderr,
-                      % parse_result.hostname, file=sys.stderr)
+                    )
-          except netrc.NetrcParseError as e:
-            print('Error parsing .netrc file: %s' % e, file=sys.stderr)
+        err_event = multiprocessing.Event()
-      if (username and password):
+        rp = manifest.repoProject
-        manifest_server = manifest_server.replace('://', '://%s:%s@' %
+        rp.PreSync()
-                                                  (username, password),
+        cb = rp.CurrentBranch
-                                                  1)
+        if cb:
+            base = rp.GetBranch(cb).merge
-    transport = PersistentTransport(manifest_server)
+            if not base or not base.startswith("refs/heads/"):
-    if manifest_server.startswith('persistent-'):
+                print(
-      manifest_server = manifest_server[len('persistent-'):]
+                    "warning: repo is not tracking a remote branch, so it will "
+                    "not receive updates; run `repo init --repo-rev=stable` to "
-    try:
+                    "fix.",
-      server = xmlrpc.client.Server(manifest_server, transport=transport)
+                    file=sys.stderr,
-      if opt.smart_sync:
+                )
-        branch = self._GetBranch(manifest.manifestProject)
+        for m in self.ManifestList(opt):
-        if 'SYNC_TARGET' in os.environ:
+            if not m.manifestProject.standalone_manifest_url:
-          target = os.environ['SYNC_TARGET']
+                m.manifestProject.PreSync()
-          [success, manifest_str] = server.GetApprovedManifest(branch, target)
-        elif ('TARGET_PRODUCT' in os.environ and
+        if opt.repo_upgraded:
-              'TARGET_BUILD_VARIANT' in os.environ):
+            _PostRepoUpgrade(manifest, quiet=opt.quiet)
-          target = '%s-%s' % (os.environ['TARGET_PRODUCT'],
-                              os.environ['TARGET_BUILD_VARIANT'])
+        mp = manifest.manifestProject
-          [success, manifest_str] = server.GetApprovedManifest(branch, target)
+        if opt.mp_update:
+            self._UpdateAllManifestProjects(opt, mp, manifest_name)
        else:
-          [success, manifest_str] = server.GetApprovedManifest(branch)
+            print("Skipping update of local manifest project.")
-      else:
-        assert(opt.smart_tag)
-        [success, manifest_str] = server.GetManifest(opt.smart_tag)
-      if success:
+        # Now that the manifests are up-to-date, setup options whose defaults
-        manifest_name = os.path.basename(smart_sync_manifest_path)
+        # might be in the manifest.
-        try:
+        self._ValidateOptionsWithManifest(opt, mp)
-          with open(smart_sync_manifest_path, 'w') as f:
-            f.write(manifest_str)
+        superproject_logging_data = {}
-        except IOError as e:
+        self._UpdateProjectsRevisionId(
-          print('error: cannot write manifest to %s:\n%s'
+            opt, args, superproject_logging_data, manifest
-                % (smart_sync_manifest_path, e),
-                file=sys.stderr)
-          sys.exit(1)
-        self._ReloadManifest(manifest_name, manifest)
-      else:
-        print('error: manifest server RPC call failed: %s' %
-              manifest_str, file=sys.stderr)
-        sys.exit(1)
-    except (socket.error, IOError, xmlrpc.client.Fault) as e:
-      print('error: cannot connect to manifest server %s:\n%s'
-            % (manifest.manifest_server, e), file=sys.stderr)
-      sys.exit(1)
-    except xmlrpc.client.ProtocolError as e:
-      print('error: cannot connect to manifest server %s:\n%d %s'
-            % (manifest.manifest_server, e.errcode, e.errmsg),
-            file=sys.stderr)
-      sys.exit(1)
-    return manifest_name
-  def _UpdateAllManifestProjects(self, opt, mp, manifest_name):
-    """Fetch & update the local manifest project.
-    After syncing the manifest project, if the manifest has any sub manifests,
-    those are recursively processed.
-    Args:
-      opt: Program options returned from optparse.  See _Options().
-      mp: the manifestProject to query.
-      manifest_name: Manifest file to be reloaded.
-    """
-    if not mp.standalone_manifest_url:
-      self._UpdateManifestProject(opt, mp, manifest_name)
-    if mp.manifest.submanifests:
-      for submanifest in mp.manifest.submanifests.values():
-        child = submanifest.repo_client.manifest
-        child.manifestProject.SyncWithPossibleInit(
-            submanifest,
-            current_branch_only=self._GetCurrentBranchOnly(opt, child),
-            verbose=opt.verbose,
-            tags=opt.tags,
-            git_event_log=self.git_event_log,
        )
-        self._UpdateAllManifestProjects(opt, child.manifestProject, None)
-  def _UpdateManifestProject(self, opt, mp, manifest_name):
+        if self.gitc_manifest:
-    """Fetch & update the local manifest project.
+            gitc_manifest_projects = self.GetProjects(args, missing_ok=True)
+            gitc_projects = []
+            opened_projects = []
+            for project in gitc_manifest_projects:
+                if (
+                    project.relpath in self.gitc_manifest.paths
+                    and self.gitc_manifest.paths[project.relpath].old_revision
+                ):
+                    opened_projects.append(project.relpath)
+                else:
+                    gitc_projects.append(project.relpath)
+            if not args:
+                gitc_projects = None
+            if gitc_projects != [] and not opt.local_only:
+                print(
+                    "Updating GITC client: %s"
+                    % self.gitc_manifest.gitc_client_name
+                )
+                manifest = GitcManifest(
+                    self.repodir, self.gitc_manifest.gitc_client_name
+                )
+                if manifest_name:
+                    manifest.Override(manifest_name)
+                else:
+                    manifest.Override(manifest.manifestFile)
+                gitc_utils.generate_gitc_manifest(
+                    self.gitc_manifest, manifest, gitc_projects
+                )
+                print("GITC client successfully synced.")
+            # The opened projects need to be synced as normal, therefore we
+            # generate a new args list to represent the opened projects.
+            # TODO: make this more reliable -- if there's a project name/path
+            # overlap, this may choose the wrong project.
+            args = [
+                os.path.relpath(manifest.paths[path].worktree, os.getcwd())
+                for path in opened_projects
+            ]
+            if not args:
+                return
+        all_projects = self.GetProjects(
+            args,
+            missing_ok=True,
+            submodules_ok=opt.fetch_submodules,
+            manifest=manifest,
+            all_manifests=not opt.this_manifest_only,
+        )
-    Args:
+        err_network_sync = False
-      opt: Program options returned from optparse.  See _Options().
+        err_update_projects = False
-      mp: the manifestProject to query.
+        err_update_linkfiles = False
-      manifest_name: Manifest file to be reloaded.
-    """
+        self._fetch_times = _FetchTimes(manifest)
-    if not opt.local_only:
+        if not opt.local_only:
-      start = time.time()
+            with multiprocessing.Manager() as manager:
-      success = mp.Sync_NetworkHalf(quiet=opt.quiet, verbose=opt.verbose,
+                with ssh.ProxyManager(manager) as ssh_proxy:
-                                    current_branch_only=self._GetCurrentBranchOnly(opt, mp.manifest),
+                    # Initialize the socket dir once in the parent.
-                                    force_sync=opt.force_sync,
+                    ssh_proxy.sock()
-                                    tags=opt.tags,
+                    result = self._FetchMain(
-                                    optimized_fetch=opt.optimized_fetch,
+                        opt, args, all_projects, err_event, ssh_proxy, manifest
-                                    retry_fetches=opt.retry_fetches,
+                    )
-                                    submodules=mp.manifest.HasSubmodules,
+                    all_projects = result.all_projects
-                                    clone_filter=mp.manifest.CloneFilter,
-                                    partial_clone_exclude=mp.manifest.PartialCloneExclude)
+            if opt.network_only:
-      finish = time.time()
+                return
-      self.event_log.AddSync(mp, event_log.TASK_SYNC_NETWORK,
-                             start, finish, success)
+            # If we saw an error, exit with code 1 so that other scripts can
+            # check.
-    if mp.HasChanges:
+            if err_event.is_set():
-      syncbuf = SyncBuffer(mp.config)
+                err_network_sync = True
-      start = time.time()
+                if opt.fail_fast:
-      mp.Sync_LocalHalf(syncbuf, submodules=mp.manifest.HasSubmodules)
+                    print(
-      clean = syncbuf.Finish()
+                        "\nerror: Exited sync due to fetch errors.\n"
-      self.event_log.AddSync(mp, event_log.TASK_SYNC_LOCAL,
+                        "Local checkouts *not* updated. Resolve network issues "
-                             start, time.time(), clean)
+                        "& retry.\n"
-      if not clean:
+                        "`repo sync -l` will update some local checkouts.",
-        sys.exit(1)
+                        file=sys.stderr,
-      self._ReloadManifest(manifest_name, mp.manifest)
+                    )
+                    sys.exit(1)
-  def ValidateOptions(self, opt, args):
-    if opt.force_broken:
+        for m in self.ManifestList(opt):
-      print('warning: -f/--force-broken is now the default behavior, and the '
+            if m.IsMirror or m.IsArchive:
-            'options are deprecated', file=sys.stderr)
+                # Bail out now, we have no working tree.
-    if opt.network_only and opt.detach_head:
+                continue
-      self.OptionParser.error('cannot combine -n and -d')
-    if opt.network_only and opt.local_only:
+            if self.UpdateProjectList(opt, m):
-      self.OptionParser.error('cannot combine -n and -l')
+                err_event.set()
-    if opt.manifest_name and opt.smart_sync:
+                err_update_projects = True
-      self.OptionParser.error('cannot combine -m and -s')
+                if opt.fail_fast:
-    if opt.manifest_name and opt.smart_tag:
+                    print(
-      self.OptionParser.error('cannot combine -m and -t')
+                        "\nerror: Local checkouts *not* updated.",
-    if opt.manifest_server_username or opt.manifest_server_password:
+                        file=sys.stderr,
-      if not (opt.smart_sync or opt.smart_tag):
+                    )
-        self.OptionParser.error('-u and -p may only be combined with -s or -t')
+                    sys.exit(1)
-      if None in [opt.manifest_server_username, opt.manifest_server_password]:
-        self.OptionParser.error('both -u and -p must be given')
+            err_update_linkfiles = not self.UpdateCopyLinkfileList(m)
+            if err_update_linkfiles:
-    if opt.prune is None:
+                err_event.set()
-      opt.prune = True
+                if opt.fail_fast:
+                    print(
-    if opt.auto_gc is None and _AUTO_GC:
+                        "\nerror: Local update copyfile or linkfile failed.",
-      print(f"Will run `git gc --auto` because {_REPO_AUTO_GC} is set.",
+                        file=sys.stderr,
-            f'{_REPO_AUTO_GC} is deprecated and will be removed in a future',
+                    )
-            'release.  Use `--auto-gc` instead.', file=sys.stderr)
+                    sys.exit(1)
-      opt.auto_gc = True
+        err_results = []
-  def _ValidateOptionsWithManifest(self, opt, mp):
+        # NB: We don't exit here because this is the last step.
-    """Like ValidateOptions, but after we've updated the manifest.
+        err_checkout = not self._Checkout(all_projects, opt, err_results)
+        if err_checkout:
-    Needed to handle sync-xxx option defaults in the manifest.
+            err_event.set()
-    Args:
+        printed_notices = set()
-      opt: The options to process.
+        # If there's a notice that's supposed to print at the end of the sync,
-      mp: The manifest project to pull defaults from.
+        # print it now...  But avoid printing duplicate messages, and preserve
-    """
+        # order.
-    if not opt.jobs:
+        for m in sorted(self.ManifestList(opt), key=lambda x: x.path_prefix):
-      # If the user hasn't made a choice, use the manifest value.
+            if m.notice and m.notice not in printed_notices:
-      opt.jobs = mp.manifest.default.sync_j
+                print(m.notice)
-    if opt.jobs:
+                printed_notices.add(m.notice)
-      # If --jobs has a non-default value, propagate it as the default for
-      # --jobs-xxx flags too.
+        # If we saw an error, exit with code 1 so that other scripts can check.
-      if not opt.jobs_network:
+        if err_event.is_set():
-        opt.jobs_network = opt.jobs
+            print("\nerror: Unable to fully sync the tree.", file=sys.stderr)
-      if not opt.jobs_checkout:
+            if err_network_sync:
-        opt.jobs_checkout = opt.jobs
+                print(
-    else:
+                    "error: Downloading network changes failed.",
-      # Neither user nor manifest have made a choice, so setup defaults.
+                    file=sys.stderr,
-      if not opt.jobs_network:
+                )
-        opt.jobs_network = 1
+            if err_update_projects:
-      if not opt.jobs_checkout:
+                print(
-        opt.jobs_checkout = DEFAULT_LOCAL_JOBS
+                    "error: Updating local project lists failed.",
-      opt.jobs = os.cpu_count()
+                    file=sys.stderr,
+                )
-    # Try to stay under user rlimit settings.
+            if err_update_linkfiles:
-    #
+                print(
-    # Since each worker requires at 3 file descriptors to run `git fetch`, use
+                    "error: Updating copyfiles or linkfiles failed.",
-    # that to scale down the number of jobs.  Unfortunately there isn't an easy
+                    file=sys.stderr,
-    # way to determine this reliably as systems change, but it was last measured
+                )
-    # by hand in 2011.
+            if err_checkout:
-    soft_limit, _ = _rlimit_nofile()
+                print(
-    jobs_soft_limit = max(1, (soft_limit - 5) // 3)
+                    "error: Checking out local projects failed.",
-    opt.jobs = min(opt.jobs, jobs_soft_limit)
+                    file=sys.stderr,
-    opt.jobs_network = min(opt.jobs_network, jobs_soft_limit)
+                )
-    opt.jobs_checkout = min(opt.jobs_checkout, jobs_soft_limit)
+                if err_results:
+                    print(
-  def Execute(self, opt, args):
+                        "Failing repos:\n%s" % "\n".join(err_results),
-    manifest = self.outer_manifest
+                        file=sys.stderr,
-    if not opt.outer_manifest:
+                    )
-      manifest = self.manifest
+            print(
+                'Try re-running with "-j1 --fail-fast" to exit at the first '
-    if opt.manifest_name:
+                "error.",
-      manifest.Override(opt.manifest_name)
+                file=sys.stderr,
+            )
-    manifest_name = opt.manifest_name
+            sys.exit(1)
-    smart_sync_manifest_path = os.path.join(
-        manifest.manifestProject.worktree, 'smart_sync_override.xml')
+        # Log the previous sync analysis state from the config.
+        self.git_event_log.LogDataConfigEvents(
-    if opt.clone_bundle is None:
+            mp.config.GetSyncAnalysisStateData(), "previous_sync_state"
-      opt.clone_bundle = manifest.CloneBundle
+        )
-    if opt.smart_sync or opt.smart_tag:
-      manifest_name = self._SmartSyncSetup(opt, smart_sync_manifest_path, manifest)
-    else:
-      if os.path.isfile(smart_sync_manifest_path):
-        try:
-          platform_utils.remove(smart_sync_manifest_path)
-        except OSError as e:
-          print('error: failed to remove existing smart sync override manifest: %s' %
-                e, file=sys.stderr)
-    err_event = multiprocessing.Event()
-    rp = manifest.repoProject
-    rp.PreSync()
-    cb = rp.CurrentBranch
-    if cb:
-      base = rp.GetBranch(cb).merge
-      if not base or not base.startswith('refs/heads/'):
-        print('warning: repo is not tracking a remote branch, so it will not '
-              'receive updates; run `repo init --repo-rev=stable` to fix.',
-              file=sys.stderr)
-    for m in self.ManifestList(opt):
-      if not m.manifestProject.standalone_manifest_url:
-        m.manifestProject.PreSync()
-    if opt.repo_upgraded:
-      _PostRepoUpgrade(manifest, quiet=opt.quiet)
-    mp = manifest.manifestProject
-    if opt.mp_update:
-      self._UpdateAllManifestProjects(opt, mp, manifest_name)
-    else:
-      print('Skipping update of local manifest project.')
-    # Now that the manifests are up-to-date, setup options whose defaults might
-    # be in the manifest.
-    self._ValidateOptionsWithManifest(opt, mp)
-    superproject_logging_data = {}
-    self._UpdateProjectsRevisionId(opt, args, superproject_logging_data,
-                                   manifest)
-    if self.gitc_manifest:
-      gitc_manifest_projects = self.GetProjects(args, missing_ok=True)
-      gitc_projects = []
-      opened_projects = []
-      for project in gitc_manifest_projects:
-        if project.relpath in self.gitc_manifest.paths and \
-           self.gitc_manifest.paths[project.relpath].old_revision:
-          opened_projects.append(project.relpath)
-        else:
-          gitc_projects.append(project.relpath)
-      if not args:
+        # Update and log with the new sync analysis state.
-        gitc_projects = None
+        mp.config.UpdateSyncAnalysisState(opt, superproject_logging_data)
+        self.git_event_log.LogDataConfigEvents(
+            mp.config.GetSyncAnalysisStateData(), "current_sync_state"
+        )
-      if gitc_projects != [] and not opt.local_only:
+        if not opt.quiet:
-        print('Updating GITC client: %s' % self.gitc_manifest.gitc_client_name)
+            print("repo sync has finished successfully.")
-        manifest = GitcManifest(self.repodir, self.gitc_manifest.gitc_client_name)
-        if manifest_name:
-          manifest.Override(manifest_name)
-        else:
-          manifest.Override(manifest.manifestFile)
-        gitc_utils.generate_gitc_manifest(self.gitc_manifest,
-                                          manifest,
-                                          gitc_projects)
-        print('GITC client successfully synced.')
-      # The opened projects need to be synced as normal, therefore we
-      # generate a new args list to represent the opened projects.
-      # TODO: make this more reliable -- if there's a project name/path overlap,
-      # this may choose the wrong project.
-      args = [os.path.relpath(manifest.paths[path].worktree, os.getcwd())
-              for path in opened_projects]
-      if not args:
-        return
-    all_projects = self.GetProjects(args,
-                                    missing_ok=True,
-                                    submodules_ok=opt.fetch_submodules,
-                                    manifest=manifest,
-                                    all_manifests=not opt.this_manifest_only)
-    err_network_sync = False
-    err_update_projects = False
-    err_update_linkfiles = False
-    self._fetch_times = _FetchTimes(manifest)
-    if not opt.local_only:
-      with multiprocessing.Manager() as manager:
-        with ssh.ProxyManager(manager) as ssh_proxy:
-          # Initialize the socket dir once in the parent.
-          ssh_proxy.sock()
-          result = self._FetchMain(opt, args, all_projects, err_event,
-                                   ssh_proxy, manifest)
-          all_projects = result.all_projects
-      if opt.network_only:
-        return
-      # If we saw an error, exit with code 1 so that other scripts can check.
-      if err_event.is_set():
-        err_network_sync = True
-        if opt.fail_fast:
-          print('\nerror: Exited sync due to fetch errors.\n'
-                'Local checkouts *not* updated. Resolve network issues & '
-                'retry.\n'
-                '`repo sync -l` will update some local checkouts.',
-                file=sys.stderr)
-          sys.exit(1)
-    for m in self.ManifestList(opt):
-      if m.IsMirror or m.IsArchive:
-        # bail out now, we have no working tree
-        continue
-      if self.UpdateProjectList(opt, m):
-        err_event.set()
-        err_update_projects = True
-        if opt.fail_fast:
-          print('\nerror: Local checkouts *not* updated.', file=sys.stderr)
-          sys.exit(1)
-      err_update_linkfiles = not self.UpdateCopyLinkfileList(m)
-      if err_update_linkfiles:
-        err_event.set()
-        if opt.fail_fast:
-          print('\nerror: Local update copyfile or linkfile failed.', file=sys.stderr)
-          sys.exit(1)
-    err_results = []
-    # NB: We don't exit here because this is the last step.
-    err_checkout = not self._Checkout(all_projects, opt, err_results)
-    if err_checkout:
-      err_event.set()
-    printed_notices = set()
-    # If there's a notice that's supposed to print at the end of the sync,
-    # print it now...  But avoid printing duplicate messages, and preserve
-    # order.
-    for m in sorted(self.ManifestList(opt), key=lambda x: x.path_prefix):
-      if m.notice and m.notice not in printed_notices:
-        print(m.notice)
-        printed_notices.add(m.notice)
-    # If we saw an error, exit with code 1 so that other scripts can check.
-    if err_event.is_set():
-      print('\nerror: Unable to fully sync the tree.', file=sys.stderr)
-      if err_network_sync:
-        print('error: Downloading network changes failed.', file=sys.stderr)
-      if err_update_projects:
-        print('error: Updating local project lists failed.', file=sys.stderr)
-      if err_update_linkfiles:
-        print('error: Updating copyfiles or linkfiles failed.', file=sys.stderr)
-      if err_checkout:
-        print('error: Checking out local projects failed.', file=sys.stderr)
-        if err_results:
-          print('Failing repos:\n%s' % '\n'.join(err_results), file=sys.stderr)
-      print('Try re-running with "-j1 --fail-fast" to exit at the first error.',
-            file=sys.stderr)
-      sys.exit(1)
-    # Log the previous sync analysis state from the config.
-    self.git_event_log.LogDataConfigEvents(mp.config.GetSyncAnalysisStateData(),
-                                           'previous_sync_state')
-    # Update and log with the new sync analysis state.
-    mp.config.UpdateSyncAnalysisState(opt, superproject_logging_data)
-    self.git_event_log.LogDataConfigEvents(mp.config.GetSyncAnalysisStateData(),
-                                           'current_sync_state')
-    if not opt.quiet:
-      print('repo sync has finished successfully.')
 def _PostRepoUpgrade(manifest, quiet=False):
-  # Link the docs for the internal .repo/ layout for people
+    # Link the docs for the internal .repo/ layout for people.
-  link = os.path.join(manifest.repodir, 'internal-fs-layout.md')
+    link = os.path.join(manifest.repodir, "internal-fs-layout.md")
-  if not platform_utils.islink(link):
+    if not platform_utils.islink(link):
-    target = os.path.join('repo', 'docs', 'internal-fs-layout.md')
+        target = os.path.join("repo", "docs", "internal-fs-layout.md")
-    try:
+        try:
-      platform_utils.symlink(target, link)
+            platform_utils.symlink(target, link)
-    except Exception:
+        except Exception:
-      pass
+            pass
-  wrapper = Wrapper()
+    wrapper = Wrapper()
-  if wrapper.NeedSetupGnuPG():
+    if wrapper.NeedSetupGnuPG():
-    wrapper.SetupGnuPG(quiet)
+        wrapper.SetupGnuPG(quiet)
-  for project in manifest.projects:
+    for project in manifest.projects:
-    if project.Exists:
+        if project.Exists:
-      project.PostRepoUpgrade()
+            project.PostRepoUpgrade()
 def _PostRepoFetch(rp, repo_verify=True, verbose=False):
-  if rp.HasChanges:
+    if rp.HasChanges:
-    print('info: A new version of repo is available', file=sys.stderr)
+        print("info: A new version of repo is available", file=sys.stderr)
-    wrapper = Wrapper()
+        wrapper = Wrapper()
-    try:
+        try:
-      rev = rp.bare_git.describe(rp.GetRevisionId())
+            rev = rp.bare_git.describe(rp.GetRevisionId())
-    except GitError:
+        except GitError:
-      rev = None
+            rev = None
-    _, new_rev = wrapper.check_repo_rev(rp.gitdir, rev, repo_verify=repo_verify)
+        _, new_rev = wrapper.check_repo_rev(
-    # See if we're held back due to missing signed tag.
+            rp.gitdir, rev, repo_verify=repo_verify
-    current_revid = rp.bare_git.rev_parse('HEAD')
+        )
-    new_revid = rp.bare_git.rev_parse('--verify', new_rev)
+        # See if we're held back due to missing signed tag.
-    if current_revid != new_revid:
+        current_revid = rp.bare_git.rev_parse("HEAD")
-      # We want to switch to the new rev, but also not trash any uncommitted
+        new_revid = rp.bare_git.rev_parse("--verify", new_rev)
-      # changes.  This helps with local testing/hacking.
+        if current_revid != new_revid:
-      # If a local change has been made, we will throw that away.
+            # We want to switch to the new rev, but also not trash any
-      # We also have to make sure this will switch to an older commit if that's
+            # uncommitted changes.  This helps with local testing/hacking.
-      # the latest tag in order to support release rollback.
+            # If a local change has been made, we will throw that away.
-      try:
+            # We also have to make sure this will switch to an older commit if
-        rp.work_git.reset('--keep', new_rev)
+            # that's the latest tag in order to support release rollback.
-      except GitError as e:
+            try:
-        sys.exit(str(e))
+                rp.work_git.reset("--keep", new_rev)
-      print('info: Restarting repo with latest version', file=sys.stderr)
+            except GitError as e:
-      raise RepoChangedException(['--repo-upgraded'])
+                sys.exit(str(e))
+            print("info: Restarting repo with latest version", file=sys.stderr)
+            raise RepoChangedException(["--repo-upgraded"])
+        else:
+            print(
+                "warning: Skipped upgrade to unverified version",
+                file=sys.stderr,
+            )
    else:
-      print('warning: Skipped upgrade to unverified version', file=sys.stderr)
+        if verbose:
-  else:
+            print(
-    if verbose:
+                "repo version %s is current" % rp.work_git.describe(HEAD),
-      print('repo version %s is current' % rp.work_git.describe(HEAD),
+                file=sys.stderr,
-            file=sys.stderr)
+            )
 class _FetchTimes(object):
-  _ALPHA = 0.5
+    _ALPHA = 0.5
-  def __init__(self, manifest):
+    def __init__(self, manifest):
-    self._path = os.path.join(manifest.repodir, '.repo_fetchtimes.json')
+        self._path = os.path.join(manifest.repodir, ".repo_fetchtimes.json")
-    self._times = None
+        self._times = None
-    self._seen = set()
+        self._seen = set()
-  def Get(self, project):
+    def Get(self, project):
-    self._Load()
+        self._Load()
-    return self._times.get(project.name, _ONE_DAY_S)
+        return self._times.get(project.name, _ONE_DAY_S)
-  def Set(self, project, t):
+    def Set(self, project, t):
-    self._Load()
+        self._Load()
-    name = project.name
+        name = project.name
-    old = self._times.get(name, t)
+        old = self._times.get(name, t)
-    self._seen.add(name)
+        self._seen.add(name)
-    a = self._ALPHA
+        a = self._ALPHA
-    self._times[name] = (a * t) + ((1 - a) * old)
+        self._times[name] = (a * t) + ((1 - a) * old)
-  def _Load(self):
+    def _Load(self):
-    if self._times is None:
+        if self._times is None:
-      try:
+            try:
-        with open(self._path) as f:
+                with open(self._path) as f:
-          self._times = json.load(f)
+                    self._times = json.load(f)
-      except (IOError, ValueError):
+            except (IOError, ValueError):
-        platform_utils.remove(self._path, missing_ok=True)
+                platform_utils.remove(self._path, missing_ok=True)
-        self._times = {}
+                self._times = {}
-  def Save(self):
+    def Save(self):
-    if self._times is None:
+        if self._times is None:
-      return
+            return
-    to_delete = []
+        to_delete = []
-    for name in self._times:
+        for name in self._times:
-      if name not in self._seen:
+            if name not in self._seen:
-        to_delete.append(name)
+                to_delete.append(name)
-    for name in to_delete:
+        for name in to_delete:
-      del self._times[name]
+            del self._times[name]
-    try:
+        try:
-      with open(self._path, 'w') as f:
+            with open(self._path, "w") as f:
-        json.dump(self._times, f, indent=2)
+                json.dump(self._times, f, indent=2)
-    except (IOError, TypeError):
+        except (IOError, TypeError):
-      platform_utils.remove(self._path, missing_ok=True)
+            platform_utils.remove(self._path, missing_ok=True)
 # This is a replacement for xmlrpc.client.Transport using urllib2
 # and supporting persistent-http[s]. It cannot change hosts from
@@ -1525,98 +1848,105 @@ class _FetchTimes(object):
 class PersistentTransport(xmlrpc.client.Transport):
-  def __init__(self, orig_host):
+    def __init__(self, orig_host):
-    self.orig_host = orig_host
+        self.orig_host = orig_host
-  def request(self, host, handler, request_body, verbose=False):
+    def request(self, host, handler, request_body, verbose=False):
-    with GetUrlCookieFile(self.orig_host, not verbose) as (cookiefile, proxy):
+        with GetUrlCookieFile(self.orig_host, not verbose) as (
-      # Python doesn't understand cookies with the #HttpOnly_ prefix
+            cookiefile,
-      # Since we're only using them for HTTP, copy the file temporarily,
+            proxy,
-      # stripping those prefixes away.
+        ):
-      if cookiefile:
+            # Python doesn't understand cookies with the #HttpOnly_ prefix
-        tmpcookiefile = tempfile.NamedTemporaryFile(mode='w')
+            # Since we're only using them for HTTP, copy the file temporarily,
-        tmpcookiefile.write("# HTTP Cookie File")
+            # stripping those prefixes away.
-        try:
+            if cookiefile:
-          with open(cookiefile) as f:
+                tmpcookiefile = tempfile.NamedTemporaryFile(mode="w")
-            for line in f:
+                tmpcookiefile.write("# HTTP Cookie File")
-              if line.startswith("#HttpOnly_"):
+                try:
-                line = line[len("#HttpOnly_"):]
+                    with open(cookiefile) as f:
-              tmpcookiefile.write(line)
+                        for line in f:
-          tmpcookiefile.flush()
+                            if line.startswith("#HttpOnly_"):
+                                line = line[len("#HttpOnly_") :]
-          cookiejar = cookielib.MozillaCookieJar(tmpcookiefile.name)
+                            tmpcookiefile.write(line)
-          try:
+                    tmpcookiefile.flush()
-            cookiejar.load()
-          except cookielib.LoadError:
+                    cookiejar = cookielib.MozillaCookieJar(tmpcookiefile.name)
-            cookiejar = cookielib.CookieJar()
+                    try:
-        finally:
+                        cookiejar.load()
-          tmpcookiefile.close()
+                    except cookielib.LoadError:
-      else:
+                        cookiejar = cookielib.CookieJar()
-        cookiejar = cookielib.CookieJar()
+                finally:
+                    tmpcookiefile.close()
-      proxyhandler = urllib.request.ProxyHandler
+            else:
-      if proxy:
+                cookiejar = cookielib.CookieJar()
-        proxyhandler = urllib.request.ProxyHandler({
-            "http": proxy,
+            proxyhandler = urllib.request.ProxyHandler
-            "https": proxy})
+            if proxy:
+                proxyhandler = urllib.request.ProxyHandler(
-      opener = urllib.request.build_opener(
+                    {"http": proxy, "https": proxy}
-          urllib.request.HTTPCookieProcessor(cookiejar),
+                )
-          proxyhandler)
+            opener = urllib.request.build_opener(
-      url = urllib.parse.urljoin(self.orig_host, handler)
+                urllib.request.HTTPCookieProcessor(cookiejar), proxyhandler
-      parse_results = urllib.parse.urlparse(url)
+            )
-      scheme = parse_results.scheme
+            url = urllib.parse.urljoin(self.orig_host, handler)
-      if scheme == 'persistent-http':
+            parse_results = urllib.parse.urlparse(url)
-        scheme = 'http'
-      if scheme == 'persistent-https':
+            scheme = parse_results.scheme
-        # If we're proxying through persistent-https, use http. The
+            if scheme == "persistent-http":
-        # proxy itself will do the https.
+                scheme = "http"
-        if proxy:
+            if scheme == "persistent-https":
-          scheme = 'http'
+                # If we're proxying through persistent-https, use http. The
-        else:
+                # proxy itself will do the https.
-          scheme = 'https'
+                if proxy:
+                    scheme = "http"
-      # Parse out any authentication information using the base class
+                else:
-      host, extra_headers, _ = self.get_host_info(parse_results.netloc)
+                    scheme = "https"
-      url = urllib.parse.urlunparse((
+            # Parse out any authentication information using the base class.
-          scheme,
+            host, extra_headers, _ = self.get_host_info(parse_results.netloc)
-          host,
-          parse_results.path,
+            url = urllib.parse.urlunparse(
-          parse_results.params,
+                (
-          parse_results.query,
+                    scheme,
-          parse_results.fragment))
+                    host,
+                    parse_results.path,
-      request = urllib.request.Request(url, request_body)
+                    parse_results.params,
-      if extra_headers is not None:
+                    parse_results.query,
-        for (name, header) in extra_headers:
+                    parse_results.fragment,
-          request.add_header(name, header)
+                )
-      request.add_header('Content-Type', 'text/xml')
+            )
-      try:
-        response = opener.open(request)
+            request = urllib.request.Request(url, request_body)
-      except urllib.error.HTTPError as e:
+            if extra_headers is not None:
-        if e.code == 501:
+                for name, header in extra_headers:
-          # We may have been redirected through a login process
+                    request.add_header(name, header)
-          # but our POST turned into a GET. Retry.
+            request.add_header("Content-Type", "text/xml")
-          response = opener.open(request)
+            try:
-        else:
+                response = opener.open(request)
-          raise
+            except urllib.error.HTTPError as e:
+                if e.code == 501:
-      p, u = xmlrpc.client.getparser()
+                    # We may have been redirected through a login process
-      # Response should be fairly small, so read it all at once.
+                    # but our POST turned into a GET. Retry.
-      # This way we can show it to the user in case of error (e.g. HTML).
+                    response = opener.open(request)
-      data = response.read()
+                else:
-      try:
+                    raise
-        p.feed(data)
-      except xml.parsers.expat.ExpatError as e:
+            p, u = xmlrpc.client.getparser()
-        raise IOError(
+            # Response should be fairly small, so read it all at once.
-            f'Parsing the manifest failed: {e}\n'
+            # This way we can show it to the user in case of error (e.g. HTML).
-            f'Please report this to your manifest server admin.\n'
+            data = response.read()
-            f'Here is the full response:\n{data.decode("utf-8")}')
+            try:
-      p.close()
+                p.feed(data)
-      return u.close()
+            except xml.parsers.expat.ExpatError as e:
+                raise IOError(
-  def close(self):
+                    f"Parsing the manifest failed: {e}\n"
-    pass
+                    f"Please report this to your manifest server admin.\n"
+                    f'Here is the full response:\n{data.decode("utf-8")}'
+                )
+            p.close()
+            return u.close()
+    def close(self):
+        pass
diff --git a/subcmds/upload.py b/subcmds/upload.py
index 9c279230..63216afb 100644
--- a/subcmds/upload.py
+++ b/subcmds/upload.py
@@ -32,69 +32,77 @@ _DEFAULT_UNUSUAL_COMMIT_THRESHOLD = 5
 def _VerifyPendingCommits(branches: List[ReviewableBranch]) -> bool:
-  """Perform basic safety checks on the given set of branches.
+    """Perform basic safety checks on the given set of branches.
-  Ensures that each branch does not have a "large" number of commits
+    Ensures that each branch does not have a "large" number of commits
-  and, if so, prompts the user to confirm they want to proceed with
+    and, if so, prompts the user to confirm they want to proceed with
-  the upload.
+    the upload.
-  Returns true if all branches pass the safety check or the user
+    Returns true if all branches pass the safety check or the user
-  confirmed. Returns false if the upload should be aborted.
+    confirmed. Returns false if the upload should be aborted.
-  """
+    """
-  # Determine if any branch has a suspicious number of commits.
+    # Determine if any branch has a suspicious number of commits.
-  many_commits = False
+    many_commits = False
-  for branch in branches:
+    for branch in branches:
-    # Get the user's unusual threshold for the branch.
+        # Get the user's unusual threshold for the branch.
-    #
+        #
-    # Each branch may be configured to have a different threshold.
+        # Each branch may be configured to have a different threshold.
-    remote = branch.project.GetBranch(branch.name).remote
+        remote = branch.project.GetBranch(branch.name).remote
-    key = f'review.{remote.review}.uploadwarningthreshold'
+        key = f"review.{remote.review}.uploadwarningthreshold"
-    threshold = branch.project.config.GetInt(key)
+        threshold = branch.project.config.GetInt(key)
-    if threshold is None:
+        if threshold is None:
-      threshold = _DEFAULT_UNUSUAL_COMMIT_THRESHOLD
+            threshold = _DEFAULT_UNUSUAL_COMMIT_THRESHOLD
-    # If the branch has more commits than the threshold, show a warning.
+        # If the branch has more commits than the threshold, show a warning.
-    if len(branch.commits) > threshold:
+        if len(branch.commits) > threshold:
-      many_commits = True
+            many_commits = True
-      break
+            break
-  # If any branch has many commits, prompt the user.
+    # If any branch has many commits, prompt the user.
-  if many_commits:
+    if many_commits:
-    if len(branches) > 1:
+        if len(branches) > 1:
-      print('ATTENTION: One or more branches has an unusually high number '
+            print(
-            'of commits.')
+                "ATTENTION: One or more branches has an unusually high number "
-    else:
+                "of commits."
-      print('ATTENTION: You are uploading an unusually high number of commits.')
+            )
-    print('YOU PROBABLY DO NOT MEAN TO DO THIS. (Did you rebase across '
+        else:
-          'branches?)')
+            print(
-    answer = input(
+                "ATTENTION: You are uploading an unusually high number of "
-        "If you are sure you intend to do this, type 'yes': ").strip()
+                "commits."
-    return answer == 'yes'
+            )
+        print(
-  return True
+            "YOU PROBABLY DO NOT MEAN TO DO THIS. (Did you rebase across "
+            "branches?)"
+        )
+        answer = input(
+            "If you are sure you intend to do this, type 'yes': "
+        ).strip()
+        return answer == "yes"
+    return True
 def _die(fmt, *args):
-  msg = fmt % args
+    msg = fmt % args
-  print('error: %s' % msg, file=sys.stderr)
+    print("error: %s" % msg, file=sys.stderr)
-  sys.exit(1)
+    sys.exit(1)
 def _SplitEmails(values):
-  result = []
+    result = []
-  for value in values:
+    for value in values:
-    result.extend([s.strip() for s in value.split(',')])
+        result.extend([s.strip() for s in value.split(",")])
-  return result
+    return result
 class Upload(InteractiveCommand):
-  COMMON = True
+    COMMON = True
-  helpSummary = "Upload changes for code review"
+    helpSummary = "Upload changes for code review"
-  helpUsage = """
+    helpUsage = """
 %prog [--re --cc] [<project>]...
 """
-  helpDescription = """
+    helpDescription = """
 The '%prog' command is used to send changes to the Gerrit Code
 Review system.  It searches for topic branches in local projects
 that have not yet been published for review.  If multiple topic
@@ -195,443 +203,611 @@ threshold to a different value.
 Gerrit Code Review:  https://www.gerritcodereview.com/
 """
-  PARALLEL_JOBS = DEFAULT_LOCAL_JOBS
+    PARALLEL_JOBS = DEFAULT_LOCAL_JOBS
-  def _Options(self, p):
+    def _Options(self, p):
-    p.add_option('-t',
+        p.add_option(
-                 dest='auto_topic', action='store_true',
+            "-t",
-                 help='send local branch name to Gerrit Code Review')
+            dest="auto_topic",
-    p.add_option('--hashtag', '--ht',
+            action="store_true",
-                 dest='hashtags', action='append', default=[],
+            help="send local branch name to Gerrit Code Review",
-                 help='add hashtags (comma delimited) to the review')
+        )
-    p.add_option('--hashtag-branch', '--htb',
+        p.add_option(
-                 action='store_true',
+            "--hashtag",
-                 help='add local branch name as a hashtag')
+            "--ht",
-    p.add_option('-l', '--label',
+            dest="hashtags",
-                 dest='labels', action='append', default=[],
+            action="append",
-                 help='add a label when uploading')
+            default=[],
-    p.add_option('--re', '--reviewers',
+            help="add hashtags (comma delimited) to the review",
-                 type='string', action='append', dest='reviewers',
+        )
-                 help='request reviews from these people')
+        p.add_option(
-    p.add_option('--cc',
+            "--hashtag-branch",
-                 type='string', action='append', dest='cc',
+            "--htb",
-                 help='also send email to these email addresses')
+            action="store_true",
-    p.add_option('--br', '--branch',
+            help="add local branch name as a hashtag",
-                 type='string', action='store', dest='branch',
+        )
-                 help='(local) branch to upload')
+        p.add_option(
-    p.add_option('-c', '--current-branch',
+            "-l",
-                 dest='current_branch', action='store_true',
+            "--label",
-                 help='upload current git branch')
+            dest="labels",
-    p.add_option('--no-current-branch',
+            action="append",
-                 dest='current_branch', action='store_false',
+            default=[],
-                 help='upload all git branches')
+            help="add a label when uploading",
-    # Turn this into a warning & remove this someday.
+        )
-    p.add_option('--cbr',
+        p.add_option(
-                 dest='current_branch', action='store_true',
+            "--re",
-                 help=optparse.SUPPRESS_HELP)
+            "--reviewers",
-    p.add_option('--ne', '--no-emails',
+            type="string",
-                 action='store_false', dest='notify', default=True,
+            action="append",
-                 help='do not send e-mails on upload')
+            dest="reviewers",
-    p.add_option('-p', '--private',
+            help="request reviews from these people",
-                 action='store_true', dest='private', default=False,
+        )
-                 help='upload as a private change (deprecated; use --wip)')
+        p.add_option(
-    p.add_option('-w', '--wip',
+            "--cc",
-                 action='store_true', dest='wip', default=False,
+            type="string",
-                 help='upload as a work-in-progress change')
+            action="append",
-    p.add_option('-r', '--ready',
+            dest="cc",
-                 action='store_true', default=False,
+            help="also send email to these email addresses",
-                 help='mark change as ready (clears work-in-progress setting)')
+        )
-    p.add_option('-o', '--push-option',
+        p.add_option(
-                 type='string', action='append', dest='push_options',
+            "--br",
-                 default=[],
+            "--branch",
-                 help='additional push options to transmit')
+            type="string",
-    p.add_option('-D', '--destination', '--dest',
+            action="store",
-                 type='string', action='store', dest='dest_branch',
+            dest="branch",
-                 metavar='BRANCH',
+            help="(local) branch to upload",
-                 help='submit for review on this target branch')
+        )
-    p.add_option('-n', '--dry-run',
+        p.add_option(
-                 dest='dryrun', default=False, action='store_true',
+            "-c",
-                 help='do everything except actually upload the CL')
+            "--current-branch",
-    p.add_option('-y', '--yes',
+            dest="current_branch",
-                 default=False, action='store_true',
+            action="store_true",
-                 help='answer yes to all safe prompts')
+            help="upload current git branch",
-    p.add_option('--ignore-untracked-files',
+        )
-                 action='store_true', default=False,
+        p.add_option(
-                 help='ignore untracked files in the working copy')
+            "--no-current-branch",
-    p.add_option('--no-ignore-untracked-files',
+            dest="current_branch",
-                 dest='ignore_untracked_files', action='store_false',
+            action="store_false",
-                 help='always ask about untracked files in the working copy')
+            help="upload all git branches",
-    p.add_option('--no-cert-checks',
+        )
-                 dest='validate_certs', action='store_false', default=True,
+        # Turn this into a warning & remove this someday.
-                 help='disable verifying ssl certs (unsafe)')
+        p.add_option(
-    RepoHook.AddOptionGroup(p, 'pre-upload')
+            "--cbr",
+            dest="current_branch",
-  def _SingleBranch(self, opt, branch, people):
+            action="store_true",
-    project = branch.project
+            help=optparse.SUPPRESS_HELP,
-    name = branch.name
+        )
-    remote = project.GetBranch(name).remote
+        p.add_option(
+            "--ne",
-    key = 'review.%s.autoupload' % remote.review
+            "--no-emails",
-    answer = project.config.GetBoolean(key)
+            action="store_false",
+            dest="notify",
-    if answer is False:
+            default=True,
-      _die("upload blocked by %s = false" % key)
+            help="do not send e-mails on upload",
+        )
-    if answer is None:
+        p.add_option(
-      date = branch.date
+            "-p",
-      commit_list = branch.commits
+            "--private",
+            action="store_true",
-      destination = opt.dest_branch or project.dest_branch or project.revisionExpr
+            dest="private",
-      print('Upload project %s/ to remote branch %s%s:' %
+            default=False,
-            (project.RelPath(local=opt.this_manifest_only), destination,
+            help="upload as a private change (deprecated; use --wip)",
-             ' (private)' if opt.private else ''))
+        )
-      print('  branch %s (%2d commit%s, %s):' % (
+        p.add_option(
-          name,
+            "-w",
-          len(commit_list),
+            "--wip",
-          len(commit_list) != 1 and 's' or '',
+            action="store_true",
-          date))
+            dest="wip",
-      for commit in commit_list:
+            default=False,
-        print('         %s' % commit)
+            help="upload as a work-in-progress change",
+        )
-      print('to %s (y/N)? ' % remote.review, end='', flush=True)
+        p.add_option(
-      if opt.yes:
+            "-r",
-        print('<--yes>')
+            "--ready",
-        answer = True
+            action="store_true",
-      else:
+            default=False,
-        answer = sys.stdin.readline().strip().lower()
+            help="mark change as ready (clears work-in-progress setting)",
-        answer = answer in ('y', 'yes', '1', 'true', 't')
+        )
-      if not answer:
+        p.add_option(
-        _die("upload aborted by user")
+            "-o",
+            "--push-option",
-    # Perform some basic safety checks prior to uploading.
+            type="string",
-    if not opt.yes and not _VerifyPendingCommits([branch]):
+            action="append",
-      _die("upload aborted by user")
+            dest="push_options",
+            default=[],
-    self._UploadAndReport(opt, [branch], people)
+            help="additional push options to transmit",
+        )
-  def _MultipleBranches(self, opt, pending, people):
+        p.add_option(
-    projects = {}
+            "-D",
-    branches = {}
+            "--destination",
+            "--dest",
-    script = []
+            type="string",
-    script.append('# Uncomment the branches to upload:')
+            action="store",
-    for project, avail in pending:
+            dest="dest_branch",
-      project_path = project.RelPath(local=opt.this_manifest_only)
+            metavar="BRANCH",
-      script.append('#')
+            help="submit for review on this target branch",
-      script.append(f'# project {project_path}/:')
+        )
+        p.add_option(
-      b = {}
+            "-n",
-      for branch in avail:
+            "--dry-run",
-        if branch is None:
+            dest="dryrun",
-          continue
+            default=False,
+            action="store_true",
+            help="do everything except actually upload the CL",
+        )
+        p.add_option(
+            "-y",
+            "--yes",
+            default=False,
+            action="store_true",
+            help="answer yes to all safe prompts",
+        )
+        p.add_option(
+            "--ignore-untracked-files",
+            action="store_true",
+            default=False,
+            help="ignore untracked files in the working copy",
+        )
+        p.add_option(
+            "--no-ignore-untracked-files",
+            dest="ignore_untracked_files",
+            action="store_false",
+            help="always ask about untracked files in the working copy",
+        )
+        p.add_option(
+            "--no-cert-checks",
+            dest="validate_certs",
+            action="store_false",
+            default=True,
+            help="disable verifying ssl certs (unsafe)",
+        )
+        RepoHook.AddOptionGroup(p, "pre-upload")
+    def _SingleBranch(self, opt, branch, people):
+        project = branch.project
        name = branch.name
-        date = branch.date
+        remote = project.GetBranch(name).remote
-        commit_list = branch.commits
+        key = "review.%s.autoupload" % remote.review
-        if b:
+        answer = project.config.GetBoolean(key)
-          script.append('#')
-        destination = opt.dest_branch or project.dest_branch or project.revisionExpr
+        if answer is False:
-        script.append('#  branch %s (%2d commit%s, %s) to remote branch %s:' % (
+            _die("upload blocked by %s = false" % key)
-                      name,
-                      len(commit_list),
+        if answer is None:
-                      len(commit_list) != 1 and 's' or '',
+            date = branch.date
-                      date,
+            commit_list = branch.commits
-                      destination))
-        for commit in commit_list:
+            destination = (
-          script.append('#         %s' % commit)
+                opt.dest_branch or project.dest_branch or project.revisionExpr
-        b[name] = branch
+            )
+            print(
-      projects[project_path] = project
+                "Upload project %s/ to remote branch %s%s:"
-      branches[project_path] = b
+                % (
-    script.append('')
+                    project.RelPath(local=opt.this_manifest_only),
+                    destination,
-    script = Editor.EditString("\n".join(script)).split("\n")
+                    " (private)" if opt.private else "",
+                )
-    project_re = re.compile(r'^#?\s*project\s*([^\s]+)/:$')
+            )
-    branch_re = re.compile(r'^\s*branch\s*([^\s(]+)\s*\(.*')
+            print(
+                "  branch %s (%2d commit%s, %s):"
-    project = None
+                % (
-    todo = []
+                    name,
+                    len(commit_list),
-    for line in script:
+                    len(commit_list) != 1 and "s" or "",
-      m = project_re.match(line)
+                    date,
-      if m:
+                )
-        name = m.group(1)
+            )
-        project = projects.get(name)
+            for commit in commit_list:
-        if not project:
+                print("         %s" % commit)
-          _die('project %s not available for upload', name)
-        continue
+            print("to %s (y/N)? " % remote.review, end="", flush=True)
-      m = branch_re.match(line)
-      if m:
-        name = m.group(1)
-        if not project:
-          _die('project for branch %s not in script', name)
-        project_path = project.RelPath(local=opt.this_manifest_only)
-        branch = branches[project_path].get(name)
-        if not branch:
-          _die('branch %s not in %s', name, project_path)
-        todo.append(branch)
-    if not todo:
-      _die("nothing uncommented for upload")
-    # Perform some basic safety checks prior to uploading.
-    if not opt.yes and not _VerifyPendingCommits(todo):
-      _die("upload aborted by user")
-    self._UploadAndReport(opt, todo, people)
-  def _AppendAutoList(self, branch, people):
-    """
-    Appends the list of reviewers in the git project's config.
-    Appends the list of users in the CC list in the git project's config if a
-    non-empty reviewer list was found.
-    """
-    name = branch.name
-    project = branch.project
-    key = 'review.%s.autoreviewer' % project.GetBranch(name).remote.review
-    raw_list = project.config.GetString(key)
-    if raw_list is not None:
-      people[0].extend([entry.strip() for entry in raw_list.split(',')])
-    key = 'review.%s.autocopy' % project.GetBranch(name).remote.review
-    raw_list = project.config.GetString(key)
-    if raw_list is not None and len(people[0]) > 0:
-      people[1].extend([entry.strip() for entry in raw_list.split(',')])
-  def _FindGerritChange(self, branch):
-    last_pub = branch.project.WasPublished(branch.name)
-    if last_pub is None:
-      return ""
-    refs = branch.GetPublishedRefs()
-    try:
-      # refs/changes/XYZ/N --> XYZ
-      return refs.get(last_pub).split('/')[-2]
-    except (AttributeError, IndexError):
-      return ""
-  def _UploadAndReport(self, opt, todo, original_people):
-    have_errors = False
-    for branch in todo:
-      try:
-        people = copy.deepcopy(original_people)
-        self._AppendAutoList(branch, people)
-        # Check if there are local changes that may have been forgotten
-        changes = branch.project.UncommitedFiles()
-        if opt.ignore_untracked_files:
-          untracked = set(branch.project.UntrackedFiles())
-          changes = [x for x in changes if x not in untracked]
-        if changes:
-          key = 'review.%s.autoupload' % branch.project.remote.review
-          answer = branch.project.config.GetBoolean(key)
-          # if they want to auto upload, let's not ask because it could be automated
-          if answer is None:
-            print()
-            print('Uncommitted changes in %s (did you forget to amend?):'
-                  % branch.project.name)
-            print('\n'.join(changes))
-            print('Continue uploading? (y/N) ', end='', flush=True)
            if opt.yes:
-              print('<--yes>')
+                print("<--yes>")
-              a = 'yes'
+                answer = True
+            else:
+                answer = sys.stdin.readline().strip().lower()
+                answer = answer in ("y", "yes", "1", "true", "t")
+            if not answer:
+                _die("upload aborted by user")
+        # Perform some basic safety checks prior to uploading.
+        if not opt.yes and not _VerifyPendingCommits([branch]):
+            _die("upload aborted by user")
+        self._UploadAndReport(opt, [branch], people)
+    def _MultipleBranches(self, opt, pending, people):
+        projects = {}
+        branches = {}
+        script = []
+        script.append("# Uncomment the branches to upload:")
+        for project, avail in pending:
+            project_path = project.RelPath(local=opt.this_manifest_only)
+            script.append("#")
+            script.append(f"# project {project_path}/:")
+            b = {}
+            for branch in avail:
+                if branch is None:
+                    continue
+                name = branch.name
+                date = branch.date
+                commit_list = branch.commits
+                if b:
+                    script.append("#")
+                destination = (
+                    opt.dest_branch
+                    or project.dest_branch
+                    or project.revisionExpr
+                )
+                script.append(
+                    "#  branch %s (%2d commit%s, %s) to remote branch %s:"
+                    % (
+                        name,
+                        len(commit_list),
+                        len(commit_list) != 1 and "s" or "",
+                        date,
+                        destination,
+                    )
+                )
+                for commit in commit_list:
+                    script.append("#         %s" % commit)
+                b[name] = branch
+            projects[project_path] = project
+            branches[project_path] = b
+        script.append("")
+        script = Editor.EditString("\n".join(script)).split("\n")
+        project_re = re.compile(r"^#?\s*project\s*([^\s]+)/:$")
+        branch_re = re.compile(r"^\s*branch\s*([^\s(]+)\s*\(.*")
+        project = None
+        todo = []
+        for line in script:
+            m = project_re.match(line)
+            if m:
+                name = m.group(1)
+                project = projects.get(name)
+                if not project:
+                    _die("project %s not available for upload", name)
+                continue
+            m = branch_re.match(line)
+            if m:
+                name = m.group(1)
+                if not project:
+                    _die("project for branch %s not in script", name)
+                project_path = project.RelPath(local=opt.this_manifest_only)
+                branch = branches[project_path].get(name)
+                if not branch:
+                    _die("branch %s not in %s", name, project_path)
+                todo.append(branch)
+        if not todo:
+            _die("nothing uncommented for upload")
+        # Perform some basic safety checks prior to uploading.
+        if not opt.yes and not _VerifyPendingCommits(todo):
+            _die("upload aborted by user")
+        self._UploadAndReport(opt, todo, people)
+    def _AppendAutoList(self, branch, people):
+        """
+        Appends the list of reviewers in the git project's config.
+        Appends the list of users in the CC list in the git project's config if
+        a non-empty reviewer list was found.
+        """
+        name = branch.name
+        project = branch.project
+        key = "review.%s.autoreviewer" % project.GetBranch(name).remote.review
+        raw_list = project.config.GetString(key)
+        if raw_list is not None:
+            people[0].extend([entry.strip() for entry in raw_list.split(",")])
+        key = "review.%s.autocopy" % project.GetBranch(name).remote.review
+        raw_list = project.config.GetString(key)
+        if raw_list is not None and len(people[0]) > 0:
+            people[1].extend([entry.strip() for entry in raw_list.split(",")])
+    def _FindGerritChange(self, branch):
+        last_pub = branch.project.WasPublished(branch.name)
+        if last_pub is None:
+            return ""
+        refs = branch.GetPublishedRefs()
+        try:
+            # refs/changes/XYZ/N --> XYZ
+            return refs.get(last_pub).split("/")[-2]
+        except (AttributeError, IndexError):
+            return ""
+    def _UploadAndReport(self, opt, todo, original_people):
+        have_errors = False
+        for branch in todo:
+            try:
+                people = copy.deepcopy(original_people)
+                self._AppendAutoList(branch, people)
+                # Check if there are local changes that may have been forgotten.
+                changes = branch.project.UncommitedFiles()
+                if opt.ignore_untracked_files:
+                    untracked = set(branch.project.UntrackedFiles())
+                    changes = [x for x in changes if x not in untracked]
+                if changes:
+                    key = "review.%s.autoupload" % branch.project.remote.review
+                    answer = branch.project.config.GetBoolean(key)
+                    # If they want to auto upload, let's not ask because it
+                    # could be automated.
+                    if answer is None:
+                        print()
+                        print(
+                            "Uncommitted changes in %s (did you forget to "
+                            "amend?):" % branch.project.name
+                        )
+                        print("\n".join(changes))
+                        print("Continue uploading? (y/N) ", end="", flush=True)
+                        if opt.yes:
+                            print("<--yes>")
+                            a = "yes"
+                        else:
+                            a = sys.stdin.readline().strip().lower()
+                        if a not in ("y", "yes", "t", "true", "on"):
+                            print("skipping upload", file=sys.stderr)
+                            branch.uploaded = False
+                            branch.error = "User aborted"
+                            continue
+                # Check if topic branches should be sent to the server during
+                # upload.
+                if opt.auto_topic is not True:
+                    key = "review.%s.uploadtopic" % branch.project.remote.review
+                    opt.auto_topic = branch.project.config.GetBoolean(key)
+                def _ExpandCommaList(value):
+                    """Split |value| up into comma delimited entries."""
+                    if not value:
+                        return
+                    for ret in value.split(","):
+                        ret = ret.strip()
+                        if ret:
+                            yield ret
+                # Check if hashtags should be included.
+                key = "review.%s.uploadhashtags" % branch.project.remote.review
+                hashtags = set(
+                    _ExpandCommaList(branch.project.config.GetString(key))
+                )
+                for tag in opt.hashtags:
+                    hashtags.update(_ExpandCommaList(tag))
+                if opt.hashtag_branch:
+                    hashtags.add(branch.name)
+                # Check if labels should be included.
+                key = "review.%s.uploadlabels" % branch.project.remote.review
+                labels = set(
+                    _ExpandCommaList(branch.project.config.GetString(key))
+                )
+                for label in opt.labels:
+                    labels.update(_ExpandCommaList(label))
+                # Handle e-mail notifications.
+                if opt.notify is False:
+                    notify = "NONE"
+                else:
+                    key = (
+                        "review.%s.uploadnotify" % branch.project.remote.review
+                    )
+                    notify = branch.project.config.GetString(key)
+                destination = opt.dest_branch or branch.project.dest_branch
+                if branch.project.dest_branch and not opt.dest_branch:
+                    merge_branch = self._GetMergeBranch(
+                        branch.project, local_branch=branch.name
+                    )
+                    full_dest = destination
+                    if not full_dest.startswith(R_HEADS):
+                        full_dest = R_HEADS + full_dest
+                    # If the merge branch of the local branch is different from
+                    # the project's revision AND destination, this might not be
+                    # intentional.
+                    if (
+                        merge_branch
+                        and merge_branch != branch.project.revisionExpr
+                        and merge_branch != full_dest
+                    ):
+                        print(
+                            f"For local branch {branch.name}: merge branch "
+                            f"{merge_branch} does not match destination branch "
+                            f"{destination}"
+                        )
+                        print("skipping upload.")
+                        print(
+                            f"Please use `--destination {destination}` if this "
+                            "is intentional"
+                        )
+                        branch.uploaded = False
+                        continue
+                branch.UploadForReview(
+                    people,
+                    dryrun=opt.dryrun,
+                    auto_topic=opt.auto_topic,
+                    hashtags=hashtags,
+                    labels=labels,
+                    private=opt.private,
+                    notify=notify,
+                    wip=opt.wip,
+                    ready=opt.ready,
+                    dest_branch=destination,
+                    validate_certs=opt.validate_certs,
+                    push_options=opt.push_options,
+                )
+                branch.uploaded = True
+            except UploadError as e:
+                branch.error = e
+                branch.uploaded = False
+                have_errors = True
+        print(file=sys.stderr)
+        print("-" * 70, file=sys.stderr)
+        if have_errors:
+            for branch in todo:
+                if not branch.uploaded:
+                    if len(str(branch.error)) <= 30:
+                        fmt = " (%s)"
+                    else:
+                        fmt = "\n       (%s)"
+                    print(
+                        ("[FAILED] %-15s %-15s" + fmt)
+                        % (
+                            branch.project.RelPath(local=opt.this_manifest_only)
+                            + "/",
+                            branch.name,
+                            str(branch.error),
+                        ),
+                        file=sys.stderr,
+                    )
+            print()
+        for branch in todo:
+            if branch.uploaded:
+                print(
+                    "[OK    ] %-15s %s"
+                    % (
+                        branch.project.RelPath(local=opt.this_manifest_only)
+                        + "/",
+                        branch.name,
+                    ),
+                    file=sys.stderr,
+                )
+        if have_errors:
+            sys.exit(1)
+    def _GetMergeBranch(self, project, local_branch=None):
+        if local_branch is None:
+            p = GitCommand(
+                project,
+                ["rev-parse", "--abbrev-ref", "HEAD"],
+                capture_stdout=True,
+                capture_stderr=True,
+            )
+            p.Wait()
+            local_branch = p.stdout.strip()
+        p = GitCommand(
+            project,
+            ["config", "--get", "branch.%s.merge" % local_branch],
+            capture_stdout=True,
+            capture_stderr=True,
+        )
+        p.Wait()
+        merge_branch = p.stdout.strip()
+        return merge_branch
+    @staticmethod
+    def _GatherOne(opt, project):
+        """Figure out the upload status for |project|."""
+        if opt.current_branch:
+            cbr = project.CurrentBranch
+            up_branch = project.GetUploadableBranch(cbr)
+            avail = [up_branch] if up_branch else None
+        else:
+            avail = project.GetUploadableBranches(opt.branch)
+        return (project, avail)
+    def Execute(self, opt, args):
+        projects = self.GetProjects(
+            args, all_manifests=not opt.this_manifest_only
+        )
+        def _ProcessResults(_pool, _out, results):
+            pending = []
+            for result in results:
+                project, avail = result
+                if avail is None:
+                    print(
+                        'repo: error: %s: Unable to upload branch "%s". '
+                        "You might be able to fix the branch by running:\n"
+                        "  git branch --set-upstream-to m/%s"
+                        % (
+                            project.RelPath(local=opt.this_manifest_only),
+                            project.CurrentBranch,
+                            project.manifest.branch,
+                        ),
+                        file=sys.stderr,
+                    )
+                elif avail:
+                    pending.append(result)
+            return pending
+        pending = self.ExecuteInParallel(
+            opt.jobs,
+            functools.partial(self._GatherOne, opt),
+            projects,
+            callback=_ProcessResults,
+        )
+        if not pending:
+            if opt.branch is None:
+                print(
+                    "repo: error: no branches ready for upload", file=sys.stderr
+                )
            else:
-              a = sys.stdin.readline().strip().lower()
+                print(
-            if a not in ('y', 'yes', 't', 'true', 'on'):
+                    'repo: error: no branches named "%s" ready for upload'
-              print("skipping upload", file=sys.stderr)
+                    % (opt.branch,),
-              branch.uploaded = False
+                    file=sys.stderr,
-              branch.error = 'User aborted'
+                )
-              continue
+            return 1
-        # Check if topic branches should be sent to the server during upload
+        manifests = {
-        if opt.auto_topic is not True:
+            project.manifest.topdir: project.manifest
-          key = 'review.%s.uploadtopic' % branch.project.remote.review
+            for (project, available) in pending
-          opt.auto_topic = branch.project.config.GetBoolean(key)
+        }
+        ret = 0
-        def _ExpandCommaList(value):
+        for manifest in manifests.values():
-          """Split |value| up into comma delimited entries."""
+            pending_proj_names = [
-          if not value:
+                project.name
-            return
+                for (project, available) in pending
-          for ret in value.split(','):
+                if project.manifest.topdir == manifest.topdir
-            ret = ret.strip()
+            ]
-            if ret:
+            pending_worktrees = [
-              yield ret
+                project.worktree
+                for (project, available) in pending
-        # Check if hashtags should be included.
+                if project.manifest.topdir == manifest.topdir
-        key = 'review.%s.uploadhashtags' % branch.project.remote.review
+            ]
-        hashtags = set(_ExpandCommaList(branch.project.config.GetString(key)))
+            hook = RepoHook.FromSubcmd(
-        for tag in opt.hashtags:
+                hook_type="pre-upload",
-          hashtags.update(_ExpandCommaList(tag))
+                manifest=manifest,
-        if opt.hashtag_branch:
+                opt=opt,
-          hashtags.add(branch.name)
+                abort_if_user_denies=True,
+            )
-        # Check if labels should be included.
+            if not hook.Run(
-        key = 'review.%s.uploadlabels' % branch.project.remote.review
+                project_list=pending_proj_names, worktree_list=pending_worktrees
-        labels = set(_ExpandCommaList(branch.project.config.GetString(key)))
+            ):
-        for label in opt.labels:
+                ret = 1
-          labels.update(_ExpandCommaList(label))
+        if ret:
+            return ret
-        # Handle e-mail notifications.
-        if opt.notify is False:
+        reviewers = _SplitEmails(opt.reviewers) if opt.reviewers else []
-          notify = 'NONE'
+        cc = _SplitEmails(opt.cc) if opt.cc else []
+        people = (reviewers, cc)
+        if len(pending) == 1 and len(pending[0][1]) == 1:
+            self._SingleBranch(opt, pending[0][1][0], people)
        else:
-          key = 'review.%s.uploadnotify' % branch.project.remote.review
+            self._MultipleBranches(opt, pending, people)
-          notify = branch.project.config.GetString(key)
-        destination = opt.dest_branch or branch.project.dest_branch
-        if branch.project.dest_branch and not opt.dest_branch:
-          merge_branch = self._GetMergeBranch(
-            branch.project, local_branch=branch.name)
-          full_dest = destination
-          if not full_dest.startswith(R_HEADS):
-            full_dest = R_HEADS + full_dest
-          # If the merge branch of the local branch is different from the
-          # project's revision AND destination, this might not be intentional.
-          if (merge_branch and merge_branch != branch.project.revisionExpr
-              and merge_branch != full_dest):
-            print(f'For local branch {branch.name}: merge branch '
-                  f'{merge_branch} does not match destination branch '
-                  f'{destination}')
-            print('skipping upload.')
-            print(f'Please use `--destination {destination}` if this is intentional')
-            branch.uploaded = False
-            continue
-        branch.UploadForReview(people,
-                               dryrun=opt.dryrun,
-                               auto_topic=opt.auto_topic,
-                               hashtags=hashtags,
-                               labels=labels,
-                               private=opt.private,
-                               notify=notify,
-                               wip=opt.wip,
-                               ready=opt.ready,
-                               dest_branch=destination,
-                               validate_certs=opt.validate_certs,
-                               push_options=opt.push_options)
-        branch.uploaded = True
-      except UploadError as e:
-        branch.error = e
-        branch.uploaded = False
-        have_errors = True
-    print(file=sys.stderr)
-    print('----------------------------------------------------------------------', file=sys.stderr)
-    if have_errors:
-      for branch in todo:
-        if not branch.uploaded:
-          if len(str(branch.error)) <= 30:
-            fmt = ' (%s)'
-          else:
-            fmt = '\n       (%s)'
-          print(('[FAILED] %-15s %-15s' + fmt) % (
-              branch.project.RelPath(local=opt.this_manifest_only) + '/',
-              branch.name,
-              str(branch.error)),
-              file=sys.stderr)
-      print()
-    for branch in todo:
-      if branch.uploaded:
-        print('[OK    ] %-15s %s' % (
-            branch.project.RelPath(local=opt.this_manifest_only) + '/',
-            branch.name),
-            file=sys.stderr)
-    if have_errors:
-      sys.exit(1)
-  def _GetMergeBranch(self, project, local_branch=None):
-    if local_branch is None:
-      p = GitCommand(project,
-                     ['rev-parse', '--abbrev-ref', 'HEAD'],
-                     capture_stdout=True,
-                     capture_stderr=True)
-      p.Wait()
-      local_branch = p.stdout.strip()
-    p = GitCommand(project,
-                   ['config', '--get', 'branch.%s.merge' % local_branch],
-                   capture_stdout=True,
-                   capture_stderr=True)
-    p.Wait()
-    merge_branch = p.stdout.strip()
-    return merge_branch
-  @staticmethod
-  def _GatherOne(opt, project):
-    """Figure out the upload status for |project|."""
-    if opt.current_branch:
-      cbr = project.CurrentBranch
-      up_branch = project.GetUploadableBranch(cbr)
-      avail = [up_branch] if up_branch else None
-    else:
-      avail = project.GetUploadableBranches(opt.branch)
-    return (project, avail)
-  def Execute(self, opt, args):
-    projects = self.GetProjects(args, all_manifests=not opt.this_manifest_only)
-    def _ProcessResults(_pool, _out, results):
-      pending = []
-      for result in results:
-        project, avail = result
-        if avail is None:
-          print('repo: error: %s: Unable to upload branch "%s". '
-                'You might be able to fix the branch by running:\n'
-                '  git branch --set-upstream-to m/%s' %
-                (project.RelPath(local=opt.this_manifest_only), project.CurrentBranch,
-                 project.manifest.branch),
-                file=sys.stderr)
-        elif avail:
-          pending.append(result)
-      return pending
-    pending = self.ExecuteInParallel(
-        opt.jobs,
-        functools.partial(self._GatherOne, opt),
-        projects,
-        callback=_ProcessResults)
-    if not pending:
-      if opt.branch is None:
-        print('repo: error: no branches ready for upload', file=sys.stderr)
-      else:
-        print('repo: error: no branches named "%s" ready for upload' %
-              (opt.branch,), file=sys.stderr)
-      return 1
-    manifests = {project.manifest.topdir: project.manifest
-                 for (project, available) in pending}
-    ret = 0
-    for manifest in manifests.values():
-      pending_proj_names = [project.name for (project, available) in pending
-                            if project.manifest.topdir == manifest.topdir]
-      pending_worktrees = [project.worktree for (project, available) in pending
-                           if project.manifest.topdir == manifest.topdir]
-      hook = RepoHook.FromSubcmd(
-          hook_type='pre-upload', manifest=manifest,
-          opt=opt, abort_if_user_denies=True)
-      if not hook.Run(project_list=pending_proj_names,
-                      worktree_list=pending_worktrees):
-        ret = 1
-    if ret:
-      return ret
-    reviewers = _SplitEmails(opt.reviewers) if opt.reviewers else []
-    cc = _SplitEmails(opt.cc) if opt.cc else []
-    people = (reviewers, cc)
-    if len(pending) == 1 and len(pending[0][1]) == 1:
-      self._SingleBranch(opt, pending[0][1][0], people)
-    else:
-      self._MultipleBranches(opt, pending, people)
diff --git a/subcmds/version.py b/subcmds/version.py
index c68cb0af..c539db63 100644
--- a/subcmds/version.py
+++ b/subcmds/version.py
@@ -22,45 +22,52 @@ from wrapper import Wrapper
 class Version(Command, MirrorSafeCommand):
-  wrapper_version = None
+    wrapper_version = None
-  wrapper_path = None
+    wrapper_path = None
-  COMMON = False
+    COMMON = False
-  helpSummary = "Display the version of repo"
+    helpSummary = "Display the version of repo"
-  helpUsage = """
+    helpUsage = """
 %prog
 """
-  def Execute(self, opt, args):
+    def Execute(self, opt, args):
-    rp = self.manifest.repoProject
+        rp = self.manifest.repoProject
-    rem = rp.GetRemote()
+        rem = rp.GetRemote()
-    branch = rp.GetBranch('default')
+        branch = rp.GetBranch("default")
-    # These might not be the same.  Report them both.
+        # These might not be the same.  Report them both.
-    src_ver = RepoSourceVersion()
+        src_ver = RepoSourceVersion()
-    rp_ver = rp.bare_git.describe(HEAD)
+        rp_ver = rp.bare_git.describe(HEAD)
-    print('repo version %s' % rp_ver)
+        print("repo version %s" % rp_ver)
-    print('       (from %s)' % rem.url)
+        print("       (from %s)" % rem.url)
-    print('       (tracking %s)' % branch.merge)
+        print("       (tracking %s)" % branch.merge)
-    print('       (%s)' % rp.bare_git.log('-1', '--format=%cD', HEAD))
+        print("       (%s)" % rp.bare_git.log("-1", "--format=%cD", HEAD))
-    if self.wrapper_path is not None:
+        if self.wrapper_path is not None:
-      print('repo launcher version %s' % self.wrapper_version)
+            print("repo launcher version %s" % self.wrapper_version)
-      print('       (from %s)' % self.wrapper_path)
+            print("       (from %s)" % self.wrapper_path)
-      if src_ver != rp_ver:
+            if src_ver != rp_ver:
-        print('       (currently at %s)' % src_ver)
+                print("       (currently at %s)" % src_ver)
-    print('repo User-Agent %s' % user_agent.repo)
+        print("repo User-Agent %s" % user_agent.repo)
-    print('git %s' % git.version_tuple().full)
+        print("git %s" % git.version_tuple().full)
-    print('git User-Agent %s' % user_agent.git)
+        print("git User-Agent %s" % user_agent.git)
-    print('Python %s' % sys.version)
+        print("Python %s" % sys.version)
-    uname = platform.uname()
+        uname = platform.uname()
-    if sys.version_info.major < 3:
+        if sys.version_info.major < 3:
-      # Python 3 returns a named tuple, but Python 2 is simpler.
+            # Python 3 returns a named tuple, but Python 2 is simpler.
-      print(uname)
+            print(uname)
-    else:
+        else:
-      print('OS %s %s (%s)' % (uname.system, uname.release, uname.version))
+            print(
-      print('CPU %s (%s)' %
+                "OS %s %s (%s)" % (uname.system, uname.release, uname.version)
-            (uname.machine, uname.processor if uname.processor else 'unknown'))
+            )
-    print('Bug reports:', Wrapper().BUG_URL)
+            print(
+                "CPU %s (%s)"
+                % (
+                    uname.machine,
+                    uname.processor if uname.processor else "unknown",
+                )
+            )
+        print("Bug reports:", Wrapper().BUG_URL)
diff --git a/tests/conftest.py b/tests/conftest.py
index 3e43f6d3..e1a2292a 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -21,5 +21,5 @@ import repo_trace
 @pytest.fixture(autouse=True)
 def disable_repo_trace(tmp_path):
-  """Set an environment marker to relax certain strict checks for test code."""
+    """Set an environment marker to relax certain strict checks for test code."""  # noqa: E501
-  repo_trace._TRACE_FILE = str(tmp_path / 'TRACE_FILE_from_test')
+    repo_trace._TRACE_FILE = str(tmp_path / "TRACE_FILE_from_test")
diff --git a/tests/test_editor.py b/tests/test_editor.py
index cfd4f5ed..8f5d160e 100644
--- a/tests/test_editor.py
+++ b/tests/test_editor.py
@@ -20,37 +20,37 @@ from editor import Editor
 class EditorTestCase(unittest.TestCase):
-  """Take care of resetting Editor state across tests."""
+    """Take care of resetting Editor state across tests."""
-  def setUp(self):
+    def setUp(self):
-    self.setEditor(None)
+        self.setEditor(None)
-  def tearDown(self):
+    def tearDown(self):
-    self.setEditor(None)
+        self.setEditor(None)
-  @staticmethod
+    @staticmethod
-  def setEditor(editor):
+    def setEditor(editor):
-    Editor._editor = editor
+        Editor._editor = editor
 class GetEditor(EditorTestCase):
-  """Check GetEditor behavior."""
+    """Check GetEditor behavior."""
-  def test_basic(self):
+    def test_basic(self):
-    """Basic checking of _GetEditor."""
+        """Basic checking of _GetEditor."""
-    self.setEditor(':')
+        self.setEditor(":")
-    self.assertEqual(':', Editor._GetEditor())
+        self.assertEqual(":", Editor._GetEditor())
 class EditString(EditorTestCase):
-  """Check EditString behavior."""
+    """Check EditString behavior."""
-  def test_no_editor(self):
+    def test_no_editor(self):
-    """Check behavior when no editor is available."""
+        """Check behavior when no editor is available."""
-    self.setEditor(':')
+        self.setEditor(":")
-    self.assertEqual('foo', Editor.EditString('foo'))
+        self.assertEqual("foo", Editor.EditString("foo"))
-  def test_cat_editor(self):
+    def test_cat_editor(self):
-    """Check behavior when editor is `cat`."""
+        """Check behavior when editor is `cat`."""
-    self.setEditor('cat')
+        self.setEditor("cat")
-    self.assertEqual('foo', Editor.EditString('foo'))
+        self.assertEqual("foo", Editor.EditString("foo"))
diff --git a/tests/test_error.py b/tests/test_error.py
index 82b00c24..784e2d57 100644
--- a/tests/test_error.py
+++ b/tests/test_error.py
@@ -22,32 +22,34 @@ import error
 class PickleTests(unittest.TestCase):
-  """Make sure all our custom exceptions can be pickled."""
+    """Make sure all our custom exceptions can be pickled."""
-  def getExceptions(self):
+    def getExceptions(self):
-    """Return all our custom exceptions."""
+        """Return all our custom exceptions."""
-    for name in dir(error):
+        for name in dir(error):
-      cls = getattr(error, name)
+            cls = getattr(error, name)
-      if isinstance(cls, type) and issubclass(cls, Exception):
+            if isinstance(cls, type) and issubclass(cls, Exception):
-        yield cls
+                yield cls
-  def testExceptionLookup(self):
+    def testExceptionLookup(self):
-    """Make sure our introspection logic works."""
+        """Make sure our introspection logic works."""
-    classes = list(self.getExceptions())
+        classes = list(self.getExceptions())
-    self.assertIn(error.HookError, classes)
+        self.assertIn(error.HookError, classes)
-    # Don't assert the exact number to avoid being a change-detector test.
+        # Don't assert the exact number to avoid being a change-detector test.
-    self.assertGreater(len(classes), 10)
+        self.assertGreater(len(classes), 10)
-  def testPickle(self):
+    def testPickle(self):
-    """Try to pickle all the exceptions."""
+        """Try to pickle all the exceptions."""
-    for cls in self.getExceptions():
+        for cls in self.getExceptions():
-      args = inspect.getfullargspec(cls.__init__).args[1:]
+            args = inspect.getfullargspec(cls.__init__).args[1:]
-      obj = cls(*args)
+            obj = cls(*args)
-      p = pickle.dumps(obj)
+            p = pickle.dumps(obj)
-      try:
+            try:
-        newobj = pickle.loads(p)
+                newobj = pickle.loads(p)
-      except Exception as e:  # pylint: disable=broad-except
+            except Exception as e:  # pylint: disable=broad-except
-        self.fail('Class %s is unable to be pickled: %s\n'
+                self.fail(
-                  'Incomplete super().__init__(...) call?' % (cls, e))
+                    "Class %s is unable to be pickled: %s\n"
-      self.assertIsInstance(newobj, cls)
+                    "Incomplete super().__init__(...) call?" % (cls, e)
-      self.assertEqual(str(obj), str(newobj))
+                )
+            self.assertIsInstance(newobj, cls)
+            self.assertEqual(str(obj), str(newobj))
diff --git a/tests/test_git_command.py b/tests/test_git_command.py
index 96408a23..c4c3a4c5 100644
--- a/tests/test_git_command.py
+++ b/tests/test_git_command.py
@@ -19,138 +19,146 @@ import os
 import unittest
 try:
-  from unittest import mock
+    from unittest import mock
 except ImportError:
-  import mock
+    import mock
 import git_command
 import wrapper
 class GitCommandTest(unittest.TestCase):
-  """Tests the GitCommand class (via git_command.git)."""
+    """Tests the GitCommand class (via git_command.git)."""
-  def setUp(self):
+    def setUp(self):
+        def realpath_mock(val):
+            return val
-    def realpath_mock(val):
+        mock.patch.object(
-      return val
+            os.path, "realpath", side_effect=realpath_mock
+        ).start()
-    mock.patch.object(os.path, 'realpath', side_effect=realpath_mock).start()
+    def tearDown(self):
+        mock.patch.stopall()
-  def tearDown(self):
+    def test_alternative_setting_when_matching(self):
-    mock.patch.stopall()
+        r = git_command._build_env(
+            objdir=os.path.join("zap", "objects"), gitdir="zap"
+        )
-  def test_alternative_setting_when_matching(self):
+        self.assertIsNone(r.get("GIT_ALTERNATE_OBJECT_DIRECTORIES"))
-    r = git_command._build_env(
+        self.assertEqual(
-      objdir = os.path.join('zap', 'objects'),
+            r.get("GIT_OBJECT_DIRECTORY"), os.path.join("zap", "objects")
-      gitdir = 'zap'
+        )
-    )
-    self.assertIsNone(r.get('GIT_ALTERNATE_OBJECT_DIRECTORIES'))
+    def test_alternative_setting_when_different(self):
-    self.assertEqual(r.get('GIT_OBJECT_DIRECTORY'), os.path.join('zap', 'objects'))
+        r = git_command._build_env(
+            objdir=os.path.join("wow", "objects"), gitdir="zap"
+        )
-  def test_alternative_setting_when_different(self):
+        self.assertEqual(
-    r = git_command._build_env(
+            r.get("GIT_ALTERNATE_OBJECT_DIRECTORIES"),
-      objdir = os.path.join('wow', 'objects'),
+            os.path.join("zap", "objects"),
-      gitdir = 'zap'
+        )
-    )
+        self.assertEqual(
+            r.get("GIT_OBJECT_DIRECTORY"), os.path.join("wow", "objects")
-    self.assertEqual(r.get('GIT_ALTERNATE_OBJECT_DIRECTORIES'), os.path.join('zap', 'objects'))
+        )
-    self.assertEqual(r.get('GIT_OBJECT_DIRECTORY'), os.path.join('wow', 'objects'))
 class GitCallUnitTest(unittest.TestCase):
-  """Tests the _GitCall class (via git_command.git)."""
+    """Tests the _GitCall class (via git_command.git)."""
-  def test_version_tuple(self):
+    def test_version_tuple(self):
-    """Check git.version_tuple() handling."""
+        """Check git.version_tuple() handling."""
-    ver = git_command.git.version_tuple()
+        ver = git_command.git.version_tuple()
-    self.assertIsNotNone(ver)
+        self.assertIsNotNone(ver)
-    # We don't dive too deep into the values here to avoid having to update
+        # We don't dive too deep into the values here to avoid having to update
-    # whenever git versions change.  We do check relative to this min version
+        # whenever git versions change.  We do check relative to this min
-    # as this is what `repo` itself requires via MIN_GIT_VERSION.
+        # version as this is what `repo` itself requires via MIN_GIT_VERSION.
-    MIN_GIT_VERSION = (2, 10, 2)
+        MIN_GIT_VERSION = (2, 10, 2)
-    self.assertTrue(isinstance(ver.major, int))
+        self.assertTrue(isinstance(ver.major, int))
-    self.assertTrue(isinstance(ver.minor, int))
+        self.assertTrue(isinstance(ver.minor, int))
-    self.assertTrue(isinstance(ver.micro, int))
+        self.assertTrue(isinstance(ver.micro, int))
-    self.assertGreater(ver.major, MIN_GIT_VERSION[0] - 1)
+        self.assertGreater(ver.major, MIN_GIT_VERSION[0] - 1)
-    self.assertGreaterEqual(ver.micro, 0)
+        self.assertGreaterEqual(ver.micro, 0)
-    self.assertGreaterEqual(ver.major, 0)
+        self.assertGreaterEqual(ver.major, 0)
-    self.assertGreaterEqual(ver, MIN_GIT_VERSION)
+        self.assertGreaterEqual(ver, MIN_GIT_VERSION)
-    self.assertLess(ver, (9999, 9999, 9999))
+        self.assertLess(ver, (9999, 9999, 9999))
-    self.assertNotEqual('', ver.full)
+        self.assertNotEqual("", ver.full)
 class UserAgentUnitTest(unittest.TestCase):
-  """Tests the UserAgent function."""
+    """Tests the UserAgent function."""
-  def test_smoke_os(self):
+    def test_smoke_os(self):
-    """Make sure UA OS setting returns something useful."""
+        """Make sure UA OS setting returns something useful."""
-    os_name = git_command.user_agent.os
+        os_name = git_command.user_agent.os
-    # We can't dive too deep because of OS/tool differences, but we can check
+        # We can't dive too deep because of OS/tool differences, but we can
-    # the general form.
+        # check the general form.
-    m = re.match(r'^[^ ]+$', os_name)
+        m = re.match(r"^[^ ]+$", os_name)
-    self.assertIsNotNone(m)
+        self.assertIsNotNone(m)
-  def test_smoke_repo(self):
+    def test_smoke_repo(self):
-    """Make sure repo UA returns something useful."""
+        """Make sure repo UA returns something useful."""
-    ua = git_command.user_agent.repo
+        ua = git_command.user_agent.repo
-    # We can't dive too deep because of OS/tool differences, but we can check
+        # We can't dive too deep because of OS/tool differences, but we can
-    # the general form.
+        # check the general form.
-    m = re.match(r'^git-repo/[^ ]+ ([^ ]+) git/[^ ]+ Python/[0-9.]+', ua)
+        m = re.match(r"^git-repo/[^ ]+ ([^ ]+) git/[^ ]+ Python/[0-9.]+", ua)
-    self.assertIsNotNone(m)
+        self.assertIsNotNone(m)
-  def test_smoke_git(self):
+    def test_smoke_git(self):
-    """Make sure git UA returns something useful."""
+        """Make sure git UA returns something useful."""
-    ua = git_command.user_agent.git
+        ua = git_command.user_agent.git
-    # We can't dive too deep because of OS/tool differences, but we can check
+        # We can't dive too deep because of OS/tool differences, but we can
-    # the general form.
+        # check the general form.
-    m = re.match(r'^git/[^ ]+ ([^ ]+) git-repo/[^ ]+', ua)
+        m = re.match(r"^git/[^ ]+ ([^ ]+) git-repo/[^ ]+", ua)
-    self.assertIsNotNone(m)
+        self.assertIsNotNone(m)
 class GitRequireTests(unittest.TestCase):
-  """Test the git_require helper."""
+    """Test the git_require helper."""
-  def setUp(self):
+    def setUp(self):
-    self.wrapper = wrapper.Wrapper()
+        self.wrapper = wrapper.Wrapper()
-    ver = self.wrapper.GitVersion(1, 2, 3, 4)
+        ver = self.wrapper.GitVersion(1, 2, 3, 4)
-    mock.patch.object(git_command.git, 'version_tuple', return_value=ver).start()
+        mock.patch.object(
+            git_command.git, "version_tuple", return_value=ver
-  def tearDown(self):
+        ).start()
-    mock.patch.stopall()
+    def tearDown(self):
-  def test_older_nonfatal(self):
+        mock.patch.stopall()
-    """Test non-fatal require calls with old versions."""
-    self.assertFalse(git_command.git_require((2,)))
+    def test_older_nonfatal(self):
-    self.assertFalse(git_command.git_require((1, 3)))
+        """Test non-fatal require calls with old versions."""
-    self.assertFalse(git_command.git_require((1, 2, 4)))
+        self.assertFalse(git_command.git_require((2,)))
-    self.assertFalse(git_command.git_require((1, 2, 3, 5)))
+        self.assertFalse(git_command.git_require((1, 3)))
+        self.assertFalse(git_command.git_require((1, 2, 4)))
-  def test_newer_nonfatal(self):
+        self.assertFalse(git_command.git_require((1, 2, 3, 5)))
-    """Test non-fatal require calls with newer versions."""
-    self.assertTrue(git_command.git_require((0,)))
+    def test_newer_nonfatal(self):
-    self.assertTrue(git_command.git_require((1, 0)))
+        """Test non-fatal require calls with newer versions."""
-    self.assertTrue(git_command.git_require((1, 2, 0)))
+        self.assertTrue(git_command.git_require((0,)))
-    self.assertTrue(git_command.git_require((1, 2, 3, 0)))
+        self.assertTrue(git_command.git_require((1, 0)))
+        self.assertTrue(git_command.git_require((1, 2, 0)))
-  def test_equal_nonfatal(self):
+        self.assertTrue(git_command.git_require((1, 2, 3, 0)))
-    """Test require calls with equal values."""
-    self.assertTrue(git_command.git_require((1, 2, 3, 4), fail=False))
+    def test_equal_nonfatal(self):
-    self.assertTrue(git_command.git_require((1, 2, 3, 4), fail=True))
+        """Test require calls with equal values."""
+        self.assertTrue(git_command.git_require((1, 2, 3, 4), fail=False))
-  def test_older_fatal(self):
+        self.assertTrue(git_command.git_require((1, 2, 3, 4), fail=True))
-    """Test fatal require calls with old versions."""
-    with self.assertRaises(SystemExit) as e:
+    def test_older_fatal(self):
-      git_command.git_require((2,), fail=True)
+        """Test fatal require calls with old versions."""
-      self.assertNotEqual(0, e.code)
+        with self.assertRaises(SystemExit) as e:
+            git_command.git_require((2,), fail=True)
-  def test_older_fatal_msg(self):
+            self.assertNotEqual(0, e.code)
-    """Test fatal require calls with old versions and message."""
-    with self.assertRaises(SystemExit) as e:
+    def test_older_fatal_msg(self):
-      git_command.git_require((2,), fail=True, msg='so sad')
+        """Test fatal require calls with old versions and message."""
-      self.assertNotEqual(0, e.code)
+        with self.assertRaises(SystemExit) as e:
+            git_command.git_require((2,), fail=True, msg="so sad")
+            self.assertNotEqual(0, e.code)
diff --git a/tests/test_git_config.py b/tests/test_git_config.py
index 3b0aa8b4..a44dca0f 100644
--- a/tests/test_git_config.py
+++ b/tests/test_git_config.py
@@ -22,167 +22,169 @@ import git_config
 def fixture(*paths):
-  """Return a path relative to test/fixtures.
+    """Return a path relative to test/fixtures."""
-  """
+    return os.path.join(os.path.dirname(__file__), "fixtures", *paths)
-  return os.path.join(os.path.dirname(__file__), 'fixtures', *paths)
 class GitConfigReadOnlyTests(unittest.TestCase):
-  """Read-only tests of the GitConfig class."""
+    """Read-only tests of the GitConfig class."""
-  def setUp(self):
+    def setUp(self):
-    """Create a GitConfig object using the test.gitconfig fixture.
+        """Create a GitConfig object using the test.gitconfig fixture."""
-    """
+        config_fixture = fixture("test.gitconfig")
-    config_fixture = fixture('test.gitconfig')
+        self.config = git_config.GitConfig(config_fixture)
-    self.config = git_config.GitConfig(config_fixture)
+    def test_GetString_with_empty_config_values(self):
-  def test_GetString_with_empty_config_values(self):
+        """
-    """
+        Test config entries with no value.
-    Test config entries with no value.
+        [section]
-    [section]
+            empty
-        empty
+        """
-    """
+        val = self.config.GetString("section.empty")
-    val = self.config.GetString('section.empty')
+        self.assertEqual(val, None)
-    self.assertEqual(val, None)
+    def test_GetString_with_true_value(self):
-  def test_GetString_with_true_value(self):
+        """
-    """
+        Test config entries with a string value.
-    Test config entries with a string value.
+        [section]
-    [section]
+            nonempty = true
-        nonempty = true
+        """
-    """
+        val = self.config.GetString("section.nonempty")
-    val = self.config.GetString('section.nonempty')
+        self.assertEqual(val, "true")
-    self.assertEqual(val, 'true')
+    def test_GetString_from_missing_file(self):
-  def test_GetString_from_missing_file(self):
+        """
-    """
+        Test missing config file
-    Test missing config file
+        """
-    """
+        config_fixture = fixture("not.present.gitconfig")
-    config_fixture = fixture('not.present.gitconfig')
+        config = git_config.GitConfig(config_fixture)
-    config = git_config.GitConfig(config_fixture)
+        val = config.GetString("empty")
-    val = config.GetString('empty')
+        self.assertEqual(val, None)
-    self.assertEqual(val, None)
+    def test_GetBoolean_undefined(self):
-  def test_GetBoolean_undefined(self):
+        """Test GetBoolean on key that doesn't exist."""
-    """Test GetBoolean on key that doesn't exist."""
+        self.assertIsNone(self.config.GetBoolean("section.missing"))
-    self.assertIsNone(self.config.GetBoolean('section.missing'))
+    def test_GetBoolean_invalid(self):
-  def test_GetBoolean_invalid(self):
+        """Test GetBoolean on invalid boolean value."""
-    """Test GetBoolean on invalid boolean value."""
+        self.assertIsNone(self.config.GetBoolean("section.boolinvalid"))
-    self.assertIsNone(self.config.GetBoolean('section.boolinvalid'))
+    def test_GetBoolean_true(self):
-  def test_GetBoolean_true(self):
+        """Test GetBoolean on valid true boolean."""
-    """Test GetBoolean on valid true boolean."""
+        self.assertTrue(self.config.GetBoolean("section.booltrue"))
-    self.assertTrue(self.config.GetBoolean('section.booltrue'))
+    def test_GetBoolean_false(self):
-  def test_GetBoolean_false(self):
+        """Test GetBoolean on valid false boolean."""
-    """Test GetBoolean on valid false boolean."""
+        self.assertFalse(self.config.GetBoolean("section.boolfalse"))
-    self.assertFalse(self.config.GetBoolean('section.boolfalse'))
+    def test_GetInt_undefined(self):
-  def test_GetInt_undefined(self):
+        """Test GetInt on key that doesn't exist."""
-    """Test GetInt on key that doesn't exist."""
+        self.assertIsNone(self.config.GetInt("section.missing"))
-    self.assertIsNone(self.config.GetInt('section.missing'))
+    def test_GetInt_invalid(self):
-  def test_GetInt_invalid(self):
+        """Test GetInt on invalid integer value."""
-    """Test GetInt on invalid integer value."""
+        self.assertIsNone(self.config.GetBoolean("section.intinvalid"))
-    self.assertIsNone(self.config.GetBoolean('section.intinvalid'))
+    def test_GetInt_valid(self):
-  def test_GetInt_valid(self):
+        """Test GetInt on valid integers."""
-    """Test GetInt on valid integers."""
+        TESTS = (
-    TESTS = (
+            ("inthex", 16),
-        ('inthex', 16),
+            ("inthexk", 16384),
-        ('inthexk', 16384),
+            ("int", 10),
-        ('int', 10),
+            ("intk", 10240),
-        ('intk', 10240),
+            ("intm", 10485760),
-        ('intm', 10485760),
+            ("intg", 10737418240),
-        ('intg', 10737418240),
+        )
-    )
+        for key, value in TESTS:
-    for key, value in TESTS:
+            self.assertEqual(value, self.config.GetInt("section.%s" % (key,)))
-      self.assertEqual(value, self.config.GetInt('section.%s' % (key,)))
 class GitConfigReadWriteTests(unittest.TestCase):
-  """Read/write tests of the GitConfig class."""
+    """Read/write tests of the GitConfig class."""
-  def setUp(self):
+    def setUp(self):
-    self.tmpfile = tempfile.NamedTemporaryFile()
+        self.tmpfile = tempfile.NamedTemporaryFile()
-    self.config = self.get_config()
+        self.config = self.get_config()
-  def get_config(self):
+    def get_config(self):
-    """Get a new GitConfig instance."""
+        """Get a new GitConfig instance."""
-    return git_config.GitConfig(self.tmpfile.name)
+        return git_config.GitConfig(self.tmpfile.name)
-  def test_SetString(self):
+    def test_SetString(self):
-    """Test SetString behavior."""
+        """Test SetString behavior."""
-    # Set a value.
+        # Set a value.
-    self.assertIsNone(self.config.GetString('foo.bar'))
+        self.assertIsNone(self.config.GetString("foo.bar"))
-    self.config.SetString('foo.bar', 'val')
+        self.config.SetString("foo.bar", "val")
-    self.assertEqual('val', self.config.GetString('foo.bar'))
+        self.assertEqual("val", self.config.GetString("foo.bar"))
-    # Make sure the value was actually written out.
+        # Make sure the value was actually written out.
-    config = self.get_config()
+        config = self.get_config()
-    self.assertEqual('val', config.GetString('foo.bar'))
+        self.assertEqual("val", config.GetString("foo.bar"))
-    # Update the value.
+        # Update the value.
-    self.config.SetString('foo.bar', 'valll')
+        self.config.SetString("foo.bar", "valll")
-    self.assertEqual('valll', self.config.GetString('foo.bar'))
+        self.assertEqual("valll", self.config.GetString("foo.bar"))
-    config = self.get_config()
+        config = self.get_config()
-    self.assertEqual('valll', config.GetString('foo.bar'))
+        self.assertEqual("valll", config.GetString("foo.bar"))
-    # Delete the value.
+        # Delete the value.
-    self.config.SetString('foo.bar', None)
+        self.config.SetString("foo.bar", None)
-    self.assertIsNone(self.config.GetString('foo.bar'))
+        self.assertIsNone(self.config.GetString("foo.bar"))
-    config = self.get_config()
+        config = self.get_config()
-    self.assertIsNone(config.GetString('foo.bar'))
+        self.assertIsNone(config.GetString("foo.bar"))
-  def test_SetBoolean(self):
+    def test_SetBoolean(self):
-    """Test SetBoolean behavior."""
+        """Test SetBoolean behavior."""
-    # Set a true value.
+        # Set a true value.
-    self.assertIsNone(self.config.GetBoolean('foo.bar'))
+        self.assertIsNone(self.config.GetBoolean("foo.bar"))
-    for val in (True, 1):
+        for val in (True, 1):
-      self.config.SetBoolean('foo.bar', val)
+            self.config.SetBoolean("foo.bar", val)
-      self.assertTrue(self.config.GetBoolean('foo.bar'))
+            self.assertTrue(self.config.GetBoolean("foo.bar"))
-    # Make sure the value was actually written out.
+        # Make sure the value was actually written out.
-    config = self.get_config()
+        config = self.get_config()
-    self.assertTrue(config.GetBoolean('foo.bar'))
+        self.assertTrue(config.GetBoolean("foo.bar"))
-    self.assertEqual('true', config.GetString('foo.bar'))
+        self.assertEqual("true", config.GetString("foo.bar"))
-    # Set a false value.
+        # Set a false value.
-    for val in (False, 0):
+        for val in (False, 0):
-      self.config.SetBoolean('foo.bar', val)
+            self.config.SetBoolean("foo.bar", val)
-      self.assertFalse(self.config.GetBoolean('foo.bar'))
+            self.assertFalse(self.config.GetBoolean("foo.bar"))
-    # Make sure the value was actually written out.
+        # Make sure the value was actually written out.
-    config = self.get_config()
+        config = self.get_config()
-    self.assertFalse(config.GetBoolean('foo.bar'))
+        self.assertFalse(config.GetBoolean("foo.bar"))
-    self.assertEqual('false', config.GetString('foo.bar'))
+        self.assertEqual("false", config.GetString("foo.bar"))
-    # Delete the value.
+        # Delete the value.
-    self.config.SetBoolean('foo.bar', None)
+        self.config.SetBoolean("foo.bar", None)
-    self.assertIsNone(self.config.GetBoolean('foo.bar'))
+        self.assertIsNone(self.config.GetBoolean("foo.bar"))
-    config = self.get_config()
+        config = self.get_config()
-    self.assertIsNone(config.GetBoolean('foo.bar'))
+        self.assertIsNone(config.GetBoolean("foo.bar"))
-  def test_GetSyncAnalysisStateData(self):
+    def test_GetSyncAnalysisStateData(self):
-    """Test config entries with a sync state analysis data."""
+        """Test config entries with a sync state analysis data."""
-    superproject_logging_data = {}
+        superproject_logging_data = {}
-    superproject_logging_data['test'] = False
+        superproject_logging_data["test"] = False
-    options = type('options', (object,), {})()
+        options = type("options", (object,), {})()
-    options.verbose = 'true'
+        options.verbose = "true"
-    options.mp_update = 'false'
+        options.mp_update = "false"
-    TESTS = (
+        TESTS = (
-        ('superproject.test', 'false'),
+            ("superproject.test", "false"),
-        ('options.verbose', 'true'),
+            ("options.verbose", "true"),
-        ('options.mpupdate', 'false'),
+            ("options.mpupdate", "false"),
-        ('main.version', '1'),
+            ("main.version", "1"),
-    )
+        )
-    self.config.UpdateSyncAnalysisState(options, superproject_logging_data)
+        self.config.UpdateSyncAnalysisState(options, superproject_logging_data)
-    sync_data = self.config.GetSyncAnalysisStateData()
+        sync_data = self.config.GetSyncAnalysisStateData()
-    for key, value in TESTS:
+        for key, value in TESTS:
-      self.assertEqual(sync_data[f'{git_config.SYNC_STATE_PREFIX}{key}'], value)
+            self.assertEqual(
-    self.assertTrue(sync_data[f'{git_config.SYNC_STATE_PREFIX}main.synctime'])
+                sync_data[f"{git_config.SYNC_STATE_PREFIX}{key}"], value
+            )
+        self.assertTrue(
+            sync_data[f"{git_config.SYNC_STATE_PREFIX}main.synctime"]
+        )
diff --git a/tests/test_git_superproject.py b/tests/test_git_superproject.py
index b9b597a6..eb542c60 100644
--- a/tests/test_git_superproject.py
+++ b/tests/test_git_superproject.py
@@ -28,297 +28,369 @@ from test_manifest_xml import sort_attributes
 class SuperprojectTestCase(unittest.TestCase):
-  """TestCase for the Superproject module."""
+    """TestCase for the Superproject module."""
-  PARENT_SID_KEY = 'GIT_TRACE2_PARENT_SID'
+    PARENT_SID_KEY = "GIT_TRACE2_PARENT_SID"
-  PARENT_SID_VALUE = 'parent_sid'
+    PARENT_SID_VALUE = "parent_sid"
-  SELF_SID_REGEX = r'repo-\d+T\d+Z-.*'
+    SELF_SID_REGEX = r"repo-\d+T\d+Z-.*"
-  FULL_SID_REGEX = r'^%s/%s' % (PARENT_SID_VALUE, SELF_SID_REGEX)
+    FULL_SID_REGEX = r"^%s/%s" % (PARENT_SID_VALUE, SELF_SID_REGEX)
-  def setUp(self):
+    def setUp(self):
-    """Set up superproject every time."""
+        """Set up superproject every time."""
-    self.tempdirobj = tempfile.TemporaryDirectory(prefix='repo_tests')
+        self.tempdirobj = tempfile.TemporaryDirectory(prefix="repo_tests")
-    self.tempdir = self.tempdirobj.name
+        self.tempdir = self.tempdirobj.name
-    self.repodir = os.path.join(self.tempdir, '.repo')
+        self.repodir = os.path.join(self.tempdir, ".repo")
-    self.manifest_file = os.path.join(
+        self.manifest_file = os.path.join(
-        self.repodir, manifest_xml.MANIFEST_FILE_NAME)
+            self.repodir, manifest_xml.MANIFEST_FILE_NAME
-    os.mkdir(self.repodir)
+        )
-    self.platform = platform.system().lower()
+        os.mkdir(self.repodir)
+        self.platform = platform.system().lower()
-    # By default we initialize with the expected case where
-    # repo launches us (so GIT_TRACE2_PARENT_SID is set).
+        # By default we initialize with the expected case where
-    env = {
+        # repo launches us (so GIT_TRACE2_PARENT_SID is set).
-        self.PARENT_SID_KEY: self.PARENT_SID_VALUE,
+        env = {
-    }
+            self.PARENT_SID_KEY: self.PARENT_SID_VALUE,
-    self.git_event_log = git_trace2_event_log.EventLog(env=env)
+        }
+        self.git_event_log = git_trace2_event_log.EventLog(env=env)
-    # The manifest parsing really wants a git repo currently.
-    gitdir = os.path.join(self.repodir, 'manifests.git')
+        # The manifest parsing really wants a git repo currently.
-    os.mkdir(gitdir)
+        gitdir = os.path.join(self.repodir, "manifests.git")
-    with open(os.path.join(gitdir, 'config'), 'w') as fp:
+        os.mkdir(gitdir)
-      fp.write("""[remote "origin"]
+        with open(os.path.join(gitdir, "config"), "w") as fp:
+            fp.write(
+                """[remote "origin"]
        url = https://localhost:0/manifest
-""")
+"""
+            )
-    manifest = self.getXmlManifest("""
+        manifest = self.getXmlManifest(
+            """
 <manifest>
  <remote name="default-remote" fetch="http://localhost" />
  <default remote="default-remote" revision="refs/heads/main" />
  <superproject name="superproject"/>
-  <project path="art" name="platform/art" groups="notdefault,platform-""" + self.platform + """
+  <project path="art" name="platform/art" groups="notdefault,platform-"""
+            + self.platform
+            + """
  " /></manifest>
-""")
+"""
-    self._superproject = git_superproject.Superproject(
+        )
-        manifest, name='superproject',
+        self._superproject = git_superproject.Superproject(
-        remote=manifest.remotes.get('default-remote').ToRemoteSpec('superproject'),
+            manifest,
-        revision='refs/heads/main')
+            name="superproject",
+            remote=manifest.remotes.get("default-remote").ToRemoteSpec(
-  def tearDown(self):
+                "superproject"
-    """Tear down superproject every time."""
+            ),
-    self.tempdirobj.cleanup()
+            revision="refs/heads/main",
+        )
-  def getXmlManifest(self, data):
-    """Helper to initialize a manifest for testing."""
+    def tearDown(self):
-    with open(self.manifest_file, 'w') as fp:
+        """Tear down superproject every time."""
-      fp.write(data)
+        self.tempdirobj.cleanup()
-    return manifest_xml.XmlManifest(self.repodir, self.manifest_file)
+    def getXmlManifest(self, data):
-  def verifyCommonKeys(self, log_entry, expected_event_name, full_sid=True):
+        """Helper to initialize a manifest for testing."""
-    """Helper function to verify common event log keys."""
+        with open(self.manifest_file, "w") as fp:
-    self.assertIn('event', log_entry)
+            fp.write(data)
-    self.assertIn('sid', log_entry)
+        return manifest_xml.XmlManifest(self.repodir, self.manifest_file)
-    self.assertIn('thread', log_entry)
-    self.assertIn('time', log_entry)
+    def verifyCommonKeys(self, log_entry, expected_event_name, full_sid=True):
+        """Helper function to verify common event log keys."""
-    # Do basic data format validation.
+        self.assertIn("event", log_entry)
-    self.assertEqual(expected_event_name, log_entry['event'])
+        self.assertIn("sid", log_entry)
-    if full_sid:
+        self.assertIn("thread", log_entry)
-      self.assertRegex(log_entry['sid'], self.FULL_SID_REGEX)
+        self.assertIn("time", log_entry)
-    else:
-      self.assertRegex(log_entry['sid'], self.SELF_SID_REGEX)
+        # Do basic data format validation.
-    self.assertRegex(log_entry['time'], r'^\d+-\d+-\d+T\d+:\d+:\d+\.\d+Z$')
+        self.assertEqual(expected_event_name, log_entry["event"])
+        if full_sid:
-  def readLog(self, log_path):
+            self.assertRegex(log_entry["sid"], self.FULL_SID_REGEX)
-    """Helper function to read log data into a list."""
+        else:
-    log_data = []
+            self.assertRegex(log_entry["sid"], self.SELF_SID_REGEX)
-    with open(log_path, mode='rb') as f:
+        self.assertRegex(log_entry["time"], r"^\d+-\d+-\d+T\d+:\d+:\d+\.\d+Z$")
-      for line in f:
-        log_data.append(json.loads(line))
+    def readLog(self, log_path):
-    return log_data
+        """Helper function to read log data into a list."""
+        log_data = []
-  def verifyErrorEvent(self):
+        with open(log_path, mode="rb") as f:
-    """Helper to verify that error event is written."""
+            for line in f:
+                log_data.append(json.loads(line))
-    with tempfile.TemporaryDirectory(prefix='event_log_tests') as tempdir:
+        return log_data
-      log_path = self.git_event_log.Write(path=tempdir)
-      self.log_data = self.readLog(log_path)
+    def verifyErrorEvent(self):
+        """Helper to verify that error event is written."""
-    self.assertEqual(len(self.log_data), 2)
-    error_event = self.log_data[1]
+        with tempfile.TemporaryDirectory(prefix="event_log_tests") as tempdir:
-    self.verifyCommonKeys(self.log_data[0], expected_event_name='version')
+            log_path = self.git_event_log.Write(path=tempdir)
-    self.verifyCommonKeys(error_event, expected_event_name='error')
+            self.log_data = self.readLog(log_path)
-    # Check for 'error' event specific fields.
-    self.assertIn('msg', error_event)
+        self.assertEqual(len(self.log_data), 2)
-    self.assertIn('fmt', error_event)
+        error_event = self.log_data[1]
+        self.verifyCommonKeys(self.log_data[0], expected_event_name="version")
-  def test_superproject_get_superproject_no_superproject(self):
+        self.verifyCommonKeys(error_event, expected_event_name="error")
-    """Test with no url."""
+        # Check for 'error' event specific fields.
-    manifest = self.getXmlManifest("""
+        self.assertIn("msg", error_event)
+        self.assertIn("fmt", error_event)
+    def test_superproject_get_superproject_no_superproject(self):
+        """Test with no url."""
+        manifest = self.getXmlManifest(
+            """
 <manifest>
 </manifest>
-""")
+"""
-    self.assertIsNone(manifest.superproject)
+        )
+        self.assertIsNone(manifest.superproject)
-  def test_superproject_get_superproject_invalid_url(self):
-    """Test with an invalid url."""
+    def test_superproject_get_superproject_invalid_url(self):
-    manifest = self.getXmlManifest("""
+        """Test with an invalid url."""
+        manifest = self.getXmlManifest(
+            """
 <manifest>
  <remote name="test-remote" fetch="localhost" />
  <default remote="test-remote" revision="refs/heads/main" />
  <superproject name="superproject"/>
 </manifest>
-""")
+"""
-    superproject = git_superproject.Superproject(
+        )
-        manifest, name='superproject',
+        superproject = git_superproject.Superproject(
-        remote=manifest.remotes.get('test-remote').ToRemoteSpec('superproject'),
+            manifest,
-        revision='refs/heads/main')
+            name="superproject",
-    sync_result = superproject.Sync(self.git_event_log)
+            remote=manifest.remotes.get("test-remote").ToRemoteSpec(
-    self.assertFalse(sync_result.success)
+                "superproject"
-    self.assertTrue(sync_result.fatal)
+            ),
+            revision="refs/heads/main",
-  def test_superproject_get_superproject_invalid_branch(self):
+        )
-    """Test with an invalid branch."""
+        sync_result = superproject.Sync(self.git_event_log)
-    manifest = self.getXmlManifest("""
+        self.assertFalse(sync_result.success)
+        self.assertTrue(sync_result.fatal)
+    def test_superproject_get_superproject_invalid_branch(self):
+        """Test with an invalid branch."""
+        manifest = self.getXmlManifest(
+            """
 <manifest>
  <remote name="test-remote" fetch="localhost" />
  <default remote="test-remote" revision="refs/heads/main" />
  <superproject name="superproject"/>
 </manifest>
-""")
+"""
-    self._superproject = git_superproject.Superproject(
+        )
-        manifest, name='superproject',
+        self._superproject = git_superproject.Superproject(
-        remote=manifest.remotes.get('test-remote').ToRemoteSpec('superproject'),
+            manifest,
-        revision='refs/heads/main')
+            name="superproject",
-    with mock.patch.object(self._superproject, '_branch', 'junk'):
+            remote=manifest.remotes.get("test-remote").ToRemoteSpec(
-      sync_result = self._superproject.Sync(self.git_event_log)
+                "superproject"
-      self.assertFalse(sync_result.success)
+            ),
-      self.assertTrue(sync_result.fatal)
+            revision="refs/heads/main",
-      self.verifyErrorEvent()
+        )
+        with mock.patch.object(self._superproject, "_branch", "junk"):
-  def test_superproject_get_superproject_mock_init(self):
+            sync_result = self._superproject.Sync(self.git_event_log)
-    """Test with _Init failing."""
+            self.assertFalse(sync_result.success)
-    with mock.patch.object(self._superproject, '_Init', return_value=False):
+            self.assertTrue(sync_result.fatal)
-      sync_result = self._superproject.Sync(self.git_event_log)
+            self.verifyErrorEvent()
-      self.assertFalse(sync_result.success)
-      self.assertTrue(sync_result.fatal)
+    def test_superproject_get_superproject_mock_init(self):
+        """Test with _Init failing."""
-  def test_superproject_get_superproject_mock_fetch(self):
+        with mock.patch.object(self._superproject, "_Init", return_value=False):
-    """Test with _Fetch failing."""
+            sync_result = self._superproject.Sync(self.git_event_log)
-    with mock.patch.object(self._superproject, '_Init', return_value=True):
+            self.assertFalse(sync_result.success)
-      os.mkdir(self._superproject._superproject_path)
+            self.assertTrue(sync_result.fatal)
-      with mock.patch.object(self._superproject, '_Fetch', return_value=False):
-        sync_result = self._superproject.Sync(self.git_event_log)
+    def test_superproject_get_superproject_mock_fetch(self):
-        self.assertFalse(sync_result.success)
+        """Test with _Fetch failing."""
-        self.assertTrue(sync_result.fatal)
+        with mock.patch.object(self._superproject, "_Init", return_value=True):
+            os.mkdir(self._superproject._superproject_path)
-  def test_superproject_get_all_project_commit_ids_mock_ls_tree(self):
+            with mock.patch.object(
-    """Test with LsTree being a mock."""
+                self._superproject, "_Fetch", return_value=False
-    data = ('120000 blob 158258bdf146f159218e2b90f8b699c4d85b5804\tAndroid.bp\x00'
+            ):
-            '160000 commit 2c2724cb36cd5a9cec6c852c681efc3b7c6b86ea\tart\x00'
+                sync_result = self._superproject.Sync(self.git_event_log)
-            '160000 commit e9d25da64d8d365dbba7c8ee00fe8c4473fe9a06\tbootable/recovery\x00'
+                self.assertFalse(sync_result.success)
-            '120000 blob acc2cbdf438f9d2141f0ae424cec1d8fc4b5d97f\tbootstrap.bash\x00'
+                self.assertTrue(sync_result.fatal)
-            '160000 commit ade9b7a0d874e25fff4bf2552488825c6f111928\tbuild/bazel\x00')
-    with mock.patch.object(self._superproject, '_Init', return_value=True):
+    def test_superproject_get_all_project_commit_ids_mock_ls_tree(self):
-      with mock.patch.object(self._superproject, '_Fetch', return_value=True):
+        """Test with LsTree being a mock."""
-        with mock.patch.object(self._superproject, '_LsTree', return_value=data):
+        data = (
-          commit_ids_result = self._superproject._GetAllProjectsCommitIds()
+            "120000 blob 158258bdf146f159218e2b90f8b699c4d85b5804\tAndroid.bp\x00"
-          self.assertEqual(commit_ids_result.commit_ids, {
+            "160000 commit 2c2724cb36cd5a9cec6c852c681efc3b7c6b86ea\tart\x00"
-              'art': '2c2724cb36cd5a9cec6c852c681efc3b7c6b86ea',
+            "160000 commit e9d25da64d8d365dbba7c8ee00fe8c4473fe9a06\tbootable/recovery\x00"
-              'bootable/recovery': 'e9d25da64d8d365dbba7c8ee00fe8c4473fe9a06',
+            "120000 blob acc2cbdf438f9d2141f0ae424cec1d8fc4b5d97f\tbootstrap.bash\x00"
-              'build/bazel': 'ade9b7a0d874e25fff4bf2552488825c6f111928'
+            "160000 commit ade9b7a0d874e25fff4bf2552488825c6f111928\tbuild/bazel\x00"
-          })
+        )
-          self.assertFalse(commit_ids_result.fatal)
+        with mock.patch.object(self._superproject, "_Init", return_value=True):
+            with mock.patch.object(
-  def test_superproject_write_manifest_file(self):
+                self._superproject, "_Fetch", return_value=True
-    """Test with writing manifest to a file after setting revisionId."""
+            ):
-    self.assertEqual(len(self._superproject._manifest.projects), 1)
+                with mock.patch.object(
-    project = self._superproject._manifest.projects[0]
+                    self._superproject, "_LsTree", return_value=data
-    project.SetRevisionId('ABCDEF')
+                ):
-    # Create temporary directory so that it can write the file.
+                    commit_ids_result = (
-    os.mkdir(self._superproject._superproject_path)
+                        self._superproject._GetAllProjectsCommitIds()
-    manifest_path = self._superproject._WriteManifestFile()
+                    )
-    self.assertIsNotNone(manifest_path)
+                    self.assertEqual(
-    with open(manifest_path, 'r') as fp:
+                        commit_ids_result.commit_ids,
-      manifest_xml_data = fp.read()
+                        {
-    self.assertEqual(
+                            "art": "2c2724cb36cd5a9cec6c852c681efc3b7c6b86ea",
-        sort_attributes(manifest_xml_data),
+                            "bootable/recovery": "e9d25da64d8d365dbba7c8ee00fe8c4473fe9a06",
-        '<?xml version="1.0" ?><manifest>'
+                            "build/bazel": "ade9b7a0d874e25fff4bf2552488825c6f111928",
-        '<remote fetch="http://localhost" name="default-remote"/>'
+                        },
-        '<default remote="default-remote" revision="refs/heads/main"/>'
+                    )
-        '<project groups="notdefault,platform-' + self.platform + '" '
+                    self.assertFalse(commit_ids_result.fatal)
-        'name="platform/art" path="art" revision="ABCDEF" upstream="refs/heads/main"/>'
-        '<superproject name="superproject"/>'
+    def test_superproject_write_manifest_file(self):
-        '</manifest>')
+        """Test with writing manifest to a file after setting revisionId."""
+        self.assertEqual(len(self._superproject._manifest.projects), 1)
-  def test_superproject_update_project_revision_id(self):
+        project = self._superproject._manifest.projects[0]
-    """Test with LsTree being a mock."""
+        project.SetRevisionId("ABCDEF")
-    self.assertEqual(len(self._superproject._manifest.projects), 1)
+        # Create temporary directory so that it can write the file.
-    projects = self._superproject._manifest.projects
+        os.mkdir(self._superproject._superproject_path)
-    data = ('160000 commit 2c2724cb36cd5a9cec6c852c681efc3b7c6b86ea\tart\x00'
+        manifest_path = self._superproject._WriteManifestFile()
-            '160000 commit e9d25da64d8d365dbba7c8ee00fe8c4473fe9a06\tbootable/recovery\x00')
+        self.assertIsNotNone(manifest_path)
-    with mock.patch.object(self._superproject, '_Init', return_value=True):
+        with open(manifest_path, "r") as fp:
-      with mock.patch.object(self._superproject, '_Fetch', return_value=True):
-        with mock.patch.object(self._superproject,
-                               '_LsTree',
-                               return_value=data):
-          # Create temporary directory so that it can write the file.
-          os.mkdir(self._superproject._superproject_path)
-          update_result = self._superproject.UpdateProjectsRevisionId(projects, self.git_event_log)
-          self.assertIsNotNone(update_result.manifest_path)
-          self.assertFalse(update_result.fatal)
-          with open(update_result.manifest_path, 'r') as fp:
            manifest_xml_data = fp.read()
-          self.assertEqual(
+        self.assertEqual(
-              sort_attributes(manifest_xml_data),
+            sort_attributes(manifest_xml_data),
-              '<?xml version="1.0" ?><manifest>'
+            '<?xml version="1.0" ?><manifest>'
-              '<remote fetch="http://localhost" name="default-remote"/>'
+            '<remote fetch="http://localhost" name="default-remote"/>'
-              '<default remote="default-remote" revision="refs/heads/main"/>'
+            '<default remote="default-remote" revision="refs/heads/main"/>'
-              '<project groups="notdefault,platform-' + self.platform + '" '
+            '<project groups="notdefault,platform-' + self.platform + '" '
-              'name="platform/art" path="art" '
+            'name="platform/art" path="art" revision="ABCDEF" upstream="refs/heads/main"/>'
-              'revision="2c2724cb36cd5a9cec6c852c681efc3b7c6b86ea" upstream="refs/heads/main"/>'
+            '<superproject name="superproject"/>'
-              '<superproject name="superproject"/>'
+            "</manifest>",
-              '</manifest>')
+        )
-  def test_superproject_update_project_revision_id_no_superproject_tag(self):
+    def test_superproject_update_project_revision_id(self):
-    """Test update of commit ids of a manifest without superproject tag."""
+        """Test with LsTree being a mock."""
-    manifest = self.getXmlManifest("""
+        self.assertEqual(len(self._superproject._manifest.projects), 1)
+        projects = self._superproject._manifest.projects
+        data = (
+            "160000 commit 2c2724cb36cd5a9cec6c852c681efc3b7c6b86ea\tart\x00"
+            "160000 commit e9d25da64d8d365dbba7c8ee00fe8c4473fe9a06\tbootable/recovery\x00"
+        )
+        with mock.patch.object(self._superproject, "_Init", return_value=True):
+            with mock.patch.object(
+                self._superproject, "_Fetch", return_value=True
+            ):
+                with mock.patch.object(
+                    self._superproject, "_LsTree", return_value=data
+                ):
+                    # Create temporary directory so that it can write the file.
+                    os.mkdir(self._superproject._superproject_path)
+                    update_result = self._superproject.UpdateProjectsRevisionId(
+                        projects, self.git_event_log
+                    )
+                    self.assertIsNotNone(update_result.manifest_path)
+                    self.assertFalse(update_result.fatal)
+                    with open(update_result.manifest_path, "r") as fp:
+                        manifest_xml_data = fp.read()
+                    self.assertEqual(
+                        sort_attributes(manifest_xml_data),
+                        '<?xml version="1.0" ?><manifest>'
+                        '<remote fetch="http://localhost" name="default-remote"/>'
+                        '<default remote="default-remote" revision="refs/heads/main"/>'
+                        '<project groups="notdefault,platform-'
+                        + self.platform
+                        + '" '
+                        'name="platform/art" path="art" '
+                        'revision="2c2724cb36cd5a9cec6c852c681efc3b7c6b86ea" upstream="refs/heads/main"/>'
+                        '<superproject name="superproject"/>'
+                        "</manifest>",
+                    )
+    def test_superproject_update_project_revision_id_no_superproject_tag(self):
+        """Test update of commit ids of a manifest without superproject tag."""
+        manifest = self.getXmlManifest(
+            """
 <manifest>
  <remote name="default-remote" fetch="http://localhost" />
  <default remote="default-remote" revision="refs/heads/main" />
  <project name="test-name"/>
 </manifest>
-""")
+"""
-    self.maxDiff = None
+        )
-    self.assertIsNone(manifest.superproject)
+        self.maxDiff = None
-    self.assertEqual(
+        self.assertIsNone(manifest.superproject)
-        sort_attributes(manifest.ToXml().toxml()),
+        self.assertEqual(
-        '<?xml version="1.0" ?><manifest>'
+            sort_attributes(manifest.ToXml().toxml()),
-        '<remote fetch="http://localhost" name="default-remote"/>'
+            '<?xml version="1.0" ?><manifest>'
-        '<default remote="default-remote" revision="refs/heads/main"/>'
+            '<remote fetch="http://localhost" name="default-remote"/>'
-        '<project name="test-name"/>'
+            '<default remote="default-remote" revision="refs/heads/main"/>'
-        '</manifest>')
+            '<project name="test-name"/>'
+            "</manifest>",
-  def test_superproject_update_project_revision_id_from_local_manifest_group(self):
+        )
-    """Test update of commit ids of a manifest that have local manifest no superproject group."""
-    local_group = manifest_xml.LOCAL_MANIFEST_GROUP_PREFIX + ':local'
+    def test_superproject_update_project_revision_id_from_local_manifest_group(
-    manifest = self.getXmlManifest("""
+        self,
+    ):
+        """Test update of commit ids of a manifest that have local manifest no superproject group."""
+        local_group = manifest_xml.LOCAL_MANIFEST_GROUP_PREFIX + ":local"
+        manifest = self.getXmlManifest(
+            """
 <manifest>
  <remote name="default-remote" fetch="http://localhost" />
  <remote name="goog" fetch="http://localhost2" />
  <default remote="default-remote" revision="refs/heads/main" />
  <superproject name="superproject"/>
  <project path="vendor/x" name="platform/vendor/x" remote="goog"
-           groups=\"""" + local_group + """
+           groups=\""""
+            + local_group
+            + """
         " revision="master-with-vendor" clone-depth="1" />
-  <project path="art" name="platform/art" groups="notdefault,platform-""" + self.platform + """
+  <project path="art" name="platform/art" groups="notdefault,platform-"""
+            + self.platform
+            + """
  " /></manifest>
-""")
+"""
-    self.maxDiff = None
+        )
-    self._superproject = git_superproject.Superproject(
+        self.maxDiff = None
-        manifest, name='superproject',
+        self._superproject = git_superproject.Superproject(
-        remote=manifest.remotes.get('default-remote').ToRemoteSpec('superproject'),
+            manifest,
-        revision='refs/heads/main')
+            name="superproject",
-    self.assertEqual(len(self._superproject._manifest.projects), 2)
+            remote=manifest.remotes.get("default-remote").ToRemoteSpec(
-    projects = self._superproject._manifest.projects
+                "superproject"
-    data = ('160000 commit 2c2724cb36cd5a9cec6c852c681efc3b7c6b86ea\tart\x00')
+            ),
-    with mock.patch.object(self._superproject, '_Init', return_value=True):
+            revision="refs/heads/main",
-      with mock.patch.object(self._superproject, '_Fetch', return_value=True):
+        )
-        with mock.patch.object(self._superproject,
+        self.assertEqual(len(self._superproject._manifest.projects), 2)
-                               '_LsTree',
+        projects = self._superproject._manifest.projects
-                               return_value=data):
+        data = "160000 commit 2c2724cb36cd5a9cec6c852c681efc3b7c6b86ea\tart\x00"
-          # Create temporary directory so that it can write the file.
+        with mock.patch.object(self._superproject, "_Init", return_value=True):
-          os.mkdir(self._superproject._superproject_path)
+            with mock.patch.object(
-          update_result = self._superproject.UpdateProjectsRevisionId(projects, self.git_event_log)
+                self._superproject, "_Fetch", return_value=True
-          self.assertIsNotNone(update_result.manifest_path)
+            ):
-          self.assertFalse(update_result.fatal)
+                with mock.patch.object(
-          with open(update_result.manifest_path, 'r') as fp:
+                    self._superproject, "_LsTree", return_value=data
-            manifest_xml_data = fp.read()
+                ):
-          # Verify platform/vendor/x's project revision hasn't changed.
+                    # Create temporary directory so that it can write the file.
-          self.assertEqual(
+                    os.mkdir(self._superproject._superproject_path)
-              sort_attributes(manifest_xml_data),
+                    update_result = self._superproject.UpdateProjectsRevisionId(
-              '<?xml version="1.0" ?><manifest>'
+                        projects, self.git_event_log
-              '<remote fetch="http://localhost" name="default-remote"/>'
+                    )
-              '<remote fetch="http://localhost2" name="goog"/>'
+                    self.assertIsNotNone(update_result.manifest_path)
-              '<default remote="default-remote" revision="refs/heads/main"/>'
+                    self.assertFalse(update_result.fatal)
-              '<project groups="notdefault,platform-' + self.platform + '" '
+                    with open(update_result.manifest_path, "r") as fp:
-              'name="platform/art" path="art" '
+                        manifest_xml_data = fp.read()
-              'revision="2c2724cb36cd5a9cec6c852c681efc3b7c6b86ea" upstream="refs/heads/main"/>'
+                    # Verify platform/vendor/x's project revision hasn't
-              '<superproject name="superproject"/>'
+                    # changed.
-              '</manifest>')
+                    self.assertEqual(
+                        sort_attributes(manifest_xml_data),
-  def test_superproject_update_project_revision_id_with_pinned_manifest(self):
+                        '<?xml version="1.0" ?><manifest>'
-    """Test update of commit ids of a pinned manifest."""
+                        '<remote fetch="http://localhost" name="default-remote"/>'
-    manifest = self.getXmlManifest("""
+                        '<remote fetch="http://localhost2" name="goog"/>'
+                        '<default remote="default-remote" revision="refs/heads/main"/>'
+                        '<project groups="notdefault,platform-'
+                        + self.platform
+                        + '" '
+                        'name="platform/art" path="art" '
+                        'revision="2c2724cb36cd5a9cec6c852c681efc3b7c6b86ea" upstream="refs/heads/main"/>'
+                        '<superproject name="superproject"/>'
+                        "</manifest>",
+                    )
+    def test_superproject_update_project_revision_id_with_pinned_manifest(self):
+        """Test update of commit ids of a pinned manifest."""
+        manifest = self.getXmlManifest(
+            """
 <manifest>
  <remote name="default-remote" fetch="http://localhost" />
  <default remote="default-remote" revision="refs/heads/main" />
@@ -326,80 +398,132 @@ class SuperprojectTestCase(unittest.TestCase):
  <project path="vendor/x" name="platform/vendor/x" revision="" />
  <project path="vendor/y" name="platform/vendor/y"
           revision="52d3c9f7c107839ece2319d077de0cd922aa9d8f" />
-  <project path="art" name="platform/art" groups="notdefault,platform-""" + self.platform + """
+  <project path="art" name="platform/art" groups="notdefault,platform-"""
+            + self.platform
+            + """
  " /></manifest>
-""")
+"""
-    self.maxDiff = None
+        )
-    self._superproject = git_superproject.Superproject(
+        self.maxDiff = None
-        manifest, name='superproject',
+        self._superproject = git_superproject.Superproject(
-        remote=manifest.remotes.get('default-remote').ToRemoteSpec('superproject'),
+            manifest,
-        revision='refs/heads/main')
+            name="superproject",
-    self.assertEqual(len(self._superproject._manifest.projects), 3)
+            remote=manifest.remotes.get("default-remote").ToRemoteSpec(
-    projects = self._superproject._manifest.projects
+                "superproject"
-    data = ('160000 commit 2c2724cb36cd5a9cec6c852c681efc3b7c6b86ea\tart\x00'
+            ),
-            '160000 commit e9d25da64d8d365dbba7c8ee00fe8c4473fe9a06\tvendor/x\x00')
+            revision="refs/heads/main",
-    with mock.patch.object(self._superproject, '_Init', return_value=True):
+        )
-      with mock.patch.object(self._superproject, '_Fetch', return_value=True):
+        self.assertEqual(len(self._superproject._manifest.projects), 3)
-        with mock.patch.object(self._superproject,
+        projects = self._superproject._manifest.projects
-                               '_LsTree',
+        data = (
-                               return_value=data):
+            "160000 commit 2c2724cb36cd5a9cec6c852c681efc3b7c6b86ea\tart\x00"
-          # Create temporary directory so that it can write the file.
+            "160000 commit e9d25da64d8d365dbba7c8ee00fe8c4473fe9a06\tvendor/x\x00"
-          os.mkdir(self._superproject._superproject_path)
+        )
-          update_result = self._superproject.UpdateProjectsRevisionId(projects, self.git_event_log)
+        with mock.patch.object(self._superproject, "_Init", return_value=True):
-          self.assertIsNotNone(update_result.manifest_path)
+            with mock.patch.object(
-          self.assertFalse(update_result.fatal)
+                self._superproject, "_Fetch", return_value=True
-          with open(update_result.manifest_path, 'r') as fp:
+            ):
-            manifest_xml_data = fp.read()
+                with mock.patch.object(
-          # Verify platform/vendor/x's project revision hasn't changed.
+                    self._superproject, "_LsTree", return_value=data
-          self.assertEqual(
+                ):
-              sort_attributes(manifest_xml_data),
+                    # Create temporary directory so that it can write the file.
-              '<?xml version="1.0" ?><manifest>'
+                    os.mkdir(self._superproject._superproject_path)
-              '<remote fetch="http://localhost" name="default-remote"/>'
+                    update_result = self._superproject.UpdateProjectsRevisionId(
-              '<default remote="default-remote" revision="refs/heads/main"/>'
+                        projects, self.git_event_log
-              '<project groups="notdefault,platform-' + self.platform + '" '
+                    )
-              'name="platform/art" path="art" '
+                    self.assertIsNotNone(update_result.manifest_path)
-              'revision="2c2724cb36cd5a9cec6c852c681efc3b7c6b86ea" upstream="refs/heads/main"/>'
+                    self.assertFalse(update_result.fatal)
-              '<project name="platform/vendor/x" path="vendor/x" '
+                    with open(update_result.manifest_path, "r") as fp:
-              'revision="e9d25da64d8d365dbba7c8ee00fe8c4473fe9a06" upstream="refs/heads/main"/>'
+                        manifest_xml_data = fp.read()
-              '<project name="platform/vendor/y" path="vendor/y" '
+                    # Verify platform/vendor/x's project revision hasn't
-              'revision="52d3c9f7c107839ece2319d077de0cd922aa9d8f"/>'
+                    # changed.
-              '<superproject name="superproject"/>'
+                    self.assertEqual(
-              '</manifest>')
+                        sort_attributes(manifest_xml_data),
+                        '<?xml version="1.0" ?><manifest>'
-  def test_Fetch(self):
+                        '<remote fetch="http://localhost" name="default-remote"/>'
-    manifest = self.getXmlManifest("""
+                        '<default remote="default-remote" revision="refs/heads/main"/>'
+                        '<project groups="notdefault,platform-'
+                        + self.platform
+                        + '" '
+                        'name="platform/art" path="art" '
+                        'revision="2c2724cb36cd5a9cec6c852c681efc3b7c6b86ea" upstream="refs/heads/main"/>'
+                        '<project name="platform/vendor/x" path="vendor/x" '
+                        'revision="e9d25da64d8d365dbba7c8ee00fe8c4473fe9a06" upstream="refs/heads/main"/>'
+                        '<project name="platform/vendor/y" path="vendor/y" '
+                        'revision="52d3c9f7c107839ece2319d077de0cd922aa9d8f"/>'
+                        '<superproject name="superproject"/>'
+                        "</manifest>",
+                    )
+    def test_Fetch(self):
+        manifest = self.getXmlManifest(
+            """
 <manifest>
  <remote name="default-remote" fetch="http://localhost" />
  <default remote="default-remote" revision="refs/heads/main" />
  <superproject name="superproject"/>
  " /></manifest>
-""")
+"""
-    self.maxDiff = None
+        )
-    self._superproject = git_superproject.Superproject(
+        self.maxDiff = None
-        manifest, name='superproject',
+        self._superproject = git_superproject.Superproject(
-        remote=manifest.remotes.get('default-remote').ToRemoteSpec('superproject'),
+            manifest,
-        revision='refs/heads/main')
+            name="superproject",
-    os.mkdir(self._superproject._superproject_path)
+            remote=manifest.remotes.get("default-remote").ToRemoteSpec(
-    os.mkdir(self._superproject._work_git)
+                "superproject"
-    with mock.patch.object(self._superproject, '_Init', return_value=True):
+            ),
-      with mock.patch('git_superproject.GitCommand', autospec=True) as mock_git_command:
+            revision="refs/heads/main",
-        with mock.patch('git_superproject.GitRefs.get', autospec=True) as mock_git_refs:
+        )
-          instance = mock_git_command.return_value
+        os.mkdir(self._superproject._superproject_path)
-          instance.Wait.return_value = 0
+        os.mkdir(self._superproject._work_git)
-          mock_git_refs.side_effect = ['', '1234']
+        with mock.patch.object(self._superproject, "_Init", return_value=True):
+            with mock.patch(
-          self.assertTrue(self._superproject._Fetch())
+                "git_superproject.GitCommand", autospec=True
-          self.assertEqual(mock_git_command.call_args.args,(None, [
+            ) as mock_git_command:
-              'fetch', 'http://localhost/superproject', '--depth', '1',
+                with mock.patch(
-              '--force', '--no-tags', '--filter', 'blob:none',
+                    "git_superproject.GitRefs.get", autospec=True
-              'refs/heads/main:refs/heads/main'
+                ) as mock_git_refs:
-          ]))
+                    instance = mock_git_command.return_value
+                    instance.Wait.return_value = 0
-          # If branch for revision exists, set as --negotiation-tip.
+                    mock_git_refs.side_effect = ["", "1234"]
-          self.assertTrue(self._superproject._Fetch())
-          self.assertEqual(mock_git_command.call_args.args,(None, [
+                    self.assertTrue(self._superproject._Fetch())
-              'fetch', 'http://localhost/superproject', '--depth', '1',
+                    self.assertEqual(
-              '--force', '--no-tags', '--filter', 'blob:none',
+                        mock_git_command.call_args.args,
-              '--negotiation-tip', '1234',
+                        (
-              'refs/heads/main:refs/heads/main'
+                            None,
-          ]))
+                            [
+                                "fetch",
+                                "http://localhost/superproject",
+                                "--depth",
+                                "1",
+                                "--force",
+                                "--no-tags",
+                                "--filter",
+                                "blob:none",
+                                "refs/heads/main:refs/heads/main",
+                            ],
+                        ),
+                    )
+                    # If branch for revision exists, set as --negotiation-tip.
+                    self.assertTrue(self._superproject._Fetch())
+                    self.assertEqual(
+                        mock_git_command.call_args.args,
+                        (
+                            None,
+                            [
+                                "fetch",
+                                "http://localhost/superproject",
+                                "--depth",
+                                "1",
+                                "--force",
+                                "--no-tags",
+                                "--filter",
+                                "blob:none",
+                                "--negotiation-tip",
+                                "1234",
+                                "refs/heads/main:refs/heads/main",
+                            ],
+                        ),
+                    )
diff --git a/tests/test_git_trace2_event_log.py b/tests/test_git_trace2_event_log.py
index 7e7dfb7a..a6078d38 100644
--- a/tests/test_git_trace2_event_log.py
+++ b/tests/test_git_trace2_event_log.py
@@ -27,361 +27,382 @@ import platform_utils
 def serverLoggingThread(socket_path, server_ready, received_traces):
-  """Helper function to receive logs over a Unix domain socket.
+    """Helper function to receive logs over a Unix domain socket.
-  Appends received messages on the provided socket and appends to received_traces.
-  Args:
-    socket_path: path to a Unix domain socket on which to listen for traces
-    server_ready: a threading.Condition used to signal to the caller that this thread is ready to
-        accept connections
-    received_traces: a list to which received traces will be appended (after decoding to a utf-8
-        string).
-  """
-  platform_utils.remove(socket_path, missing_ok=True)
-  data = b''
-  with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as sock:
-    sock.bind(socket_path)
-    sock.listen(0)
-    with server_ready:
-      server_ready.notify()
-    with sock.accept()[0] as conn:
-      while True:
-        recved = conn.recv(4096)
-        if not recved:
-          break
-        data += recved
-  received_traces.extend(data.decode('utf-8').splitlines())
+    Appends received messages on the provided socket and appends to
+    received_traces.
-class EventLogTestCase(unittest.TestCase):
+    Args:
-  """TestCase for the EventLog module."""
+        socket_path: path to a Unix domain socket on which to listen for traces
+        server_ready: a threading.Condition used to signal to the caller that
-  PARENT_SID_KEY = 'GIT_TRACE2_PARENT_SID'
+            this thread is ready to accept connections
-  PARENT_SID_VALUE = 'parent_sid'
+        received_traces: a list to which received traces will be appended (after
-  SELF_SID_REGEX = r'repo-\d+T\d+Z-.*'
+            decoding to a utf-8 string).
-  FULL_SID_REGEX = r'^%s/%s' % (PARENT_SID_VALUE, SELF_SID_REGEX)
-  def setUp(self):
-    """Load the event_log module every time."""
-    self._event_log_module = None
-    # By default we initialize with the expected case where
-    # repo launches us (so GIT_TRACE2_PARENT_SID is set).
-    env = {
-        self.PARENT_SID_KEY: self.PARENT_SID_VALUE,
-    }
-    self._event_log_module = git_trace2_event_log.EventLog(env=env)
-    self._log_data = None
-  def verifyCommonKeys(self, log_entry, expected_event_name=None, full_sid=True):
-    """Helper function to verify common event log keys."""
-    self.assertIn('event', log_entry)
-    self.assertIn('sid', log_entry)
-    self.assertIn('thread', log_entry)
-    self.assertIn('time', log_entry)
-    # Do basic data format validation.
-    if expected_event_name:
-      self.assertEqual(expected_event_name, log_entry['event'])
-    if full_sid:
-      self.assertRegex(log_entry['sid'], self.FULL_SID_REGEX)
-    else:
-      self.assertRegex(log_entry['sid'], self.SELF_SID_REGEX)
-    self.assertRegex(log_entry['time'], r'^\d+-\d+-\d+T\d+:\d+:\d+\.\d+Z$')
-  def readLog(self, log_path):
-    """Helper function to read log data into a list."""
-    log_data = []
-    with open(log_path, mode='rb') as f:
-      for line in f:
-        log_data.append(json.loads(line))
-    return log_data
-  def remove_prefix(self, s, prefix):
-    """Return a copy string after removing |prefix| from |s|, if present or the original string."""
-    if s.startswith(prefix):
-        return s[len(prefix):]
-    else:
-        return s
-  def test_initial_state_with_parent_sid(self):
-    """Test initial state when 'GIT_TRACE2_PARENT_SID' is set by parent."""
-    self.assertRegex(self._event_log_module.full_sid, self.FULL_SID_REGEX)
-  def test_initial_state_no_parent_sid(self):
-    """Test initial state when 'GIT_TRACE2_PARENT_SID' is not set."""
-    # Setup an empty environment dict (no parent sid).
-    self._event_log_module = git_trace2_event_log.EventLog(env={})
-    self.assertRegex(self._event_log_module.full_sid, self.SELF_SID_REGEX)
-  def test_version_event(self):
-    """Test 'version' event data is valid.
-    Verify that the 'version' event is written even when no other
-    events are addded.
-    Expected event log:
-    <version event>
-    """
-    with tempfile.TemporaryDirectory(prefix='event_log_tests') as tempdir:
-      log_path = self._event_log_module.Write(path=tempdir)
-      self._log_data = self.readLog(log_path)
-    # A log with no added events should only have the version entry.
-    self.assertEqual(len(self._log_data), 1)
-    version_event = self._log_data[0]
-    self.verifyCommonKeys(version_event, expected_event_name='version')
-    # Check for 'version' event specific fields.
-    self.assertIn('evt', version_event)
-    self.assertIn('exe', version_event)
-    # Verify "evt" version field is a string.
-    self.assertIsInstance(version_event['evt'], str)
-  def test_start_event(self):
-    """Test and validate 'start' event data is valid.
-    Expected event log:
-    <version event>
-    <start event>
-    """
-    self._event_log_module.StartEvent()
-    with tempfile.TemporaryDirectory(prefix='event_log_tests') as tempdir:
-      log_path = self._event_log_module.Write(path=tempdir)
-      self._log_data = self.readLog(log_path)
-    self.assertEqual(len(self._log_data), 2)
-    start_event = self._log_data[1]
-    self.verifyCommonKeys(self._log_data[0], expected_event_name='version')
-    self.verifyCommonKeys(start_event, expected_event_name='start')
-    # Check for 'start' event specific fields.
-    self.assertIn('argv', start_event)
-    self.assertTrue(isinstance(start_event['argv'], list))
-  def test_exit_event_result_none(self):
-    """Test 'exit' event data is valid when result is None.
-    We expect None result to be converted to 0 in the exit event data.
-    Expected event log:
-    <version event>
-    <exit event>
-    """
-    self._event_log_module.ExitEvent(None)
-    with tempfile.TemporaryDirectory(prefix='event_log_tests') as tempdir:
-      log_path = self._event_log_module.Write(path=tempdir)
-      self._log_data = self.readLog(log_path)
-    self.assertEqual(len(self._log_data), 2)
-    exit_event = self._log_data[1]
-    self.verifyCommonKeys(self._log_data[0], expected_event_name='version')
-    self.verifyCommonKeys(exit_event, expected_event_name='exit')
-    # Check for 'exit' event specific fields.
-    self.assertIn('code', exit_event)
-    # 'None' result should convert to 0 (successful) return code.
-    self.assertEqual(exit_event['code'], 0)
-  def test_exit_event_result_integer(self):
-    """Test 'exit' event data is valid when result is an integer.
-    Expected event log:
-    <version event>
-    <exit event>
-    """
-    self._event_log_module.ExitEvent(2)
-    with tempfile.TemporaryDirectory(prefix='event_log_tests') as tempdir:
-      log_path = self._event_log_module.Write(path=tempdir)
-      self._log_data = self.readLog(log_path)
-    self.assertEqual(len(self._log_data), 2)
-    exit_event = self._log_data[1]
-    self.verifyCommonKeys(self._log_data[0], expected_event_name='version')
-    self.verifyCommonKeys(exit_event, expected_event_name='exit')
-    # Check for 'exit' event specific fields.
-    self.assertIn('code', exit_event)
-    self.assertEqual(exit_event['code'], 2)
-  def test_command_event(self):
-    """Test and validate 'command' event data is valid.
-    Expected event log:
-    <version event>
-    <command event>
-    """
-    name = 'repo'
-    subcommands = ['init' 'this']
-    self._event_log_module.CommandEvent(name='repo', subcommands=subcommands)
-    with tempfile.TemporaryDirectory(prefix='event_log_tests') as tempdir:
-      log_path = self._event_log_module.Write(path=tempdir)
-      self._log_data = self.readLog(log_path)
-    self.assertEqual(len(self._log_data), 2)
-    command_event = self._log_data[1]
-    self.verifyCommonKeys(self._log_data[0], expected_event_name='version')
-    self.verifyCommonKeys(command_event, expected_event_name='command')
-    # Check for 'command' event specific fields.
-    self.assertIn('name', command_event)
-    self.assertIn('subcommands', command_event)
-    self.assertEqual(command_event['name'], name)
-    self.assertEqual(command_event['subcommands'], subcommands)
-  def test_def_params_event_repo_config(self):
-    """Test 'def_params' event data outputs only repo config keys.
-    Expected event log:
-    <version event>
-    <def_param event>
-    <def_param event>
    """
-    config = {
+    platform_utils.remove(socket_path, missing_ok=True)
-        'git.foo': 'bar',
+    data = b""
-        'repo.partialclone': 'true',
+    with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as sock:
-        'repo.partialclonefilter': 'blob:none',
+        sock.bind(socket_path)
-    }
+        sock.listen(0)
-    self._event_log_module.DefParamRepoEvents(config)
-    with tempfile.TemporaryDirectory(prefix='event_log_tests') as tempdir:
-      log_path = self._event_log_module.Write(path=tempdir)
-      self._log_data = self.readLog(log_path)
-    self.assertEqual(len(self._log_data), 3)
-    def_param_events = self._log_data[1:]
-    self.verifyCommonKeys(self._log_data[0], expected_event_name='version')
-    for event in def_param_events:
-      self.verifyCommonKeys(event, expected_event_name='def_param')
-      # Check for 'def_param' event specific fields.
-      self.assertIn('param', event)
-      self.assertIn('value', event)
-      self.assertTrue(event['param'].startswith('repo.'))
-  def test_def_params_event_no_repo_config(self):
-    """Test 'def_params' event data won't output non-repo config keys.
-    Expected event log:
-    <version event>
-    """
-    config = {
-        'git.foo': 'bar',
-        'git.core.foo2': 'baz',
-    }
-    self._event_log_module.DefParamRepoEvents(config)
-    with tempfile.TemporaryDirectory(prefix='event_log_tests') as tempdir:
-      log_path = self._event_log_module.Write(path=tempdir)
-      self._log_data = self.readLog(log_path)
-    self.assertEqual(len(self._log_data), 1)
-    self.verifyCommonKeys(self._log_data[0], expected_event_name='version')
-  def test_data_event_config(self):
-    """Test 'data' event data outputs all config keys.
-    Expected event log:
-    <version event>
-    <data event>
-    <data event>
-    """
-    config = {
-        'git.foo': 'bar',
-        'repo.partialclone': 'false',
-        'repo.syncstate.superproject.hassuperprojecttag': 'true',
-        'repo.syncstate.superproject.sys.argv': ['--', 'sync', 'protobuf'],
-    }
-    prefix_value = 'prefix'
-    self._event_log_module.LogDataConfigEvents(config, prefix_value)
-    with tempfile.TemporaryDirectory(prefix='event_log_tests') as tempdir:
-      log_path = self._event_log_module.Write(path=tempdir)
-      self._log_data = self.readLog(log_path)
-    self.assertEqual(len(self._log_data), 5)
-    data_events = self._log_data[1:]
-    self.verifyCommonKeys(self._log_data[0], expected_event_name='version')
-    for event in data_events:
-      self.verifyCommonKeys(event)
-      # Check for 'data' event specific fields.
-      self.assertIn('key', event)
-      self.assertIn('value', event)
-      key = event['key']
-      key = self.remove_prefix(key, f'{prefix_value}/')
-      value = event['value']
-      self.assertEqual(self._event_log_module.GetDataEventName(value), event['event'])
-      self.assertTrue(key in config and value == config[key])
-  def test_error_event(self):
-    """Test and validate 'error' event data is valid.
-    Expected event log:
-    <version event>
-    <error event>
-    """
-    msg = 'invalid option: --cahced'
-    fmt = 'invalid option: %s'
-    self._event_log_module.ErrorEvent(msg, fmt)
-    with tempfile.TemporaryDirectory(prefix='event_log_tests') as tempdir:
-      log_path = self._event_log_module.Write(path=tempdir)
-      self._log_data = self.readLog(log_path)
-    self.assertEqual(len(self._log_data), 2)
-    error_event = self._log_data[1]
-    self.verifyCommonKeys(self._log_data[0], expected_event_name='version')
-    self.verifyCommonKeys(error_event, expected_event_name='error')
-    # Check for 'error' event specific fields.
-    self.assertIn('msg', error_event)
-    self.assertIn('fmt', error_event)
-    self.assertEqual(error_event['msg'], msg)
-    self.assertEqual(error_event['fmt'], fmt)
-  def test_write_with_filename(self):
-    """Test Write() with a path to a file exits with None."""
-    self.assertIsNone(self._event_log_module.Write(path='path/to/file'))
-  def test_write_with_git_config(self):
-    """Test Write() uses the git config path when 'git config' call succeeds."""
-    with tempfile.TemporaryDirectory(prefix='event_log_tests') as tempdir:
-      with mock.patch.object(self._event_log_module,
-                             '_GetEventTargetPath', return_value=tempdir):
-        self.assertEqual(os.path.dirname(self._event_log_module.Write()), tempdir)
-  def test_write_no_git_config(self):
-    """Test Write() with no git config variable present exits with None."""
-    with mock.patch.object(self._event_log_module,
-                           '_GetEventTargetPath', return_value=None):
-      self.assertIsNone(self._event_log_module.Write())
-  def test_write_non_string(self):
-    """Test Write() with non-string type for |path| throws TypeError."""
-    with self.assertRaises(TypeError):
-      self._event_log_module.Write(path=1234)
-  def test_write_socket(self):
-    """Test Write() with Unix domain socket for |path| and validate received traces."""
-    received_traces = []
-    with tempfile.TemporaryDirectory(prefix='test_server_sockets') as tempdir:
-      socket_path = os.path.join(tempdir, "server.sock")
-      server_ready = threading.Condition()
-      # Start "server" listening on Unix domain socket at socket_path.
-      try:
-        server_thread = threading.Thread(
-            target=serverLoggingThread,
-            args=(socket_path, server_ready, received_traces))
-        server_thread.start()
        with server_ready:
-          server_ready.wait(timeout=120)
+            server_ready.notify()
+        with sock.accept()[0] as conn:
+            while True:
+                recved = conn.recv(4096)
+                if not recved:
+                    break
+                data += recved
+    received_traces.extend(data.decode("utf-8").splitlines())
+class EventLogTestCase(unittest.TestCase):
+    """TestCase for the EventLog module."""
+    PARENT_SID_KEY = "GIT_TRACE2_PARENT_SID"
+    PARENT_SID_VALUE = "parent_sid"
+    SELF_SID_REGEX = r"repo-\d+T\d+Z-.*"
+    FULL_SID_REGEX = r"^%s/%s" % (PARENT_SID_VALUE, SELF_SID_REGEX)
+    def setUp(self):
+        """Load the event_log module every time."""
+        self._event_log_module = None
+        # By default we initialize with the expected case where
+        # repo launches us (so GIT_TRACE2_PARENT_SID is set).
+        env = {
+            self.PARENT_SID_KEY: self.PARENT_SID_VALUE,
+        }
+        self._event_log_module = git_trace2_event_log.EventLog(env=env)
+        self._log_data = None
+    def verifyCommonKeys(
+        self, log_entry, expected_event_name=None, full_sid=True
+    ):
+        """Helper function to verify common event log keys."""
+        self.assertIn("event", log_entry)
+        self.assertIn("sid", log_entry)
+        self.assertIn("thread", log_entry)
+        self.assertIn("time", log_entry)
+        # Do basic data format validation.
+        if expected_event_name:
+            self.assertEqual(expected_event_name, log_entry["event"])
+        if full_sid:
+            self.assertRegex(log_entry["sid"], self.FULL_SID_REGEX)
+        else:
+            self.assertRegex(log_entry["sid"], self.SELF_SID_REGEX)
+        self.assertRegex(log_entry["time"], r"^\d+-\d+-\d+T\d+:\d+:\d+\.\d+Z$")
+    def readLog(self, log_path):
+        """Helper function to read log data into a list."""
+        log_data = []
+        with open(log_path, mode="rb") as f:
+            for line in f:
+                log_data.append(json.loads(line))
+        return log_data
+    def remove_prefix(self, s, prefix):
+        """Return a copy string after removing |prefix| from |s|, if present or
+        the original string."""
+        if s.startswith(prefix):
+            return s[len(prefix) :]
+        else:
+            return s
+    def test_initial_state_with_parent_sid(self):
+        """Test initial state when 'GIT_TRACE2_PARENT_SID' is set by parent."""
+        self.assertRegex(self._event_log_module.full_sid, self.FULL_SID_REGEX)
+    def test_initial_state_no_parent_sid(self):
+        """Test initial state when 'GIT_TRACE2_PARENT_SID' is not set."""
+        # Setup an empty environment dict (no parent sid).
+        self._event_log_module = git_trace2_event_log.EventLog(env={})
+        self.assertRegex(self._event_log_module.full_sid, self.SELF_SID_REGEX)
+    def test_version_event(self):
+        """Test 'version' event data is valid.
+        Verify that the 'version' event is written even when no other
+        events are addded.
+        Expected event log:
+        <version event>
+        """
+        with tempfile.TemporaryDirectory(prefix="event_log_tests") as tempdir:
+            log_path = self._event_log_module.Write(path=tempdir)
+            self._log_data = self.readLog(log_path)
+        # A log with no added events should only have the version entry.
+        self.assertEqual(len(self._log_data), 1)
+        version_event = self._log_data[0]
+        self.verifyCommonKeys(version_event, expected_event_name="version")
+        # Check for 'version' event specific fields.
+        self.assertIn("evt", version_event)
+        self.assertIn("exe", version_event)
+        # Verify "evt" version field is a string.
+        self.assertIsInstance(version_event["evt"], str)
+    def test_start_event(self):
+        """Test and validate 'start' event data is valid.
+        Expected event log:
+        <version event>
+        <start event>
+        """
        self._event_log_module.StartEvent()
-        path = self._event_log_module.Write(path=f'af_unix:{socket_path}')
+        with tempfile.TemporaryDirectory(prefix="event_log_tests") as tempdir:
-      finally:
+            log_path = self._event_log_module.Write(path=tempdir)
-        server_thread.join(timeout=5)
+            self._log_data = self.readLog(log_path)
-    self.assertEqual(path, f'af_unix:stream:{socket_path}')
+        self.assertEqual(len(self._log_data), 2)
-    self.assertEqual(len(received_traces), 2)
+        start_event = self._log_data[1]
-    version_event = json.loads(received_traces[0])
+        self.verifyCommonKeys(self._log_data[0], expected_event_name="version")
-    start_event = json.loads(received_traces[1])
+        self.verifyCommonKeys(start_event, expected_event_name="start")
-    self.verifyCommonKeys(version_event, expected_event_name='version')
+        # Check for 'start' event specific fields.
-    self.verifyCommonKeys(start_event, expected_event_name='start')
+        self.assertIn("argv", start_event)
-    # Check for 'start' event specific fields.
+        self.assertTrue(isinstance(start_event["argv"], list))
-    self.assertIn('argv', start_event)
-    self.assertIsInstance(start_event['argv'], list)
+    def test_exit_event_result_none(self):
+        """Test 'exit' event data is valid when result is None.
+        We expect None result to be converted to 0 in the exit event data.
+        Expected event log:
+        <version event>
+        <exit event>
+        """
+        self._event_log_module.ExitEvent(None)
+        with tempfile.TemporaryDirectory(prefix="event_log_tests") as tempdir:
+            log_path = self._event_log_module.Write(path=tempdir)
+            self._log_data = self.readLog(log_path)
+        self.assertEqual(len(self._log_data), 2)
+        exit_event = self._log_data[1]
+        self.verifyCommonKeys(self._log_data[0], expected_event_name="version")
+        self.verifyCommonKeys(exit_event, expected_event_name="exit")
+        # Check for 'exit' event specific fields.
+        self.assertIn("code", exit_event)
+        # 'None' result should convert to 0 (successful) return code.
+        self.assertEqual(exit_event["code"], 0)
+    def test_exit_event_result_integer(self):
+        """Test 'exit' event data is valid when result is an integer.
+        Expected event log:
+        <version event>
+        <exit event>
+        """
+        self._event_log_module.ExitEvent(2)
+        with tempfile.TemporaryDirectory(prefix="event_log_tests") as tempdir:
+            log_path = self._event_log_module.Write(path=tempdir)
+            self._log_data = self.readLog(log_path)
+        self.assertEqual(len(self._log_data), 2)
+        exit_event = self._log_data[1]
+        self.verifyCommonKeys(self._log_data[0], expected_event_name="version")
+        self.verifyCommonKeys(exit_event, expected_event_name="exit")
+        # Check for 'exit' event specific fields.
+        self.assertIn("code", exit_event)
+        self.assertEqual(exit_event["code"], 2)
+    def test_command_event(self):
+        """Test and validate 'command' event data is valid.
+        Expected event log:
+        <version event>
+        <command event>
+        """
+        name = "repo"
+        subcommands = ["init" "this"]
+        self._event_log_module.CommandEvent(
+            name="repo", subcommands=subcommands
+        )
+        with tempfile.TemporaryDirectory(prefix="event_log_tests") as tempdir:
+            log_path = self._event_log_module.Write(path=tempdir)
+            self._log_data = self.readLog(log_path)
+        self.assertEqual(len(self._log_data), 2)
+        command_event = self._log_data[1]
+        self.verifyCommonKeys(self._log_data[0], expected_event_name="version")
+        self.verifyCommonKeys(command_event, expected_event_name="command")
+        # Check for 'command' event specific fields.
+        self.assertIn("name", command_event)
+        self.assertIn("subcommands", command_event)
+        self.assertEqual(command_event["name"], name)
+        self.assertEqual(command_event["subcommands"], subcommands)
+    def test_def_params_event_repo_config(self):
+        """Test 'def_params' event data outputs only repo config keys.
+        Expected event log:
+        <version event>
+        <def_param event>
+        <def_param event>
+        """
+        config = {
+            "git.foo": "bar",
+            "repo.partialclone": "true",
+            "repo.partialclonefilter": "blob:none",
+        }
+        self._event_log_module.DefParamRepoEvents(config)
+        with tempfile.TemporaryDirectory(prefix="event_log_tests") as tempdir:
+            log_path = self._event_log_module.Write(path=tempdir)
+            self._log_data = self.readLog(log_path)
+        self.assertEqual(len(self._log_data), 3)
+        def_param_events = self._log_data[1:]
+        self.verifyCommonKeys(self._log_data[0], expected_event_name="version")
+        for event in def_param_events:
+            self.verifyCommonKeys(event, expected_event_name="def_param")
+            # Check for 'def_param' event specific fields.
+            self.assertIn("param", event)
+            self.assertIn("value", event)
+            self.assertTrue(event["param"].startswith("repo."))
+    def test_def_params_event_no_repo_config(self):
+        """Test 'def_params' event data won't output non-repo config keys.
+        Expected event log:
+        <version event>
+        """
+        config = {
+            "git.foo": "bar",
+            "git.core.foo2": "baz",
+        }
+        self._event_log_module.DefParamRepoEvents(config)
+        with tempfile.TemporaryDirectory(prefix="event_log_tests") as tempdir:
+            log_path = self._event_log_module.Write(path=tempdir)
+            self._log_data = self.readLog(log_path)
+        self.assertEqual(len(self._log_data), 1)
+        self.verifyCommonKeys(self._log_data[0], expected_event_name="version")
+    def test_data_event_config(self):
+        """Test 'data' event data outputs all config keys.
+        Expected event log:
+        <version event>
+        <data event>
+        <data event>
+        """
+        config = {
+            "git.foo": "bar",
+            "repo.partialclone": "false",
+            "repo.syncstate.superproject.hassuperprojecttag": "true",
+            "repo.syncstate.superproject.sys.argv": ["--", "sync", "protobuf"],
+        }
+        prefix_value = "prefix"
+        self._event_log_module.LogDataConfigEvents(config, prefix_value)
+        with tempfile.TemporaryDirectory(prefix="event_log_tests") as tempdir:
+            log_path = self._event_log_module.Write(path=tempdir)
+            self._log_data = self.readLog(log_path)
+        self.assertEqual(len(self._log_data), 5)
+        data_events = self._log_data[1:]
+        self.verifyCommonKeys(self._log_data[0], expected_event_name="version")
+        for event in data_events:
+            self.verifyCommonKeys(event)
+            # Check for 'data' event specific fields.
+            self.assertIn("key", event)
+            self.assertIn("value", event)
+            key = event["key"]
+            key = self.remove_prefix(key, f"{prefix_value}/")
+            value = event["value"]
+            self.assertEqual(
+                self._event_log_module.GetDataEventName(value), event["event"]
+            )
+            self.assertTrue(key in config and value == config[key])
+    def test_error_event(self):
+        """Test and validate 'error' event data is valid.
+        Expected event log:
+        <version event>
+        <error event>
+        """
+        msg = "invalid option: --cahced"
+        fmt = "invalid option: %s"
+        self._event_log_module.ErrorEvent(msg, fmt)
+        with tempfile.TemporaryDirectory(prefix="event_log_tests") as tempdir:
+            log_path = self._event_log_module.Write(path=tempdir)
+            self._log_data = self.readLog(log_path)
+        self.assertEqual(len(self._log_data), 2)
+        error_event = self._log_data[1]
+        self.verifyCommonKeys(self._log_data[0], expected_event_name="version")
+        self.verifyCommonKeys(error_event, expected_event_name="error")
+        # Check for 'error' event specific fields.
+        self.assertIn("msg", error_event)
+        self.assertIn("fmt", error_event)
+        self.assertEqual(error_event["msg"], msg)
+        self.assertEqual(error_event["fmt"], fmt)
+    def test_write_with_filename(self):
+        """Test Write() with a path to a file exits with None."""
+        self.assertIsNone(self._event_log_module.Write(path="path/to/file"))
+    def test_write_with_git_config(self):
+        """Test Write() uses the git config path when 'git config' call
+        succeeds."""
+        with tempfile.TemporaryDirectory(prefix="event_log_tests") as tempdir:
+            with mock.patch.object(
+                self._event_log_module,
+                "_GetEventTargetPath",
+                return_value=tempdir,
+            ):
+                self.assertEqual(
+                    os.path.dirname(self._event_log_module.Write()), tempdir
+                )
+    def test_write_no_git_config(self):
+        """Test Write() with no git config variable present exits with None."""
+        with mock.patch.object(
+            self._event_log_module, "_GetEventTargetPath", return_value=None
+        ):
+            self.assertIsNone(self._event_log_module.Write())
+    def test_write_non_string(self):
+        """Test Write() with non-string type for |path| throws TypeError."""
+        with self.assertRaises(TypeError):
+            self._event_log_module.Write(path=1234)
+    def test_write_socket(self):
+        """Test Write() with Unix domain socket for |path| and validate received
+        traces."""
+        received_traces = []
+        with tempfile.TemporaryDirectory(
+            prefix="test_server_sockets"
+        ) as tempdir:
+            socket_path = os.path.join(tempdir, "server.sock")
+            server_ready = threading.Condition()
+            # Start "server" listening on Unix domain socket at socket_path.
+            try:
+                server_thread = threading.Thread(
+                    target=serverLoggingThread,
+                    args=(socket_path, server_ready, received_traces),
+                )
+                server_thread.start()
+                with server_ready:
+                    server_ready.wait(timeout=120)
+                self._event_log_module.StartEvent()
+                path = self._event_log_module.Write(
+                    path=f"af_unix:{socket_path}"
+                )
+            finally:
+                server_thread.join(timeout=5)
+        self.assertEqual(path, f"af_unix:stream:{socket_path}")
+        self.assertEqual(len(received_traces), 2)
+        version_event = json.loads(received_traces[0])
+        start_event = json.loads(received_traces[1])
+        self.verifyCommonKeys(version_event, expected_event_name="version")
+        self.verifyCommonKeys(start_event, expected_event_name="start")
+        # Check for 'start' event specific fields.
+        self.assertIn("argv", start_event)
+        self.assertIsInstance(start_event["argv"], list)
diff --git a/tests/test_hooks.py b/tests/test_hooks.py
index 6632b3e5..78277128 100644
--- a/tests/test_hooks.py
+++ b/tests/test_hooks.py
@@ -17,39 +17,38 @@
 import hooks
 import unittest
 class RepoHookShebang(unittest.TestCase):
-  """Check shebang parsing in RepoHook."""
+    """Check shebang parsing in RepoHook."""
-  def test_no_shebang(self):
+    def test_no_shebang(self):
-    """Lines w/out shebangs should be rejected."""
+        """Lines w/out shebangs should be rejected."""
-    DATA = (
+        DATA = ("", "#\n# foo\n", "# Bad shebang in script\n#!/foo\n")
-        '',
+        for data in DATA:
-        '#\n# foo\n',
+            self.assertIsNone(hooks.RepoHook._ExtractInterpFromShebang(data))
-        '# Bad shebang in script\n#!/foo\n'
-    )
-    for data in DATA:
-      self.assertIsNone(hooks.RepoHook._ExtractInterpFromShebang(data))
-  def test_direct_interp(self):
+    def test_direct_interp(self):
-    """Lines whose shebang points directly to the interpreter."""
+        """Lines whose shebang points directly to the interpreter."""
-    DATA = (
+        DATA = (
-        ('#!/foo', '/foo'),
+            ("#!/foo", "/foo"),
-        ('#! /foo', '/foo'),
+            ("#! /foo", "/foo"),
-        ('#!/bin/foo ', '/bin/foo'),
+            ("#!/bin/foo ", "/bin/foo"),
-        ('#! /usr/foo ', '/usr/foo'),
+            ("#! /usr/foo ", "/usr/foo"),
-        ('#! /usr/foo -args', '/usr/foo'),
+            ("#! /usr/foo -args", "/usr/foo"),
-    )
+        )
-    for shebang, interp in DATA:
+        for shebang, interp in DATA:
-      self.assertEqual(hooks.RepoHook._ExtractInterpFromShebang(shebang),
+            self.assertEqual(
-                       interp)
+                hooks.RepoHook._ExtractInterpFromShebang(shebang), interp
+            )
-  def test_env_interp(self):
+    def test_env_interp(self):
-    """Lines whose shebang launches through `env`."""
+        """Lines whose shebang launches through `env`."""
-    DATA = (
+        DATA = (
-        ('#!/usr/bin/env foo', 'foo'),
+            ("#!/usr/bin/env foo", "foo"),
-        ('#!/bin/env foo', 'foo'),
+            ("#!/bin/env foo", "foo"),
-        ('#! /bin/env /bin/foo ', '/bin/foo'),
+            ("#! /bin/env /bin/foo ", "/bin/foo"),
-    )
+        )
-    for shebang, interp in DATA:
+        for shebang, interp in DATA:
-      self.assertEqual(hooks.RepoHook._ExtractInterpFromShebang(shebang),
+            self.assertEqual(
-                       interp)
+                hooks.RepoHook._ExtractInterpFromShebang(shebang), interp
+            )
diff --git a/tests/test_manifest_xml.py b/tests/test_manifest_xml.py
index 3634701f..648acde8 100644
--- a/tests/test_manifest_xml.py
+++ b/tests/test_manifest_xml.py
@@ -27,291 +27,318 @@ import manifest_xml
 # Invalid paths that we don't want in the filesystem.
 INVALID_FS_PATHS = (
-    '',
+    "",
-    '.',
+    ".",
-    '..',
+    "..",
-    '../',
+    "../",
-    './',
+    "./",
-    './/',
+    ".//",
-    'foo/',
+    "foo/",
-    './foo',
+    "./foo",
-    '../foo',
+    "../foo",
-    'foo/./bar',
+    "foo/./bar",
-    'foo/../../bar',
+    "foo/../../bar",
-    '/foo',
+    "/foo",
-    './../foo',
+    "./../foo",
-    '.git/foo',
+    ".git/foo",
    # Check case folding.
-    '.GIT/foo',
+    ".GIT/foo",
-    'blah/.git/foo',
+    "blah/.git/foo",
-    '.repo/foo',
+    ".repo/foo",
-    '.repoconfig',
+    ".repoconfig",
    # Block ~ due to 8.3 filenames on Windows filesystems.
-    '~',
+    "~",
-    'foo~',
+    "foo~",
-    'blah/foo~',
+    "blah/foo~",
    # Block Unicode characters that get normalized out by filesystems.
-    u'foo\u200Cbar',
+    "foo\u200Cbar",
    # Block newlines.
-    'f\n/bar',
+    "f\n/bar",
-    'f\r/bar',
+    "f\r/bar",
 )
 # Make sure platforms that use path separators (e.g. Windows) are also
 # rejected properly.
-if os.path.sep != '/':
+if os.path.sep != "/":
-  INVALID_FS_PATHS += tuple(x.replace('/', os.path.sep) for x in INVALID_FS_PATHS)
+    INVALID_FS_PATHS += tuple(
+        x.replace("/", os.path.sep) for x in INVALID_FS_PATHS
+    )
 def sort_attributes(manifest):
-  """Sort the attributes of all elements alphabetically.
+    """Sort the attributes of all elements alphabetically.
-  This is needed because different versions of the toxml() function from
+    This is needed because different versions of the toxml() function from
-  xml.dom.minidom outputs the attributes of elements in different orders.
+    xml.dom.minidom outputs the attributes of elements in different orders.
-  Before Python 3.8 they were output alphabetically, later versions preserve
+    Before Python 3.8 they were output alphabetically, later versions preserve
-  the order specified by the user.
+    the order specified by the user.
-  Args:
+    Args:
-    manifest: String containing an XML manifest.
+        manifest: String containing an XML manifest.
-  Returns:
+    Returns:
-    The XML manifest with the attributes of all elements sorted alphabetically.
+        The XML manifest with the attributes of all elements sorted
-  """
+        alphabetically.
-  new_manifest = ''
+    """
-  # This will find every element in the XML manifest, whether they have
+    new_manifest = ""
-  # attributes or not. This simplifies recreating the manifest below.
+    # This will find every element in the XML manifest, whether they have
-  matches = re.findall(r'(<[/?]?[a-z-]+\s*)((?:\S+?="[^"]+"\s*?)*)(\s*[/?]?>)', manifest)
+    # attributes or not. This simplifies recreating the manifest below.
-  for head, attrs, tail in matches:
+    matches = re.findall(
-    m = re.findall(r'\S+?="[^"]+"', attrs)
+        r'(<[/?]?[a-z-]+\s*)((?:\S+?="[^"]+"\s*?)*)(\s*[/?]?>)', manifest
-    new_manifest += head + ' '.join(sorted(m)) + tail
+    )
-  return new_manifest
+    for head, attrs, tail in matches:
+        m = re.findall(r'\S+?="[^"]+"', attrs)
+        new_manifest += head + " ".join(sorted(m)) + tail
+    return new_manifest
 class ManifestParseTestCase(unittest.TestCase):
-  """TestCase for parsing manifests."""
+    """TestCase for parsing manifests."""
-  def setUp(self):
+    def setUp(self):
-    self.tempdirobj = tempfile.TemporaryDirectory(prefix='repo_tests')
+        self.tempdirobj = tempfile.TemporaryDirectory(prefix="repo_tests")
-    self.tempdir = self.tempdirobj.name
+        self.tempdir = self.tempdirobj.name
-    self.repodir = os.path.join(self.tempdir, '.repo')
+        self.repodir = os.path.join(self.tempdir, ".repo")
-    self.manifest_dir = os.path.join(self.repodir, 'manifests')
+        self.manifest_dir = os.path.join(self.repodir, "manifests")
-    self.manifest_file = os.path.join(
+        self.manifest_file = os.path.join(
-        self.repodir, manifest_xml.MANIFEST_FILE_NAME)
+            self.repodir, manifest_xml.MANIFEST_FILE_NAME
-    self.local_manifest_dir = os.path.join(
+        )
-        self.repodir, manifest_xml.LOCAL_MANIFESTS_DIR_NAME)
+        self.local_manifest_dir = os.path.join(
-    os.mkdir(self.repodir)
+            self.repodir, manifest_xml.LOCAL_MANIFESTS_DIR_NAME
-    os.mkdir(self.manifest_dir)
+        )
+        os.mkdir(self.repodir)
-    # The manifest parsing really wants a git repo currently.
+        os.mkdir(self.manifest_dir)
-    gitdir = os.path.join(self.repodir, 'manifests.git')
-    os.mkdir(gitdir)
+        # The manifest parsing really wants a git repo currently.
-    with open(os.path.join(gitdir, 'config'), 'w') as fp:
+        gitdir = os.path.join(self.repodir, "manifests.git")
-      fp.write("""[remote "origin"]
+        os.mkdir(gitdir)
+        with open(os.path.join(gitdir, "config"), "w") as fp:
+            fp.write(
+                """[remote "origin"]
        url = https://localhost:0/manifest
-""")
+"""
+            )
-  def tearDown(self):
+    def tearDown(self):
-    self.tempdirobj.cleanup()
+        self.tempdirobj.cleanup()
-  def getXmlManifest(self, data):
+    def getXmlManifest(self, data):
-    """Helper to initialize a manifest for testing."""
+        """Helper to initialize a manifest for testing."""
-    with open(self.manifest_file, 'w', encoding="utf-8") as fp:
+        with open(self.manifest_file, "w", encoding="utf-8") as fp:
-      fp.write(data)
+            fp.write(data)
-    return manifest_xml.XmlManifest(self.repodir, self.manifest_file)
+        return manifest_xml.XmlManifest(self.repodir, self.manifest_file)
-  @staticmethod
+    @staticmethod
-  def encodeXmlAttr(attr):
+    def encodeXmlAttr(attr):
-    """Encode |attr| using XML escape rules."""
+        """Encode |attr| using XML escape rules."""
-    return attr.replace('\r', '&#x000d;').replace('\n', '&#x000a;')
+        return attr.replace("\r", "&#x000d;").replace("\n", "&#x000a;")
 class ManifestValidateFilePaths(unittest.TestCase):
-  """Check _ValidateFilePaths helper.
+    """Check _ValidateFilePaths helper.
-  This doesn't access a real filesystem.
+    This doesn't access a real filesystem.
-  """
+    """
-  def check_both(self, *args):
+    def check_both(self, *args):
-    manifest_xml.XmlManifest._ValidateFilePaths('copyfile', *args)
+        manifest_xml.XmlManifest._ValidateFilePaths("copyfile", *args)
-    manifest_xml.XmlManifest._ValidateFilePaths('linkfile', *args)
+        manifest_xml.XmlManifest._ValidateFilePaths("linkfile", *args)
-  def test_normal_path(self):
+    def test_normal_path(self):
-    """Make sure good paths are accepted."""
+        """Make sure good paths are accepted."""
-    self.check_both('foo', 'bar')
+        self.check_both("foo", "bar")
-    self.check_both('foo/bar', 'bar')
+        self.check_both("foo/bar", "bar")
-    self.check_both('foo', 'bar/bar')
+        self.check_both("foo", "bar/bar")
-    self.check_both('foo/bar', 'bar/bar')
+        self.check_both("foo/bar", "bar/bar")
-  def test_symlink_targets(self):
+    def test_symlink_targets(self):
-    """Some extra checks for symlinks."""
+        """Some extra checks for symlinks."""
-    def check(*args):
-      manifest_xml.XmlManifest._ValidateFilePaths('linkfile', *args)
+        def check(*args):
+            manifest_xml.XmlManifest._ValidateFilePaths("linkfile", *args)
-    # We allow symlinks to end in a slash since we allow them to point to dirs
-    # in general.  Technically the slash isn't necessary.
+        # We allow symlinks to end in a slash since we allow them to point to
-    check('foo/', 'bar')
+        # dirs in general.  Technically the slash isn't necessary.
-    # We allow a single '.' to get a reference to the project itself.
+        check("foo/", "bar")
-    check('.', 'bar')
+        # We allow a single '.' to get a reference to the project itself.
+        check(".", "bar")
-  def test_bad_paths(self):
-    """Make sure bad paths (src & dest) are rejected."""
+    def test_bad_paths(self):
-    for path in INVALID_FS_PATHS:
+        """Make sure bad paths (src & dest) are rejected."""
-      self.assertRaises(
+        for path in INVALID_FS_PATHS:
-          error.ManifestInvalidPathError, self.check_both, path, 'a')
+            self.assertRaises(
-      self.assertRaises(
+                error.ManifestInvalidPathError, self.check_both, path, "a"
-          error.ManifestInvalidPathError, self.check_both, 'a', path)
+            )
+            self.assertRaises(
+                error.ManifestInvalidPathError, self.check_both, "a", path
+            )
 class ValueTests(unittest.TestCase):
-  """Check utility parsing code."""
+    """Check utility parsing code."""
-  def _get_node(self, text):
+    def _get_node(self, text):
-    return xml.dom.minidom.parseString(text).firstChild
+        return xml.dom.minidom.parseString(text).firstChild
-  def test_bool_default(self):
+    def test_bool_default(self):
-    """Check XmlBool default handling."""
+        """Check XmlBool default handling."""
-    node = self._get_node('<node/>')
+        node = self._get_node("<node/>")
-    self.assertIsNone(manifest_xml.XmlBool(node, 'a'))
+        self.assertIsNone(manifest_xml.XmlBool(node, "a"))
-    self.assertIsNone(manifest_xml.XmlBool(node, 'a', None))
+        self.assertIsNone(manifest_xml.XmlBool(node, "a", None))
-    self.assertEqual(123, manifest_xml.XmlBool(node, 'a', 123))
+        self.assertEqual(123, manifest_xml.XmlBool(node, "a", 123))
-    node = self._get_node('<node a=""/>')
+        node = self._get_node('<node a=""/>')
-    self.assertIsNone(manifest_xml.XmlBool(node, 'a'))
+        self.assertIsNone(manifest_xml.XmlBool(node, "a"))
-  def test_bool_invalid(self):
+    def test_bool_invalid(self):
-    """Check XmlBool invalid handling."""
+        """Check XmlBool invalid handling."""
-    node = self._get_node('<node a="moo"/>')
+        node = self._get_node('<node a="moo"/>')
-    self.assertEqual(123, manifest_xml.XmlBool(node, 'a', 123))
+        self.assertEqual(123, manifest_xml.XmlBool(node, "a", 123))
-  def test_bool_true(self):
+    def test_bool_true(self):
-    """Check XmlBool true values."""
+        """Check XmlBool true values."""
-    for value in ('yes', 'true', '1'):
+        for value in ("yes", "true", "1"):
-      node = self._get_node('<node a="%s"/>' % (value,))
+            node = self._get_node('<node a="%s"/>' % (value,))
-      self.assertTrue(manifest_xml.XmlBool(node, 'a'))
+            self.assertTrue(manifest_xml.XmlBool(node, "a"))
-  def test_bool_false(self):
+    def test_bool_false(self):
-    """Check XmlBool false values."""
+        """Check XmlBool false values."""
-    for value in ('no', 'false', '0'):
+        for value in ("no", "false", "0"):
-      node = self._get_node('<node a="%s"/>' % (value,))
+            node = self._get_node('<node a="%s"/>' % (value,))
-      self.assertFalse(manifest_xml.XmlBool(node, 'a'))
+            self.assertFalse(manifest_xml.XmlBool(node, "a"))
-  def test_int_default(self):
+    def test_int_default(self):
-    """Check XmlInt default handling."""
+        """Check XmlInt default handling."""
-    node = self._get_node('<node/>')
+        node = self._get_node("<node/>")
-    self.assertIsNone(manifest_xml.XmlInt(node, 'a'))
+        self.assertIsNone(manifest_xml.XmlInt(node, "a"))
-    self.assertIsNone(manifest_xml.XmlInt(node, 'a', None))
+        self.assertIsNone(manifest_xml.XmlInt(node, "a", None))
-    self.assertEqual(123, manifest_xml.XmlInt(node, 'a', 123))
+        self.assertEqual(123, manifest_xml.XmlInt(node, "a", 123))
-    node = self._get_node('<node a=""/>')
+        node = self._get_node('<node a=""/>')
-    self.assertIsNone(manifest_xml.XmlInt(node, 'a'))
+        self.assertIsNone(manifest_xml.XmlInt(node, "a"))
-  def test_int_good(self):
+    def test_int_good(self):
-    """Check XmlInt numeric handling."""
+        """Check XmlInt numeric handling."""
-    for value in (-1, 0, 1, 50000):
+        for value in (-1, 0, 1, 50000):
-      node = self._get_node('<node a="%s"/>' % (value,))
+            node = self._get_node('<node a="%s"/>' % (value,))
-      self.assertEqual(value, manifest_xml.XmlInt(node, 'a'))
+            self.assertEqual(value, manifest_xml.XmlInt(node, "a"))
-  def test_int_invalid(self):
+    def test_int_invalid(self):
-    """Check XmlInt invalid handling."""
+        """Check XmlInt invalid handling."""
-    with self.assertRaises(error.ManifestParseError):
+        with self.assertRaises(error.ManifestParseError):
-      node = self._get_node('<node a="xx"/>')
+            node = self._get_node('<node a="xx"/>')
-      manifest_xml.XmlInt(node, 'a')
+            manifest_xml.XmlInt(node, "a")
 class XmlManifestTests(ManifestParseTestCase):
-  """Check manifest processing."""
+    """Check manifest processing."""
-  def test_empty(self):
+    def test_empty(self):
-    """Parse an 'empty' manifest file."""
+        """Parse an 'empty' manifest file."""
-    manifest = self.getXmlManifest(
+        manifest = self.getXmlManifest(
-        '<?xml version="1.0" encoding="UTF-8"?>'
+            '<?xml version="1.0" encoding="UTF-8"?>' "<manifest></manifest>"
-        '<manifest></manifest>')
+        )
-    self.assertEqual(manifest.remotes, {})
+        self.assertEqual(manifest.remotes, {})
-    self.assertEqual(manifest.projects, [])
+        self.assertEqual(manifest.projects, [])
-  def test_link(self):
+    def test_link(self):
-    """Verify Link handling with new names."""
+        """Verify Link handling with new names."""
-    manifest = manifest_xml.XmlManifest(self.repodir, self.manifest_file)
+        manifest = manifest_xml.XmlManifest(self.repodir, self.manifest_file)
-    with open(os.path.join(self.manifest_dir, 'foo.xml'), 'w') as fp:
+        with open(os.path.join(self.manifest_dir, "foo.xml"), "w") as fp:
-      fp.write('<manifest></manifest>')
+            fp.write("<manifest></manifest>")
-    manifest.Link('foo.xml')
+        manifest.Link("foo.xml")
-    with open(self.manifest_file) as fp:
+        with open(self.manifest_file) as fp:
-      self.assertIn('<include name="foo.xml" />', fp.read())
+            self.assertIn('<include name="foo.xml" />', fp.read())
-  def test_toxml_empty(self):
+    def test_toxml_empty(self):
-    """Verify the ToXml() helper."""
+        """Verify the ToXml() helper."""
-    manifest = self.getXmlManifest(
+        manifest = self.getXmlManifest(
-        '<?xml version="1.0" encoding="UTF-8"?>'
+            '<?xml version="1.0" encoding="UTF-8"?>' "<manifest></manifest>"
-        '<manifest></manifest>')
+        )
-    self.assertEqual(manifest.ToXml().toxml(), '<?xml version="1.0" ?><manifest/>')
+        self.assertEqual(
+            manifest.ToXml().toxml(), '<?xml version="1.0" ?><manifest/>'
-  def test_todict_empty(self):
+        )
-    """Verify the ToDict() helper."""
-    manifest = self.getXmlManifest(
+    def test_todict_empty(self):
-        '<?xml version="1.0" encoding="UTF-8"?>'
+        """Verify the ToDict() helper."""
-        '<manifest></manifest>')
+        manifest = self.getXmlManifest(
-    self.assertEqual(manifest.ToDict(), {})
+            '<?xml version="1.0" encoding="UTF-8"?>' "<manifest></manifest>"
+        )
-  def test_toxml_omit_local(self):
+        self.assertEqual(manifest.ToDict(), {})
-    """Does not include local_manifests projects when omit_local=True."""
-    manifest = self.getXmlManifest(
+    def test_toxml_omit_local(self):
-        '<?xml version="1.0" encoding="UTF-8"?><manifest>'
+        """Does not include local_manifests projects when omit_local=True."""
-        '<remote name="a" fetch=".."/><default remote="a" revision="r"/>'
+        manifest = self.getXmlManifest(
-        '<project name="p" groups="local::me"/>'
+            '<?xml version="1.0" encoding="UTF-8"?><manifest>'
-        '<project name="q"/>'
+            '<remote name="a" fetch=".."/><default remote="a" revision="r"/>'
-        '<project name="r" groups="keep"/>'
+            '<project name="p" groups="local::me"/>'
-        '</manifest>')
+            '<project name="q"/>'
-    self.assertEqual(
+            '<project name="r" groups="keep"/>'
-        sort_attributes(manifest.ToXml(omit_local=True).toxml()),
+            "</manifest>"
-        '<?xml version="1.0" ?><manifest>'
+        )
-        '<remote fetch=".." name="a"/><default remote="a" revision="r"/>'
+        self.assertEqual(
-        '<project name="q"/><project groups="keep" name="r"/></manifest>')
+            sort_attributes(manifest.ToXml(omit_local=True).toxml()),
+            '<?xml version="1.0" ?><manifest>'
-  def test_toxml_with_local(self):
+            '<remote fetch=".." name="a"/><default remote="a" revision="r"/>'
-    """Does include local_manifests projects when omit_local=False."""
+            '<project name="q"/><project groups="keep" name="r"/></manifest>',
-    manifest = self.getXmlManifest(
+        )
-        '<?xml version="1.0" encoding="UTF-8"?><manifest>'
-        '<remote name="a" fetch=".."/><default remote="a" revision="r"/>'
+    def test_toxml_with_local(self):
-        '<project name="p" groups="local::me"/>'
+        """Does include local_manifests projects when omit_local=False."""
-        '<project name="q"/>'
+        manifest = self.getXmlManifest(
-        '<project name="r" groups="keep"/>'
+            '<?xml version="1.0" encoding="UTF-8"?><manifest>'
-        '</manifest>')
+            '<remote name="a" fetch=".."/><default remote="a" revision="r"/>'
-    self.assertEqual(
+            '<project name="p" groups="local::me"/>'
-        sort_attributes(manifest.ToXml(omit_local=False).toxml()),
+            '<project name="q"/>'
-        '<?xml version="1.0" ?><manifest>'
+            '<project name="r" groups="keep"/>'
-        '<remote fetch=".." name="a"/><default remote="a" revision="r"/>'
+            "</manifest>"
-        '<project groups="local::me" name="p"/>'
+        )
-        '<project name="q"/><project groups="keep" name="r"/></manifest>')
+        self.assertEqual(
+            sort_attributes(manifest.ToXml(omit_local=False).toxml()),
-  def test_repo_hooks(self):
+            '<?xml version="1.0" ?><manifest>'
-    """Check repo-hooks settings."""
+            '<remote fetch=".." name="a"/><default remote="a" revision="r"/>'
-    manifest = self.getXmlManifest("""
+            '<project groups="local::me" name="p"/>'
+            '<project name="q"/><project groups="keep" name="r"/></manifest>',
+        )
+    def test_repo_hooks(self):
+        """Check repo-hooks settings."""
+        manifest = self.getXmlManifest(
+            """
 <manifest>
  <remote name="test-remote" fetch="http://localhost" />
  <default remote="test-remote" revision="refs/heads/main" />
  <project name="repohooks" path="src/repohooks"/>
  <repo-hooks in-project="repohooks" enabled-list="a, b"/>
 </manifest>
-""")
+"""
-    self.assertEqual(manifest.repo_hooks_project.name, 'repohooks')
+        )
-    self.assertEqual(manifest.repo_hooks_project.enabled_repo_hooks, ['a', 'b'])
+        self.assertEqual(manifest.repo_hooks_project.name, "repohooks")
+        self.assertEqual(
-  def test_repo_hooks_unordered(self):
+            manifest.repo_hooks_project.enabled_repo_hooks, ["a", "b"]
-    """Check repo-hooks settings work even if the project def comes second."""
+        )
-    manifest = self.getXmlManifest("""
+    def test_repo_hooks_unordered(self):
+        """Check repo-hooks settings work even if the project def comes second."""  # noqa: E501
+        manifest = self.getXmlManifest(
+            """
 <manifest>
  <remote name="test-remote" fetch="http://localhost" />
  <default remote="test-remote" revision="refs/heads/main" />
  <repo-hooks in-project="repohooks" enabled-list="a, b"/>
  <project name="repohooks" path="src/repohooks"/>
 </manifest>
-""")
+"""
-    self.assertEqual(manifest.repo_hooks_project.name, 'repohooks')
+        )
-    self.assertEqual(manifest.repo_hooks_project.enabled_repo_hooks, ['a', 'b'])
+        self.assertEqual(manifest.repo_hooks_project.name, "repohooks")
+        self.assertEqual(
-  def test_unknown_tags(self):
+            manifest.repo_hooks_project.enabled_repo_hooks, ["a", "b"]
-    """Check superproject settings."""
+        )
-    manifest = self.getXmlManifest("""
+    def test_unknown_tags(self):
+        """Check superproject settings."""
+        manifest = self.getXmlManifest(
+            """
 <manifest>
  <remote name="test-remote" fetch="http://localhost" />
  <default remote="test-remote" revision="refs/heads/main" />
@@ -319,44 +346,54 @@ class XmlManifestTests(ManifestParseTestCase):
  <iankaz value="unknown (possible) future tags are ignored"/>
  <x-custom-tag>X tags are always ignored</x-custom-tag>
 </manifest>
-""")
+"""
-    self.assertEqual(manifest.superproject.name, 'superproject')
+        )
-    self.assertEqual(manifest.superproject.remote.name, 'test-remote')
+        self.assertEqual(manifest.superproject.name, "superproject")
-    self.assertEqual(
+        self.assertEqual(manifest.superproject.remote.name, "test-remote")
-        sort_attributes(manifest.ToXml().toxml()),
+        self.assertEqual(
-        '<?xml version="1.0" ?><manifest>'
+            sort_attributes(manifest.ToXml().toxml()),
-        '<remote fetch="http://localhost" name="test-remote"/>'
+            '<?xml version="1.0" ?><manifest>'
-        '<default remote="test-remote" revision="refs/heads/main"/>'
+            '<remote fetch="http://localhost" name="test-remote"/>'
-        '<superproject name="superproject"/>'
+            '<default remote="test-remote" revision="refs/heads/main"/>'
-        '</manifest>')
+            '<superproject name="superproject"/>'
+            "</manifest>",
-  def test_remote_annotations(self):
+        )
-    """Check remote settings."""
-    manifest = self.getXmlManifest("""
+    def test_remote_annotations(self):
+        """Check remote settings."""
+        manifest = self.getXmlManifest(
+            """
 <manifest>
  <remote name="test-remote" fetch="http://localhost">
    <annotation name="foo" value="bar"/>
  </remote>
 </manifest>
-""")
+"""
-    self.assertEqual(manifest.remotes['test-remote'].annotations[0].name, 'foo')
+        )
-    self.assertEqual(manifest.remotes['test-remote'].annotations[0].value, 'bar')
+        self.assertEqual(
-    self.assertEqual(
+            manifest.remotes["test-remote"].annotations[0].name, "foo"
-        sort_attributes(manifest.ToXml().toxml()),
+        )
-        '<?xml version="1.0" ?><manifest>'
+        self.assertEqual(
-        '<remote fetch="http://localhost" name="test-remote">'
+            manifest.remotes["test-remote"].annotations[0].value, "bar"
-        '<annotation name="foo" value="bar"/>'
+        )
-        '</remote>'
+        self.assertEqual(
-        '</manifest>')
+            sort_attributes(manifest.ToXml().toxml()),
+            '<?xml version="1.0" ?><manifest>'
+            '<remote fetch="http://localhost" name="test-remote">'
+            '<annotation name="foo" value="bar"/>'
+            "</remote>"
+            "</manifest>",
+        )
 class IncludeElementTests(ManifestParseTestCase):
-  """Tests for <include>."""
+    """Tests for <include>."""
-  def test_group_levels(self):
+    def test_group_levels(self):
-    root_m = os.path.join(self.manifest_dir, 'root.xml')
+        root_m = os.path.join(self.manifest_dir, "root.xml")
-    with open(root_m, 'w') as fp:
+        with open(root_m, "w") as fp:
-      fp.write("""
+            fp.write(
+                """
 <manifest>
  <remote name="test-remote" fetch="http://localhost" />
  <default remote="test-remote" revision="refs/heads/main" />
@@ -364,438 +401,524 @@ class IncludeElementTests(ManifestParseTestCase):
  <project name="root-name1" path="root-path1" />
  <project name="root-name2" path="root-path2" groups="r2g1,r2g2" />
 </manifest>
-""")
+"""
-    with open(os.path.join(self.manifest_dir, 'level1.xml'), 'w') as fp:
+            )
-      fp.write("""
+        with open(os.path.join(self.manifest_dir, "level1.xml"), "w") as fp:
+            fp.write(
+                """
 <manifest>
  <include name="level2.xml" groups="level2-group" />
  <project name="level1-name1" path="level1-path1" />
 </manifest>
-""")
+"""
-    with open(os.path.join(self.manifest_dir, 'level2.xml'), 'w') as fp:
+            )
-      fp.write("""
+        with open(os.path.join(self.manifest_dir, "level2.xml"), "w") as fp:
+            fp.write(
+                """
 <manifest>
  <project name="level2-name1" path="level2-path1" groups="l2g1,l2g2" />
 </manifest>
-""")
+"""
-    include_m = manifest_xml.XmlManifest(self.repodir, root_m)
+            )
-    for proj in include_m.projects:
+        include_m = manifest_xml.XmlManifest(self.repodir, root_m)
-      if proj.name == 'root-name1':
+        for proj in include_m.projects:
-        # Check include group not set on root level proj.
+            if proj.name == "root-name1":
-        self.assertNotIn('level1-group', proj.groups)
+                # Check include group not set on root level proj.
-      if proj.name == 'root-name2':
+                self.assertNotIn("level1-group", proj.groups)
-        # Check root proj group not removed.
+            if proj.name == "root-name2":
-        self.assertIn('r2g1', proj.groups)
+                # Check root proj group not removed.
-      if proj.name == 'level1-name1':
+                self.assertIn("r2g1", proj.groups)
-        # Check level1 proj has inherited group level 1.
+            if proj.name == "level1-name1":
-        self.assertIn('level1-group', proj.groups)
+                # Check level1 proj has inherited group level 1.
-      if proj.name == 'level2-name1':
+                self.assertIn("level1-group", proj.groups)
-        # Check level2 proj has inherited group levels 1 and 2.
+            if proj.name == "level2-name1":
-        self.assertIn('level1-group', proj.groups)
+                # Check level2 proj has inherited group levels 1 and 2.
-        self.assertIn('level2-group', proj.groups)
+                self.assertIn("level1-group", proj.groups)
-        # Check level2 proj group not removed.
+                self.assertIn("level2-group", proj.groups)
-        self.assertIn('l2g1', proj.groups)
+                # Check level2 proj group not removed.
+                self.assertIn("l2g1", proj.groups)
-  def test_allow_bad_name_from_user(self):
-    """Check handling of bad name attribute from the user's input."""
+    def test_allow_bad_name_from_user(self):
-    def parse(name):
+        """Check handling of bad name attribute from the user's input."""
-      name = self.encodeXmlAttr(name)
-      manifest = self.getXmlManifest(f"""
+        def parse(name):
+            name = self.encodeXmlAttr(name)
+            manifest = self.getXmlManifest(
+                f"""
 <manifest>
  <remote name="default-remote" fetch="http://localhost" />
  <default remote="default-remote" revision="refs/heads/main" />
  <include name="{name}" />
 </manifest>
-""")
+"""
-      # Force the manifest to be parsed.
+            )
-      manifest.ToXml()
+            # Force the manifest to be parsed.
+            manifest.ToXml()
-    # Setup target of the include.
-    target = os.path.join(self.tempdir, 'target.xml')
+        # Setup target of the include.
-    with open(target, 'w') as fp:
+        target = os.path.join(self.tempdir, "target.xml")
-      fp.write('<manifest></manifest>')
+        with open(target, "w") as fp:
+            fp.write("<manifest></manifest>")
-    # Include with absolute path.
-    parse(os.path.abspath(target))
+        # Include with absolute path.
+        parse(os.path.abspath(target))
-    # Include with relative path.
-    parse(os.path.relpath(target, self.manifest_dir))
+        # Include with relative path.
+        parse(os.path.relpath(target, self.manifest_dir))
-  def test_bad_name_checks(self):
-    """Check handling of bad name attribute."""
+    def test_bad_name_checks(self):
-    def parse(name):
+        """Check handling of bad name attribute."""
-      name = self.encodeXmlAttr(name)
-      # Setup target of the include.
+        def parse(name):
-      with open(os.path.join(self.manifest_dir, 'target.xml'), 'w', encoding="utf-8") as fp:
+            name = self.encodeXmlAttr(name)
-        fp.write(f'<manifest><include name="{name}"/></manifest>')
+            # Setup target of the include.
+            with open(
-      manifest = self.getXmlManifest("""
+                os.path.join(self.manifest_dir, "target.xml"),
+                "w",
+                encoding="utf-8",
+            ) as fp:
+                fp.write(f'<manifest><include name="{name}"/></manifest>')
+            manifest = self.getXmlManifest(
+                """
 <manifest>
  <remote name="default-remote" fetch="http://localhost" />
  <default remote="default-remote" revision="refs/heads/main" />
  <include name="target.xml" />
 </manifest>
-""")
+"""
-      # Force the manifest to be parsed.
+            )
-      manifest.ToXml()
+            # Force the manifest to be parsed.
+            manifest.ToXml()
-    # Handle empty name explicitly because a different codepath rejects it.
+        # Handle empty name explicitly because a different codepath rejects it.
-    with self.assertRaises(error.ManifestParseError):
+        with self.assertRaises(error.ManifestParseError):
-      parse('')
+            parse("")
-    for path in INVALID_FS_PATHS:
+        for path in INVALID_FS_PATHS:
-      if not path:
+            if not path:
-        continue
+                continue
-      with self.assertRaises(error.ManifestInvalidPathError):
+            with self.assertRaises(error.ManifestInvalidPathError):
-        parse(path)
+                parse(path)
 class ProjectElementTests(ManifestParseTestCase):
-  """Tests for <project>."""
+    """Tests for <project>."""
-  def test_group(self):
+    def test_group(self):
-    """Check project group settings."""
+        """Check project group settings."""
-    manifest = self.getXmlManifest("""
+        manifest = self.getXmlManifest(
+            """
 <manifest>
  <remote name="test-remote" fetch="http://localhost" />
  <default remote="test-remote" revision="refs/heads/main" />
  <project name="test-name" path="test-path"/>
  <project name="extras" path="path" groups="g1,g2,g1"/>
 </manifest>
-""")
+"""
-    self.assertEqual(len(manifest.projects), 2)
+        )
-    # Ordering isn't guaranteed.
+        self.assertEqual(len(manifest.projects), 2)
-    result = {
+        # Ordering isn't guaranteed.
-        manifest.projects[0].name: manifest.projects[0].groups,
+        result = {
-        manifest.projects[1].name: manifest.projects[1].groups,
+            manifest.projects[0].name: manifest.projects[0].groups,
-    }
+            manifest.projects[1].name: manifest.projects[1].groups,
-    project = manifest.projects[0]
+        }
-    self.assertCountEqual(
+        self.assertCountEqual(
-        result['test-name'],
+            result["test-name"], ["name:test-name", "all", "path:test-path"]
-        ['name:test-name', 'all', 'path:test-path'])
+        )
-    self.assertCountEqual(
+        self.assertCountEqual(
-        result['extras'],
+            result["extras"],
-        ['g1', 'g2', 'g1', 'name:extras', 'all', 'path:path'])
+            ["g1", "g2", "g1", "name:extras", "all", "path:path"],
-    groupstr = 'default,platform-' + platform.system().lower()
+        )
-    self.assertEqual(groupstr, manifest.GetGroupsStr())
+        groupstr = "default,platform-" + platform.system().lower()
-    groupstr = 'g1,g2,g1'
+        self.assertEqual(groupstr, manifest.GetGroupsStr())
-    manifest.manifestProject.config.SetString('manifest.groups', groupstr)
+        groupstr = "g1,g2,g1"
-    self.assertEqual(groupstr, manifest.GetGroupsStr())
+        manifest.manifestProject.config.SetString("manifest.groups", groupstr)
+        self.assertEqual(groupstr, manifest.GetGroupsStr())
-  def test_set_revision_id(self):
-    """Check setting of project's revisionId."""
+    def test_set_revision_id(self):
-    manifest = self.getXmlManifest("""
+        """Check setting of project's revisionId."""
+        manifest = self.getXmlManifest(
+            """
 <manifest>
  <remote name="default-remote" fetch="http://localhost" />
  <default remote="default-remote" revision="refs/heads/main" />
  <project name="test-name"/>
 </manifest>
-""")
+"""
-    self.assertEqual(len(manifest.projects), 1)
+        )
-    project = manifest.projects[0]
+        self.assertEqual(len(manifest.projects), 1)
-    project.SetRevisionId('ABCDEF')
+        project = manifest.projects[0]
-    self.assertEqual(
+        project.SetRevisionId("ABCDEF")
-        sort_attributes(manifest.ToXml().toxml()),
+        self.assertEqual(
-        '<?xml version="1.0" ?><manifest>'
+            sort_attributes(manifest.ToXml().toxml()),
-        '<remote fetch="http://localhost" name="default-remote"/>'
+            '<?xml version="1.0" ?><manifest>'
-        '<default remote="default-remote" revision="refs/heads/main"/>'
+            '<remote fetch="http://localhost" name="default-remote"/>'
-        '<project name="test-name" revision="ABCDEF" upstream="refs/heads/main"/>'
+            '<default remote="default-remote" revision="refs/heads/main"/>'
-        '</manifest>')
+            '<project name="test-name" revision="ABCDEF" upstream="refs/heads/main"/>'  # noqa: E501
+            "</manifest>",
-  def test_trailing_slash(self):
+        )
-    """Check handling of trailing slashes in attributes."""
-    def parse(name, path):
+    def test_trailing_slash(self):
-      name = self.encodeXmlAttr(name)
+        """Check handling of trailing slashes in attributes."""
-      path = self.encodeXmlAttr(path)
-      return self.getXmlManifest(f"""
+        def parse(name, path):
+            name = self.encodeXmlAttr(name)
+            path = self.encodeXmlAttr(path)
+            return self.getXmlManifest(
+                f"""
 <manifest>
  <remote name="default-remote" fetch="http://localhost" />
  <default remote="default-remote" revision="refs/heads/main" />
  <project name="{name}" path="{path}" />
 </manifest>
-""")
+"""
+            )
-    manifest = parse('a/path/', 'foo')
-    self.assertEqual(os.path.normpath(manifest.projects[0].gitdir),
+        manifest = parse("a/path/", "foo")
-                     os.path.join(self.tempdir, '.repo', 'projects', 'foo.git'))
+        self.assertEqual(
-    self.assertEqual(os.path.normpath(manifest.projects[0].objdir),
+            os.path.normpath(manifest.projects[0].gitdir),
-                     os.path.join(self.tempdir, '.repo', 'project-objects', 'a', 'path.git'))
+            os.path.join(self.tempdir, ".repo", "projects", "foo.git"),
+        )
-    manifest = parse('a/path', 'foo/')
+        self.assertEqual(
-    self.assertEqual(os.path.normpath(manifest.projects[0].gitdir),
+            os.path.normpath(manifest.projects[0].objdir),
-                     os.path.join(self.tempdir, '.repo', 'projects', 'foo.git'))
+            os.path.join(
-    self.assertEqual(os.path.normpath(manifest.projects[0].objdir),
+                self.tempdir, ".repo", "project-objects", "a", "path.git"
-                     os.path.join(self.tempdir, '.repo', 'project-objects', 'a', 'path.git'))
+            ),
+        )
-    manifest = parse('a/path', 'foo//////')
-    self.assertEqual(os.path.normpath(manifest.projects[0].gitdir),
+        manifest = parse("a/path", "foo/")
-                     os.path.join(self.tempdir, '.repo', 'projects', 'foo.git'))
+        self.assertEqual(
-    self.assertEqual(os.path.normpath(manifest.projects[0].objdir),
+            os.path.normpath(manifest.projects[0].gitdir),
-                     os.path.join(self.tempdir, '.repo', 'project-objects', 'a', 'path.git'))
+            os.path.join(self.tempdir, ".repo", "projects", "foo.git"),
+        )
-  def test_toplevel_path(self):
+        self.assertEqual(
-    """Check handling of path=. specially."""
+            os.path.normpath(manifest.projects[0].objdir),
-    def parse(name, path):
+            os.path.join(
-      name = self.encodeXmlAttr(name)
+                self.tempdir, ".repo", "project-objects", "a", "path.git"
-      path = self.encodeXmlAttr(path)
+            ),
-      return self.getXmlManifest(f"""
+        )
+        manifest = parse("a/path", "foo//////")
+        self.assertEqual(
+            os.path.normpath(manifest.projects[0].gitdir),
+            os.path.join(self.tempdir, ".repo", "projects", "foo.git"),
+        )
+        self.assertEqual(
+            os.path.normpath(manifest.projects[0].objdir),
+            os.path.join(
+                self.tempdir, ".repo", "project-objects", "a", "path.git"
+            ),
+        )
+    def test_toplevel_path(self):
+        """Check handling of path=. specially."""
+        def parse(name, path):
+            name = self.encodeXmlAttr(name)
+            path = self.encodeXmlAttr(path)
+            return self.getXmlManifest(
+                f"""
 <manifest>
  <remote name="default-remote" fetch="http://localhost" />
  <default remote="default-remote" revision="refs/heads/main" />
  <project name="{name}" path="{path}" />
 </manifest>
-""")
+"""
+            )
-    for path in ('.', './', './/', './//'):
-      manifest = parse('server/path', path)
+        for path in (".", "./", ".//", ".///"):
-      self.assertEqual(os.path.normpath(manifest.projects[0].gitdir),
+            manifest = parse("server/path", path)
-                       os.path.join(self.tempdir, '.repo', 'projects', '..git'))
+            self.assertEqual(
+                os.path.normpath(manifest.projects[0].gitdir),
-  def test_bad_path_name_checks(self):
+                os.path.join(self.tempdir, ".repo", "projects", "..git"),
-    """Check handling of bad path & name attributes."""
+            )
-    def parse(name, path):
-      name = self.encodeXmlAttr(name)
+    def test_bad_path_name_checks(self):
-      path = self.encodeXmlAttr(path)
+        """Check handling of bad path & name attributes."""
-      manifest = self.getXmlManifest(f"""
+        def parse(name, path):
+            name = self.encodeXmlAttr(name)
+            path = self.encodeXmlAttr(path)
+            manifest = self.getXmlManifest(
+                f"""
 <manifest>
  <remote name="default-remote" fetch="http://localhost" />
  <default remote="default-remote" revision="refs/heads/main" />
  <project name="{name}" path="{path}" />
 </manifest>
-""")
+"""
-      # Force the manifest to be parsed.
+            )
-      manifest.ToXml()
+            # Force the manifest to be parsed.
+            manifest.ToXml()
-    # Verify the parser is valid by default to avoid buggy tests below.
+        # Verify the parser is valid by default to avoid buggy tests below.
-    parse('ok', 'ok')
+        parse("ok", "ok")
-    # Handle empty name explicitly because a different codepath rejects it.
+        # Handle empty name explicitly because a different codepath rejects it.
-    # Empty path is OK because it defaults to the name field.
+        # Empty path is OK because it defaults to the name field.
-    with self.assertRaises(error.ManifestParseError):
+        with self.assertRaises(error.ManifestParseError):
-      parse('', 'ok')
+            parse("", "ok")
-    for path in INVALID_FS_PATHS:
+        for path in INVALID_FS_PATHS:
-      if not path or path.endswith('/') or path.endswith(os.path.sep):
+            if not path or path.endswith("/") or path.endswith(os.path.sep):
-        continue
+                continue
-      with self.assertRaises(error.ManifestInvalidPathError):
+            with self.assertRaises(error.ManifestInvalidPathError):
-        parse(path, 'ok')
+                parse(path, "ok")
-      # We have a dedicated test for path=".".
+            # We have a dedicated test for path=".".
-      if path not in {'.'}:
+            if path not in {"."}:
-        with self.assertRaises(error.ManifestInvalidPathError):
+                with self.assertRaises(error.ManifestInvalidPathError):
-          parse('ok', path)
+                    parse("ok", path)
 class SuperProjectElementTests(ManifestParseTestCase):
-  """Tests for <superproject>."""
+    """Tests for <superproject>."""
-  def test_superproject(self):
+    def test_superproject(self):
-    """Check superproject settings."""
+        """Check superproject settings."""
-    manifest = self.getXmlManifest("""
+        manifest = self.getXmlManifest(
+            """
 <manifest>
  <remote name="test-remote" fetch="http://localhost" />
  <default remote="test-remote" revision="refs/heads/main" />
  <superproject name="superproject"/>
 </manifest>
-""")
+"""
-    self.assertEqual(manifest.superproject.name, 'superproject')
+        )
-    self.assertEqual(manifest.superproject.remote.name, 'test-remote')
+        self.assertEqual(manifest.superproject.name, "superproject")
-    self.assertEqual(manifest.superproject.remote.url, 'http://localhost/superproject')
+        self.assertEqual(manifest.superproject.remote.name, "test-remote")
-    self.assertEqual(manifest.superproject.revision, 'refs/heads/main')
+        self.assertEqual(
-    self.assertEqual(
+            manifest.superproject.remote.url, "http://localhost/superproject"
-        sort_attributes(manifest.ToXml().toxml()),
+        )
-        '<?xml version="1.0" ?><manifest>'
+        self.assertEqual(manifest.superproject.revision, "refs/heads/main")
-        '<remote fetch="http://localhost" name="test-remote"/>'
+        self.assertEqual(
-        '<default remote="test-remote" revision="refs/heads/main"/>'
+            sort_attributes(manifest.ToXml().toxml()),
-        '<superproject name="superproject"/>'
+            '<?xml version="1.0" ?><manifest>'
-        '</manifest>')
+            '<remote fetch="http://localhost" name="test-remote"/>'
+            '<default remote="test-remote" revision="refs/heads/main"/>'
-  def test_superproject_revision(self):
+            '<superproject name="superproject"/>'
-    """Check superproject settings with a different revision attribute"""
+            "</manifest>",
-    self.maxDiff = None
+        )
-    manifest = self.getXmlManifest("""
+    def test_superproject_revision(self):
+        """Check superproject settings with a different revision attribute"""
+        self.maxDiff = None
+        manifest = self.getXmlManifest(
+            """
 <manifest>
  <remote name="test-remote" fetch="http://localhost" />
  <default remote="test-remote" revision="refs/heads/main" />
  <superproject name="superproject" revision="refs/heads/stable" />
 </manifest>
-""")
+"""
-    self.assertEqual(manifest.superproject.name, 'superproject')
+        )
-    self.assertEqual(manifest.superproject.remote.name, 'test-remote')
+        self.assertEqual(manifest.superproject.name, "superproject")
-    self.assertEqual(manifest.superproject.remote.url, 'http://localhost/superproject')
+        self.assertEqual(manifest.superproject.remote.name, "test-remote")
-    self.assertEqual(manifest.superproject.revision, 'refs/heads/stable')
+        self.assertEqual(
-    self.assertEqual(
+            manifest.superproject.remote.url, "http://localhost/superproject"
-        sort_attributes(manifest.ToXml().toxml()),
+        )
-        '<?xml version="1.0" ?><manifest>'
+        self.assertEqual(manifest.superproject.revision, "refs/heads/stable")
-        '<remote fetch="http://localhost" name="test-remote"/>'
+        self.assertEqual(
-        '<default remote="test-remote" revision="refs/heads/main"/>'
+            sort_attributes(manifest.ToXml().toxml()),
-        '<superproject name="superproject" revision="refs/heads/stable"/>'
+            '<?xml version="1.0" ?><manifest>'
-        '</manifest>')
+            '<remote fetch="http://localhost" name="test-remote"/>'
+            '<default remote="test-remote" revision="refs/heads/main"/>'
-  def test_superproject_revision_default_negative(self):
+            '<superproject name="superproject" revision="refs/heads/stable"/>'
-    """Check superproject settings with a same revision attribute"""
+            "</manifest>",
-    self.maxDiff = None
+        )
-    manifest = self.getXmlManifest("""
+    def test_superproject_revision_default_negative(self):
+        """Check superproject settings with a same revision attribute"""
+        self.maxDiff = None
+        manifest = self.getXmlManifest(
+            """
 <manifest>
  <remote name="test-remote" fetch="http://localhost" />
  <default remote="test-remote" revision="refs/heads/stable" />
  <superproject name="superproject" revision="refs/heads/stable" />
 </manifest>
-""")
+"""
-    self.assertEqual(manifest.superproject.name, 'superproject')
+        )
-    self.assertEqual(manifest.superproject.remote.name, 'test-remote')
+        self.assertEqual(manifest.superproject.name, "superproject")
-    self.assertEqual(manifest.superproject.remote.url, 'http://localhost/superproject')
+        self.assertEqual(manifest.superproject.remote.name, "test-remote")
-    self.assertEqual(manifest.superproject.revision, 'refs/heads/stable')
+        self.assertEqual(
-    self.assertEqual(
+            manifest.superproject.remote.url, "http://localhost/superproject"
-        sort_attributes(manifest.ToXml().toxml()),
+        )
-        '<?xml version="1.0" ?><manifest>'
+        self.assertEqual(manifest.superproject.revision, "refs/heads/stable")
-        '<remote fetch="http://localhost" name="test-remote"/>'
+        self.assertEqual(
-        '<default remote="test-remote" revision="refs/heads/stable"/>'
+            sort_attributes(manifest.ToXml().toxml()),
-        '<superproject name="superproject"/>'
+            '<?xml version="1.0" ?><manifest>'
-        '</manifest>')
+            '<remote fetch="http://localhost" name="test-remote"/>'
+            '<default remote="test-remote" revision="refs/heads/stable"/>'
-  def test_superproject_revision_remote(self):
+            '<superproject name="superproject"/>'
-    """Check superproject settings with a same revision attribute"""
+            "</manifest>",
-    self.maxDiff = None
+        )
-    manifest = self.getXmlManifest("""
+    def test_superproject_revision_remote(self):
+        """Check superproject settings with a same revision attribute"""
+        self.maxDiff = None
+        manifest = self.getXmlManifest(
+            """
 <manifest>
  <remote name="test-remote" fetch="http://localhost" revision="refs/heads/main" />
  <default remote="test-remote" />
  <superproject name="superproject" revision="refs/heads/stable" />
 </manifest>
-""")
+"""  # noqa: E501
-    self.assertEqual(manifest.superproject.name, 'superproject')
+        )
-    self.assertEqual(manifest.superproject.remote.name, 'test-remote')
+        self.assertEqual(manifest.superproject.name, "superproject")
-    self.assertEqual(manifest.superproject.remote.url, 'http://localhost/superproject')
+        self.assertEqual(manifest.superproject.remote.name, "test-remote")
-    self.assertEqual(manifest.superproject.revision, 'refs/heads/stable')
+        self.assertEqual(
-    self.assertEqual(
+            manifest.superproject.remote.url, "http://localhost/superproject"
-        sort_attributes(manifest.ToXml().toxml()),
+        )
-        '<?xml version="1.0" ?><manifest>'
+        self.assertEqual(manifest.superproject.revision, "refs/heads/stable")
-        '<remote fetch="http://localhost" name="test-remote" revision="refs/heads/main"/>'
+        self.assertEqual(
-        '<default remote="test-remote"/>'
+            sort_attributes(manifest.ToXml().toxml()),
-        '<superproject name="superproject" revision="refs/heads/stable"/>'
+            '<?xml version="1.0" ?><manifest>'
-        '</manifest>')
+            '<remote fetch="http://localhost" name="test-remote" revision="refs/heads/main"/>'  # noqa: E501
+            '<default remote="test-remote"/>'
-  def test_remote(self):
+            '<superproject name="superproject" revision="refs/heads/stable"/>'
-    """Check superproject settings with a remote."""
+            "</manifest>",
-    manifest = self.getXmlManifest("""
+        )
+    def test_remote(self):
+        """Check superproject settings with a remote."""
+        manifest = self.getXmlManifest(
+            """
 <manifest>
  <remote name="default-remote" fetch="http://localhost" />
  <remote name="superproject-remote" fetch="http://localhost" />
  <default remote="default-remote" revision="refs/heads/main" />
  <superproject name="platform/superproject" remote="superproject-remote"/>
 </manifest>
-""")
+"""
-    self.assertEqual(manifest.superproject.name, 'platform/superproject')
+        )
-    self.assertEqual(manifest.superproject.remote.name, 'superproject-remote')
+        self.assertEqual(manifest.superproject.name, "platform/superproject")
-    self.assertEqual(manifest.superproject.remote.url, 'http://localhost/platform/superproject')
+        self.assertEqual(
-    self.assertEqual(manifest.superproject.revision, 'refs/heads/main')
+            manifest.superproject.remote.name, "superproject-remote"
-    self.assertEqual(
+        )
-        sort_attributes(manifest.ToXml().toxml()),
+        self.assertEqual(
-        '<?xml version="1.0" ?><manifest>'
+            manifest.superproject.remote.url,
-        '<remote fetch="http://localhost" name="default-remote"/>'
+            "http://localhost/platform/superproject",
-        '<remote fetch="http://localhost" name="superproject-remote"/>'
+        )
-        '<default remote="default-remote" revision="refs/heads/main"/>'
+        self.assertEqual(manifest.superproject.revision, "refs/heads/main")
-        '<superproject name="platform/superproject" remote="superproject-remote"/>'
+        self.assertEqual(
-        '</manifest>')
+            sort_attributes(manifest.ToXml().toxml()),
+            '<?xml version="1.0" ?><manifest>'
-  def test_defalut_remote(self):
+            '<remote fetch="http://localhost" name="default-remote"/>'
-    """Check superproject settings with a default remote."""
+            '<remote fetch="http://localhost" name="superproject-remote"/>'
-    manifest = self.getXmlManifest("""
+            '<default remote="default-remote" revision="refs/heads/main"/>'
+            '<superproject name="platform/superproject" remote="superproject-remote"/>'  # noqa: E501
+            "</manifest>",
+        )
+    def test_defalut_remote(self):
+        """Check superproject settings with a default remote."""
+        manifest = self.getXmlManifest(
+            """
 <manifest>
  <remote name="default-remote" fetch="http://localhost" />
  <default remote="default-remote" revision="refs/heads/main" />
  <superproject name="superproject" remote="default-remote"/>
 </manifest>
-""")
+"""
-    self.assertEqual(manifest.superproject.name, 'superproject')
+        )
-    self.assertEqual(manifest.superproject.remote.name, 'default-remote')
+        self.assertEqual(manifest.superproject.name, "superproject")
-    self.assertEqual(manifest.superproject.revision, 'refs/heads/main')
+        self.assertEqual(manifest.superproject.remote.name, "default-remote")
-    self.assertEqual(
+        self.assertEqual(manifest.superproject.revision, "refs/heads/main")
-        sort_attributes(manifest.ToXml().toxml()),
+        self.assertEqual(
-        '<?xml version="1.0" ?><manifest>'
+            sort_attributes(manifest.ToXml().toxml()),
-        '<remote fetch="http://localhost" name="default-remote"/>'
+            '<?xml version="1.0" ?><manifest>'
-        '<default remote="default-remote" revision="refs/heads/main"/>'
+            '<remote fetch="http://localhost" name="default-remote"/>'
-        '<superproject name="superproject"/>'
+            '<default remote="default-remote" revision="refs/heads/main"/>'
-        '</manifest>')
+            '<superproject name="superproject"/>'
+            "</manifest>",
+        )
 class ContactinfoElementTests(ManifestParseTestCase):
-  """Tests for <contactinfo>."""
+    """Tests for <contactinfo>."""
-  def test_contactinfo(self):
+    def test_contactinfo(self):
-    """Check contactinfo settings."""
+        """Check contactinfo settings."""
-    bugurl = 'http://localhost/contactinfo'
+        bugurl = "http://localhost/contactinfo"
-    manifest = self.getXmlManifest(f"""
+        manifest = self.getXmlManifest(
+            f"""
 <manifest>
  <contactinfo bugurl="{bugurl}"/>
 </manifest>
-""")
+"""
-    self.assertEqual(manifest.contactinfo.bugurl, bugurl)
+        )
-    self.assertEqual(
+        self.assertEqual(manifest.contactinfo.bugurl, bugurl)
-        manifest.ToXml().toxml(),
+        self.assertEqual(
-        '<?xml version="1.0" ?><manifest>'
+            manifest.ToXml().toxml(),
-        f'<contactinfo bugurl="{bugurl}"/>'
+            '<?xml version="1.0" ?><manifest>'
-        '</manifest>')
+            f'<contactinfo bugurl="{bugurl}"/>'
+            "</manifest>",
+        )
 class DefaultElementTests(ManifestParseTestCase):
-  """Tests for <default>."""
+    """Tests for <default>."""
-  def test_default(self):
+    def test_default(self):
-    """Check default settings."""
+        """Check default settings."""
-    a = manifest_xml._Default()
+        a = manifest_xml._Default()
-    a.revisionExpr = 'foo'
+        a.revisionExpr = "foo"
-    a.remote = manifest_xml._XmlRemote(name='remote')
+        a.remote = manifest_xml._XmlRemote(name="remote")
-    b = manifest_xml._Default()
+        b = manifest_xml._Default()
-    b.revisionExpr = 'bar'
+        b.revisionExpr = "bar"
-    self.assertEqual(a, a)
+        self.assertEqual(a, a)
-    self.assertNotEqual(a, b)
+        self.assertNotEqual(a, b)
-    self.assertNotEqual(b, a.remote)
+        self.assertNotEqual(b, a.remote)
-    self.assertNotEqual(a, 123)
+        self.assertNotEqual(a, 123)
-    self.assertNotEqual(a, None)
+        self.assertNotEqual(a, None)
 class RemoteElementTests(ManifestParseTestCase):
-  """Tests for <remote>."""
+    """Tests for <remote>."""
-  def test_remote(self):
+    def test_remote(self):
-    """Check remote settings."""
+        """Check remote settings."""
-    a = manifest_xml._XmlRemote(name='foo')
+        a = manifest_xml._XmlRemote(name="foo")
-    a.AddAnnotation('key1', 'value1', 'true')
+        a.AddAnnotation("key1", "value1", "true")
-    b = manifest_xml._XmlRemote(name='foo')
+        b = manifest_xml._XmlRemote(name="foo")
-    b.AddAnnotation('key2', 'value1', 'true')
+        b.AddAnnotation("key2", "value1", "true")
-    c = manifest_xml._XmlRemote(name='foo')
+        c = manifest_xml._XmlRemote(name="foo")
-    c.AddAnnotation('key1', 'value2', 'true')
+        c.AddAnnotation("key1", "value2", "true")
-    d = manifest_xml._XmlRemote(name='foo')
+        d = manifest_xml._XmlRemote(name="foo")
-    d.AddAnnotation('key1', 'value1', 'false')
+        d.AddAnnotation("key1", "value1", "false")
-    self.assertEqual(a, a)
+        self.assertEqual(a, a)
-    self.assertNotEqual(a, b)
+        self.assertNotEqual(a, b)
-    self.assertNotEqual(a, c)
+        self.assertNotEqual(a, c)
-    self.assertNotEqual(a, d)
+        self.assertNotEqual(a, d)
-    self.assertNotEqual(a, manifest_xml._Default())
+        self.assertNotEqual(a, manifest_xml._Default())
-    self.assertNotEqual(a, 123)
+        self.assertNotEqual(a, 123)
-    self.assertNotEqual(a, None)
+        self.assertNotEqual(a, None)
 class RemoveProjectElementTests(ManifestParseTestCase):
-  """Tests for <remove-project>."""
+    """Tests for <remove-project>."""
-  def test_remove_one_project(self):
+    def test_remove_one_project(self):
-    manifest = self.getXmlManifest("""
+        manifest = self.getXmlManifest(
+            """
 <manifest>
  <remote name="default-remote" fetch="http://localhost" />
  <default remote="default-remote" revision="refs/heads/main" />
  <project name="myproject" />
  <remove-project name="myproject" />
 </manifest>
-""")
+"""
-    self.assertEqual(manifest.projects, [])
+        )
+        self.assertEqual(manifest.projects, [])
-  def test_remove_one_project_one_remains(self):
+    def test_remove_one_project_one_remains(self):
-    manifest = self.getXmlManifest("""
+        manifest = self.getXmlManifest(
+            """
 <manifest>
  <remote name="default-remote" fetch="http://localhost" />
  <default remote="default-remote" revision="refs/heads/main" />
@@ -803,51 +926,59 @@ class RemoveProjectElementTests(ManifestParseTestCase):
  <project name="yourproject" />
  <remove-project name="myproject" />
 </manifest>
-""")
+"""
+        )
-    self.assertEqual(len(manifest.projects), 1)
+        self.assertEqual(len(manifest.projects), 1)
-    self.assertEqual(manifest.projects[0].name, 'yourproject')
+        self.assertEqual(manifest.projects[0].name, "yourproject")
-  def test_remove_one_project_doesnt_exist(self):
+    def test_remove_one_project_doesnt_exist(self):
-    with self.assertRaises(manifest_xml.ManifestParseError):
+        with self.assertRaises(manifest_xml.ManifestParseError):
-      manifest = self.getXmlManifest("""
+            manifest = self.getXmlManifest(
+                """
 <manifest>
  <remote name="default-remote" fetch="http://localhost" />
  <default remote="default-remote" revision="refs/heads/main" />
  <remove-project name="myproject" />
 </manifest>
-""")
+"""
-      manifest.projects
+            )
+            manifest.projects
-  def test_remove_one_optional_project_doesnt_exist(self):
+    def test_remove_one_optional_project_doesnt_exist(self):
-    manifest = self.getXmlManifest("""
+        manifest = self.getXmlManifest(
+            """
 <manifest>
  <remote name="default-remote" fetch="http://localhost" />
  <default remote="default-remote" revision="refs/heads/main" />
  <remove-project name="myproject" optional="true" />
 </manifest>
-""")
+"""
-    self.assertEqual(manifest.projects, [])
+        )
+        self.assertEqual(manifest.projects, [])
 class ExtendProjectElementTests(ManifestParseTestCase):
-  """Tests for <extend-project>."""
+    """Tests for <extend-project>."""
-  def test_extend_project_dest_path_single_match(self):
+    def test_extend_project_dest_path_single_match(self):
-    manifest = self.getXmlManifest("""
+        manifest = self.getXmlManifest(
+            """
 <manifest>
  <remote name="default-remote" fetch="http://localhost" />
  <default remote="default-remote" revision="refs/heads/main" />
  <project name="myproject" />
  <extend-project name="myproject" dest-path="bar" />
 </manifest>
-""")
+"""
-    self.assertEqual(len(manifest.projects), 1)
+        )
-    self.assertEqual(manifest.projects[0].relpath, 'bar')
+        self.assertEqual(len(manifest.projects), 1)
+        self.assertEqual(manifest.projects[0].relpath, "bar")
-  def test_extend_project_dest_path_multi_match(self):
-    with self.assertRaises(manifest_xml.ManifestParseError):
+    def test_extend_project_dest_path_multi_match(self):
-      manifest = self.getXmlManifest("""
+        with self.assertRaises(manifest_xml.ManifestParseError):
+            manifest = self.getXmlManifest(
+                """
 <manifest>
  <remote name="default-remote" fetch="http://localhost" />
  <default remote="default-remote" revision="refs/heads/main" />
@@ -855,11 +986,13 @@ class ExtendProjectElementTests(ManifestParseTestCase):
  <project name="myproject" path="y" />
  <extend-project name="myproject" dest-path="bar" />
 </manifest>
-""")
+"""
-      manifest.projects
+            )
+            manifest.projects
-  def test_extend_project_dest_path_multi_match_path_specified(self):
+    def test_extend_project_dest_path_multi_match_path_specified(self):
-    manifest = self.getXmlManifest("""
+        manifest = self.getXmlManifest(
+            """
 <manifest>
  <remote name="default-remote" fetch="http://localhost" />
  <default remote="default-remote" revision="refs/heads/main" />
@@ -867,34 +1000,39 @@ class ExtendProjectElementTests(ManifestParseTestCase):
  <project name="myproject" path="y" />
  <extend-project name="myproject" path="x" dest-path="bar" />
 </manifest>
-""")
+"""
-    self.assertEqual(len(manifest.projects), 2)
+        )
-    if manifest.projects[0].relpath == 'y':
+        self.assertEqual(len(manifest.projects), 2)
-      self.assertEqual(manifest.projects[1].relpath, 'bar')
+        if manifest.projects[0].relpath == "y":
-    else:
+            self.assertEqual(manifest.projects[1].relpath, "bar")
-      self.assertEqual(manifest.projects[0].relpath, 'bar')
+        else:
-      self.assertEqual(manifest.projects[1].relpath, 'y')
+            self.assertEqual(manifest.projects[0].relpath, "bar")
+            self.assertEqual(manifest.projects[1].relpath, "y")
-  def test_extend_project_dest_branch(self):
-    manifest = self.getXmlManifest("""
+    def test_extend_project_dest_branch(self):
+        manifest = self.getXmlManifest(
+            """
 <manifest>
  <remote name="default-remote" fetch="http://localhost" />
  <default remote="default-remote" revision="refs/heads/main" dest-branch="foo" />
  <project name="myproject" />
  <extend-project name="myproject" dest-branch="bar" />
 </manifest>
-""")
+"""  # noqa: E501
-    self.assertEqual(len(manifest.projects), 1)
+        )
-    self.assertEqual(manifest.projects[0].dest_branch, 'bar')
+        self.assertEqual(len(manifest.projects), 1)
+        self.assertEqual(manifest.projects[0].dest_branch, "bar")
-  def test_extend_project_upstream(self):
-    manifest = self.getXmlManifest("""
+    def test_extend_project_upstream(self):
+        manifest = self.getXmlManifest(
+            """
 <manifest>
  <remote name="default-remote" fetch="http://localhost" />
  <default remote="default-remote" revision="refs/heads/main" />
  <project name="myproject" />
  <extend-project name="myproject" upstream="bar" />
 </manifest>
-""")
+"""
-    self.assertEqual(len(manifest.projects), 1)
+        )
-    self.assertEqual(manifest.projects[0].upstream, 'bar')
+        self.assertEqual(len(manifest.projects), 1)
+        self.assertEqual(manifest.projects[0].upstream, "bar")
diff --git a/tests/test_platform_utils.py b/tests/test_platform_utils.py
index 55b7805c..7a42de01 100644
--- a/tests/test_platform_utils.py
+++ b/tests/test_platform_utils.py
@@ -22,29 +22,31 @@ import platform_utils
 class RemoveTests(unittest.TestCase):
-  """Check remove() helper."""
+    """Check remove() helper."""
-  def testMissingOk(self):
+    def testMissingOk(self):
-    """Check missing_ok handling."""
+        """Check missing_ok handling."""
-    with tempfile.TemporaryDirectory() as tmpdir:
+        with tempfile.TemporaryDirectory() as tmpdir:
-      path = os.path.join(tmpdir, 'test')
+            path = os.path.join(tmpdir, "test")
-      # Should not fail.
+            # Should not fail.
-      platform_utils.remove(path, missing_ok=True)
+            platform_utils.remove(path, missing_ok=True)
-      # Should fail.
+            # Should fail.
-      self.assertRaises(OSError, platform_utils.remove, path)
+            self.assertRaises(OSError, platform_utils.remove, path)
-      self.assertRaises(OSError, platform_utils.remove, path, missing_ok=False)
+            self.assertRaises(
+                OSError, platform_utils.remove, path, missing_ok=False
-      # Should not fail if it exists.
+            )
-      open(path, 'w').close()
-      platform_utils.remove(path, missing_ok=True)
+            # Should not fail if it exists.
-      self.assertFalse(os.path.exists(path))
+            open(path, "w").close()
+            platform_utils.remove(path, missing_ok=True)
-      open(path, 'w').close()
+            self.assertFalse(os.path.exists(path))
-      platform_utils.remove(path)
-      self.assertFalse(os.path.exists(path))
+            open(path, "w").close()
+            platform_utils.remove(path)
-      open(path, 'w').close()
+            self.assertFalse(os.path.exists(path))
-      platform_utils.remove(path, missing_ok=False)
-      self.assertFalse(os.path.exists(path))
+            open(path, "w").close()
+            platform_utils.remove(path, missing_ok=False)
+            self.assertFalse(os.path.exists(path))
diff --git a/tests/test_project.py b/tests/test_project.py
index c50d9940..bc8330b2 100644
--- a/tests/test_project.py
+++ b/tests/test_project.py
@@ -31,452 +31,493 @@ import project
 @contextlib.contextmanager
 def TempGitTree():
-  """Create a new empty git checkout for testing."""
+    """Create a new empty git checkout for testing."""
-  with tempfile.TemporaryDirectory(prefix='repo-tests') as tempdir:
+    with tempfile.TemporaryDirectory(prefix="repo-tests") as tempdir:
-    # Tests need to assume, that main is default branch at init,
+        # Tests need to assume, that main is default branch at init,
-    # which is not supported in config until 2.28.
+        # which is not supported in config until 2.28.
-    cmd = ['git', 'init']
+        cmd = ["git", "init"]
-    if git_command.git_require((2, 28, 0)):
+        if git_command.git_require((2, 28, 0)):
-      cmd += ['--initial-branch=main']
+            cmd += ["--initial-branch=main"]
-    else:
+        else:
-      # Use template dir for init.
+            # Use template dir for init.
-      templatedir = tempfile.mkdtemp(prefix='.test-template')
+            templatedir = tempfile.mkdtemp(prefix=".test-template")
-      with open(os.path.join(templatedir, 'HEAD'), 'w') as fp:
+            with open(os.path.join(templatedir, "HEAD"), "w") as fp:
-        fp.write('ref: refs/heads/main\n')
+                fp.write("ref: refs/heads/main\n")
-      cmd += ['--template', templatedir]
+            cmd += ["--template", templatedir]
-    subprocess.check_call(cmd, cwd=tempdir)
+        subprocess.check_call(cmd, cwd=tempdir)
-    yield tempdir
+        yield tempdir
 class FakeProject(object):
-  """A fake for Project for basic functionality."""
+    """A fake for Project for basic functionality."""
-  def __init__(self, worktree):
+    def __init__(self, worktree):
-    self.worktree = worktree
+        self.worktree = worktree
-    self.gitdir = os.path.join(worktree, '.git')
+        self.gitdir = os.path.join(worktree, ".git")
-    self.name = 'fakeproject'
+        self.name = "fakeproject"
-    self.work_git = project.Project._GitGetByExec(
+        self.work_git = project.Project._GitGetByExec(
-        self, bare=False, gitdir=self.gitdir)
+            self, bare=False, gitdir=self.gitdir
-    self.bare_git = project.Project._GitGetByExec(
+        )
-        self, bare=True, gitdir=self.gitdir)
+        self.bare_git = project.Project._GitGetByExec(
-    self.config = git_config.GitConfig.ForRepository(gitdir=self.gitdir)
+            self, bare=True, gitdir=self.gitdir
+        )
+        self.config = git_config.GitConfig.ForRepository(gitdir=self.gitdir)
 class ReviewableBranchTests(unittest.TestCase):
-  """Check ReviewableBranch behavior."""
+    """Check ReviewableBranch behavior."""
-  def test_smoke(self):
+    def test_smoke(self):
-    """A quick run through everything."""
+        """A quick run through everything."""
-    with TempGitTree() as tempdir:
+        with TempGitTree() as tempdir:
-      fakeproj = FakeProject(tempdir)
+            fakeproj = FakeProject(tempdir)
-      # Generate some commits.
+            # Generate some commits.
-      with open(os.path.join(tempdir, 'readme'), 'w') as fp:
+            with open(os.path.join(tempdir, "readme"), "w") as fp:
-        fp.write('txt')
+                fp.write("txt")
-      fakeproj.work_git.add('readme')
+            fakeproj.work_git.add("readme")
-      fakeproj.work_git.commit('-mAdd file')
+            fakeproj.work_git.commit("-mAdd file")
-      fakeproj.work_git.checkout('-b', 'work')
+            fakeproj.work_git.checkout("-b", "work")
-      fakeproj.work_git.rm('-f', 'readme')
+            fakeproj.work_git.rm("-f", "readme")
-      fakeproj.work_git.commit('-mDel file')
+            fakeproj.work_git.commit("-mDel file")
-      # Start off with the normal details.
+            # Start off with the normal details.
-      rb = project.ReviewableBranch(
+            rb = project.ReviewableBranch(
-          fakeproj, fakeproj.config.GetBranch('work'), 'main')
+                fakeproj, fakeproj.config.GetBranch("work"), "main"
-      self.assertEqual('work', rb.name)
+            )
-      self.assertEqual(1, len(rb.commits))
+            self.assertEqual("work", rb.name)
-      self.assertIn('Del file', rb.commits[0])
+            self.assertEqual(1, len(rb.commits))
-      d = rb.unabbrev_commits
+            self.assertIn("Del file", rb.commits[0])
-      self.assertEqual(1, len(d))
+            d = rb.unabbrev_commits
-      short, long = next(iter(d.items()))
+            self.assertEqual(1, len(d))
-      self.assertTrue(long.startswith(short))
+            short, long = next(iter(d.items()))
-      self.assertTrue(rb.base_exists)
+            self.assertTrue(long.startswith(short))
-      # Hard to assert anything useful about this.
+            self.assertTrue(rb.base_exists)
-      self.assertTrue(rb.date)
+            # Hard to assert anything useful about this.
+            self.assertTrue(rb.date)
-      # Now delete the tracking branch!
-      fakeproj.work_git.branch('-D', 'main')
+            # Now delete the tracking branch!
-      rb = project.ReviewableBranch(
+            fakeproj.work_git.branch("-D", "main")
-          fakeproj, fakeproj.config.GetBranch('work'), 'main')
+            rb = project.ReviewableBranch(
-      self.assertEqual(0, len(rb.commits))
+                fakeproj, fakeproj.config.GetBranch("work"), "main"
-      self.assertFalse(rb.base_exists)
+            )
-      # Hard to assert anything useful about this.
+            self.assertEqual(0, len(rb.commits))
-      self.assertTrue(rb.date)
+            self.assertFalse(rb.base_exists)
+            # Hard to assert anything useful about this.
+            self.assertTrue(rb.date)
 class CopyLinkTestCase(unittest.TestCase):
-  """TestCase for stub repo client checkouts.
+    """TestCase for stub repo client checkouts.
-  It'll have a layout like this:
+    It'll have a layout like this:
-    tempdir/          # self.tempdir
+      tempdir/          # self.tempdir
-      checkout/       # self.topdir
+        checkout/       # self.topdir
-        git-project/  # self.worktree
+          git-project/  # self.worktree
-  Attributes:
+    Attributes:
-    tempdir: A dedicated temporary directory.
+      tempdir: A dedicated temporary directory.
-    worktree: The top of the repo client checkout.
+      worktree: The top of the repo client checkout.
-    topdir: The top of a project checkout.
+      topdir: The top of a project checkout.
-  """
+    """
-  def setUp(self):
+    def setUp(self):
-    self.tempdirobj = tempfile.TemporaryDirectory(prefix='repo_tests')
+        self.tempdirobj = tempfile.TemporaryDirectory(prefix="repo_tests")
-    self.tempdir = self.tempdirobj.name
+        self.tempdir = self.tempdirobj.name
-    self.topdir = os.path.join(self.tempdir, 'checkout')
+        self.topdir = os.path.join(self.tempdir, "checkout")
-    self.worktree = os.path.join(self.topdir, 'git-project')
+        self.worktree = os.path.join(self.topdir, "git-project")
-    os.makedirs(self.topdir)
+        os.makedirs(self.topdir)
-    os.makedirs(self.worktree)
+        os.makedirs(self.worktree)
-  def tearDown(self):
+    def tearDown(self):
-    self.tempdirobj.cleanup()
+        self.tempdirobj.cleanup()
-  @staticmethod
+    @staticmethod
-  def touch(path):
+    def touch(path):
-    with open(path, 'w'):
+        with open(path, "w"):
-      pass
+            pass
-  def assertExists(self, path, msg=None):
+    def assertExists(self, path, msg=None):
-    """Make sure |path| exists."""
+        """Make sure |path| exists."""
-    if os.path.exists(path):
+        if os.path.exists(path):
-      return
+            return
-    if msg is None:
+        if msg is None:
-      msg = ['path is missing: %s' % path]
+            msg = ["path is missing: %s" % path]
-      while path != '/':
+            while path != "/":
-        path = os.path.dirname(path)
+                path = os.path.dirname(path)
-        if not path:
+                if not path:
-          # If we're given something like "foo", abort once we get to "".
+                    # If we're given something like "foo", abort once we get to
-          break
+                    # "".
-        result = os.path.exists(path)
+                    break
-        msg.append('\tos.path.exists(%s): %s' % (path, result))
+                result = os.path.exists(path)
-        if result:
+                msg.append("\tos.path.exists(%s): %s" % (path, result))
-          msg.append('\tcontents: %r' % os.listdir(path))
+                if result:
-          break
+                    msg.append("\tcontents: %r" % os.listdir(path))
-      msg = '\n'.join(msg)
+                    break
+            msg = "\n".join(msg)
-    raise self.failureException(msg)
+        raise self.failureException(msg)
 class CopyFile(CopyLinkTestCase):
-  """Check _CopyFile handling."""
+    """Check _CopyFile handling."""
-  def CopyFile(self, src, dest):
+    def CopyFile(self, src, dest):
-    return project._CopyFile(self.worktree, src, self.topdir, dest)
+        return project._CopyFile(self.worktree, src, self.topdir, dest)
-  def test_basic(self):
+    def test_basic(self):
-    """Basic test of copying a file from a project to the toplevel."""
+        """Basic test of copying a file from a project to the toplevel."""
-    src = os.path.join(self.worktree, 'foo.txt')
+        src = os.path.join(self.worktree, "foo.txt")
-    self.touch(src)
+        self.touch(src)
-    cf = self.CopyFile('foo.txt', 'foo')
+        cf = self.CopyFile("foo.txt", "foo")
-    cf._Copy()
+        cf._Copy()
-    self.assertExists(os.path.join(self.topdir, 'foo'))
+        self.assertExists(os.path.join(self.topdir, "foo"))
-  def test_src_subdir(self):
+    def test_src_subdir(self):
-    """Copy a file from a subdir of a project."""
+        """Copy a file from a subdir of a project."""
-    src = os.path.join(self.worktree, 'bar', 'foo.txt')
+        src = os.path.join(self.worktree, "bar", "foo.txt")
-    os.makedirs(os.path.dirname(src))
+        os.makedirs(os.path.dirname(src))
-    self.touch(src)
+        self.touch(src)
-    cf = self.CopyFile('bar/foo.txt', 'new.txt')
+        cf = self.CopyFile("bar/foo.txt", "new.txt")
-    cf._Copy()
+        cf._Copy()
-    self.assertExists(os.path.join(self.topdir, 'new.txt'))
+        self.assertExists(os.path.join(self.topdir, "new.txt"))
-  def test_dest_subdir(self):
+    def test_dest_subdir(self):
-    """Copy a file to a subdir of a checkout."""
+        """Copy a file to a subdir of a checkout."""
-    src = os.path.join(self.worktree, 'foo.txt')
+        src = os.path.join(self.worktree, "foo.txt")
-    self.touch(src)
+        self.touch(src)
-    cf = self.CopyFile('foo.txt', 'sub/dir/new.txt')
+        cf = self.CopyFile("foo.txt", "sub/dir/new.txt")
-    self.assertFalse(os.path.exists(os.path.join(self.topdir, 'sub')))
+        self.assertFalse(os.path.exists(os.path.join(self.topdir, "sub")))
-    cf._Copy()
+        cf._Copy()
-    self.assertExists(os.path.join(self.topdir, 'sub', 'dir', 'new.txt'))
+        self.assertExists(os.path.join(self.topdir, "sub", "dir", "new.txt"))
-  def test_update(self):
+    def test_update(self):
-    """Make sure changed files get copied again."""
+        """Make sure changed files get copied again."""
-    src = os.path.join(self.worktree, 'foo.txt')
+        src = os.path.join(self.worktree, "foo.txt")
-    dest = os.path.join(self.topdir, 'bar')
+        dest = os.path.join(self.topdir, "bar")
-    with open(src, 'w') as f:
+        with open(src, "w") as f:
-      f.write('1st')
+            f.write("1st")
-    cf = self.CopyFile('foo.txt', 'bar')
+        cf = self.CopyFile("foo.txt", "bar")
-    cf._Copy()
+        cf._Copy()
-    self.assertExists(dest)
+        self.assertExists(dest)
-    with open(dest) as f:
+        with open(dest) as f:
-      self.assertEqual(f.read(), '1st')
+            self.assertEqual(f.read(), "1st")
-    with open(src, 'w') as f:
+        with open(src, "w") as f:
-      f.write('2nd!')
+            f.write("2nd!")
-    cf._Copy()
+        cf._Copy()
-    with open(dest) as f:
+        with open(dest) as f:
-      self.assertEqual(f.read(), '2nd!')
+            self.assertEqual(f.read(), "2nd!")
-  def test_src_block_symlink(self):
+    def test_src_block_symlink(self):
-    """Do not allow reading from a symlinked path."""
+        """Do not allow reading from a symlinked path."""
-    src = os.path.join(self.worktree, 'foo.txt')
+        src = os.path.join(self.worktree, "foo.txt")
-    sym = os.path.join(self.worktree, 'sym')
+        sym = os.path.join(self.worktree, "sym")
-    self.touch(src)
+        self.touch(src)
-    platform_utils.symlink('foo.txt', sym)
+        platform_utils.symlink("foo.txt", sym)
-    self.assertExists(sym)
+        self.assertExists(sym)
-    cf = self.CopyFile('sym', 'foo')
+        cf = self.CopyFile("sym", "foo")
-    self.assertRaises(error.ManifestInvalidPathError, cf._Copy)
+        self.assertRaises(error.ManifestInvalidPathError, cf._Copy)
-  def test_src_block_symlink_traversal(self):
+    def test_src_block_symlink_traversal(self):
-    """Do not allow reading through a symlink dir."""
+        """Do not allow reading through a symlink dir."""
-    realfile = os.path.join(self.tempdir, 'file.txt')
+        realfile = os.path.join(self.tempdir, "file.txt")
-    self.touch(realfile)
+        self.touch(realfile)
-    src = os.path.join(self.worktree, 'bar', 'file.txt')
+        src = os.path.join(self.worktree, "bar", "file.txt")
-    platform_utils.symlink(self.tempdir, os.path.join(self.worktree, 'bar'))
+        platform_utils.symlink(self.tempdir, os.path.join(self.worktree, "bar"))
-    self.assertExists(src)
+        self.assertExists(src)
-    cf = self.CopyFile('bar/file.txt', 'foo')
+        cf = self.CopyFile("bar/file.txt", "foo")
-    self.assertRaises(error.ManifestInvalidPathError, cf._Copy)
+        self.assertRaises(error.ManifestInvalidPathError, cf._Copy)
-  def test_src_block_copy_from_dir(self):
+    def test_src_block_copy_from_dir(self):
-    """Do not allow copying from a directory."""
+        """Do not allow copying from a directory."""
-    src = os.path.join(self.worktree, 'dir')
+        src = os.path.join(self.worktree, "dir")
-    os.makedirs(src)
+        os.makedirs(src)
-    cf = self.CopyFile('dir', 'foo')
+        cf = self.CopyFile("dir", "foo")
-    self.assertRaises(error.ManifestInvalidPathError, cf._Copy)
+        self.assertRaises(error.ManifestInvalidPathError, cf._Copy)
-  def test_dest_block_symlink(self):
+    def test_dest_block_symlink(self):
-    """Do not allow writing to a symlink."""
+        """Do not allow writing to a symlink."""
-    src = os.path.join(self.worktree, 'foo.txt')
+        src = os.path.join(self.worktree, "foo.txt")
-    self.touch(src)
+        self.touch(src)
-    platform_utils.symlink('dest', os.path.join(self.topdir, 'sym'))
+        platform_utils.symlink("dest", os.path.join(self.topdir, "sym"))
-    cf = self.CopyFile('foo.txt', 'sym')
+        cf = self.CopyFile("foo.txt", "sym")
-    self.assertRaises(error.ManifestInvalidPathError, cf._Copy)
+        self.assertRaises(error.ManifestInvalidPathError, cf._Copy)
-  def test_dest_block_symlink_traversal(self):
+    def test_dest_block_symlink_traversal(self):
-    """Do not allow writing through a symlink dir."""
+        """Do not allow writing through a symlink dir."""
-    src = os.path.join(self.worktree, 'foo.txt')
+        src = os.path.join(self.worktree, "foo.txt")
-    self.touch(src)
+        self.touch(src)
-    platform_utils.symlink(tempfile.gettempdir(),
+        platform_utils.symlink(
-                           os.path.join(self.topdir, 'sym'))
+            tempfile.gettempdir(), os.path.join(self.topdir, "sym")
-    cf = self.CopyFile('foo.txt', 'sym/foo.txt')
+        )
-    self.assertRaises(error.ManifestInvalidPathError, cf._Copy)
+        cf = self.CopyFile("foo.txt", "sym/foo.txt")
+        self.assertRaises(error.ManifestInvalidPathError, cf._Copy)
-  def test_src_block_copy_to_dir(self):
-    """Do not allow copying to a directory."""
+    def test_src_block_copy_to_dir(self):
-    src = os.path.join(self.worktree, 'foo.txt')
+        """Do not allow copying to a directory."""
-    self.touch(src)
+        src = os.path.join(self.worktree, "foo.txt")
-    os.makedirs(os.path.join(self.topdir, 'dir'))
+        self.touch(src)
-    cf = self.CopyFile('foo.txt', 'dir')
+        os.makedirs(os.path.join(self.topdir, "dir"))
-    self.assertRaises(error.ManifestInvalidPathError, cf._Copy)
+        cf = self.CopyFile("foo.txt", "dir")
+        self.assertRaises(error.ManifestInvalidPathError, cf._Copy)
 class LinkFile(CopyLinkTestCase):
-  """Check _LinkFile handling."""
+    """Check _LinkFile handling."""
-  def LinkFile(self, src, dest):
+    def LinkFile(self, src, dest):
-    return project._LinkFile(self.worktree, src, self.topdir, dest)
+        return project._LinkFile(self.worktree, src, self.topdir, dest)
-  def test_basic(self):
+    def test_basic(self):
-    """Basic test of linking a file from a project into the toplevel."""
+        """Basic test of linking a file from a project into the toplevel."""
-    src = os.path.join(self.worktree, 'foo.txt')
+        src = os.path.join(self.worktree, "foo.txt")
-    self.touch(src)
+        self.touch(src)
-    lf = self.LinkFile('foo.txt', 'foo')
+        lf = self.LinkFile("foo.txt", "foo")
-    lf._Link()
+        lf._Link()
-    dest = os.path.join(self.topdir, 'foo')
+        dest = os.path.join(self.topdir, "foo")
-    self.assertExists(dest)
+        self.assertExists(dest)
-    self.assertTrue(os.path.islink(dest))
+        self.assertTrue(os.path.islink(dest))
-    self.assertEqual(os.path.join('git-project', 'foo.txt'), os.readlink(dest))
+        self.assertEqual(
+            os.path.join("git-project", "foo.txt"), os.readlink(dest)
-  def test_src_subdir(self):
+        )
-    """Link to a file in a subdir of a project."""
-    src = os.path.join(self.worktree, 'bar', 'foo.txt')
+    def test_src_subdir(self):
-    os.makedirs(os.path.dirname(src))
+        """Link to a file in a subdir of a project."""
-    self.touch(src)
+        src = os.path.join(self.worktree, "bar", "foo.txt")
-    lf = self.LinkFile('bar/foo.txt', 'foo')
+        os.makedirs(os.path.dirname(src))
-    lf._Link()
+        self.touch(src)
-    self.assertExists(os.path.join(self.topdir, 'foo'))
+        lf = self.LinkFile("bar/foo.txt", "foo")
+        lf._Link()
-  def test_src_self(self):
+        self.assertExists(os.path.join(self.topdir, "foo"))
-    """Link to the project itself."""
-    dest = os.path.join(self.topdir, 'foo', 'bar')
+    def test_src_self(self):
-    lf = self.LinkFile('.', 'foo/bar')
+        """Link to the project itself."""
-    lf._Link()
+        dest = os.path.join(self.topdir, "foo", "bar")
-    self.assertExists(dest)
+        lf = self.LinkFile(".", "foo/bar")
-    self.assertEqual(os.path.join('..', 'git-project'), os.readlink(dest))
+        lf._Link()
+        self.assertExists(dest)
-  def test_dest_subdir(self):
+        self.assertEqual(os.path.join("..", "git-project"), os.readlink(dest))
-    """Link a file to a subdir of a checkout."""
-    src = os.path.join(self.worktree, 'foo.txt')
+    def test_dest_subdir(self):
-    self.touch(src)
+        """Link a file to a subdir of a checkout."""
-    lf = self.LinkFile('foo.txt', 'sub/dir/foo/bar')
+        src = os.path.join(self.worktree, "foo.txt")
-    self.assertFalse(os.path.exists(os.path.join(self.topdir, 'sub')))
+        self.touch(src)
-    lf._Link()
+        lf = self.LinkFile("foo.txt", "sub/dir/foo/bar")
-    self.assertExists(os.path.join(self.topdir, 'sub', 'dir', 'foo', 'bar'))
+        self.assertFalse(os.path.exists(os.path.join(self.topdir, "sub")))
+        lf._Link()
-  def test_src_block_relative(self):
+        self.assertExists(os.path.join(self.topdir, "sub", "dir", "foo", "bar"))
-    """Do not allow relative symlinks."""
-    BAD_SOURCES = (
+    def test_src_block_relative(self):
-        './',
+        """Do not allow relative symlinks."""
-        '..',
+        BAD_SOURCES = (
-        '../',
+            "./",
-        'foo/.',
+            "..",
-        'foo/./bar',
+            "../",
-        'foo/..',
+            "foo/.",
-        'foo/../foo',
+            "foo/./bar",
-    )
+            "foo/..",
-    for src in BAD_SOURCES:
+            "foo/../foo",
-      lf = self.LinkFile(src, 'foo')
+        )
-      self.assertRaises(error.ManifestInvalidPathError, lf._Link)
+        for src in BAD_SOURCES:
+            lf = self.LinkFile(src, "foo")
-  def test_update(self):
+            self.assertRaises(error.ManifestInvalidPathError, lf._Link)
-    """Make sure changed targets get updated."""
-    dest = os.path.join(self.topdir, 'sym')
+    def test_update(self):
+        """Make sure changed targets get updated."""
-    src = os.path.join(self.worktree, 'foo.txt')
+        dest = os.path.join(self.topdir, "sym")
-    self.touch(src)
-    lf = self.LinkFile('foo.txt', 'sym')
+        src = os.path.join(self.worktree, "foo.txt")
-    lf._Link()
+        self.touch(src)
-    self.assertEqual(os.path.join('git-project', 'foo.txt'), os.readlink(dest))
+        lf = self.LinkFile("foo.txt", "sym")
+        lf._Link()
-    # Point the symlink somewhere else.
+        self.assertEqual(
-    os.unlink(dest)
+            os.path.join("git-project", "foo.txt"), os.readlink(dest)
-    platform_utils.symlink(self.tempdir, dest)
+        )
-    lf._Link()
-    self.assertEqual(os.path.join('git-project', 'foo.txt'), os.readlink(dest))
+        # Point the symlink somewhere else.
+        os.unlink(dest)
+        platform_utils.symlink(self.tempdir, dest)
+        lf._Link()
+        self.assertEqual(
+            os.path.join("git-project", "foo.txt"), os.readlink(dest)
+        )
 class MigrateWorkTreeTests(unittest.TestCase):
-  """Check _MigrateOldWorkTreeGitDir handling."""
+    """Check _MigrateOldWorkTreeGitDir handling."""
-  _SYMLINKS = {
+    _SYMLINKS = {
-      'config', 'description', 'hooks', 'info', 'logs', 'objects',
+        "config",
-      'packed-refs', 'refs', 'rr-cache', 'shallow', 'svn',
+        "description",
-  }
+        "hooks",
-  _FILES = {
+        "info",
-      'COMMIT_EDITMSG', 'FETCH_HEAD', 'HEAD', 'index', 'ORIG_HEAD',
+        "logs",
-      'unknown-file-should-be-migrated',
+        "objects",
-  }
+        "packed-refs",
-  _CLEAN_FILES = {
+        "refs",
-      'a-vim-temp-file~', '#an-emacs-temp-file#',
+        "rr-cache",
-  }
+        "shallow",
+        "svn",
-  @classmethod
+    }
-  @contextlib.contextmanager
+    _FILES = {
-  def _simple_layout(cls):
+        "COMMIT_EDITMSG",
-    """Create a simple repo client checkout to test against."""
+        "FETCH_HEAD",
-    with tempfile.TemporaryDirectory() as tempdir:
+        "HEAD",
-      tempdir = Path(tempdir)
+        "index",
+        "ORIG_HEAD",
-      gitdir = tempdir / '.repo/projects/src/test.git'
+        "unknown-file-should-be-migrated",
-      gitdir.mkdir(parents=True)
+    }
-      cmd = ['git', 'init', '--bare', str(gitdir)]
+    _CLEAN_FILES = {
-      subprocess.check_call(cmd)
+        "a-vim-temp-file~",
+        "#an-emacs-temp-file#",
-      dotgit = tempdir / 'src/test/.git'
+    }
-      dotgit.mkdir(parents=True)
-      for name in cls._SYMLINKS:
+    @classmethod
-        (dotgit / name).symlink_to(f'../../../.repo/projects/src/test.git/{name}')
+    @contextlib.contextmanager
-      for name in cls._FILES | cls._CLEAN_FILES:
+    def _simple_layout(cls):
-        (dotgit / name).write_text(name)
+        """Create a simple repo client checkout to test against."""
+        with tempfile.TemporaryDirectory() as tempdir:
-      yield tempdir
+            tempdir = Path(tempdir)
-  def test_standard(self):
+            gitdir = tempdir / ".repo/projects/src/test.git"
-    """Migrate a standard checkout that we expect."""
+            gitdir.mkdir(parents=True)
-    with self._simple_layout() as tempdir:
+            cmd = ["git", "init", "--bare", str(gitdir)]
-      dotgit = tempdir / 'src/test/.git'
+            subprocess.check_call(cmd)
-      project.Project._MigrateOldWorkTreeGitDir(str(dotgit))
+            dotgit = tempdir / "src/test/.git"
-      # Make sure the dir was transformed into a symlink.
+            dotgit.mkdir(parents=True)
-      self.assertTrue(dotgit.is_symlink())
+            for name in cls._SYMLINKS:
-      self.assertEqual(os.readlink(dotgit), os.path.normpath('../../.repo/projects/src/test.git'))
+                (dotgit / name).symlink_to(
+                    f"../../../.repo/projects/src/test.git/{name}"
-      # Make sure files were moved over.
+                )
-      gitdir = tempdir / '.repo/projects/src/test.git'
+            for name in cls._FILES | cls._CLEAN_FILES:
-      for name in self._FILES:
+                (dotgit / name).write_text(name)
-        self.assertEqual(name, (gitdir / name).read_text())
-      # Make sure files were removed.
+            yield tempdir
-      for name in self._CLEAN_FILES:
-        self.assertFalse((gitdir / name).exists())
+    def test_standard(self):
+        """Migrate a standard checkout that we expect."""
-  def test_unknown(self):
+        with self._simple_layout() as tempdir:
-    """A checkout with unknown files should abort."""
+            dotgit = tempdir / "src/test/.git"
-    with self._simple_layout() as tempdir:
+            project.Project._MigrateOldWorkTreeGitDir(str(dotgit))
-      dotgit = tempdir / 'src/test/.git'
-      (tempdir / '.repo/projects/src/test.git/random-file').write_text('one')
+            # Make sure the dir was transformed into a symlink.
-      (dotgit / 'random-file').write_text('two')
+            self.assertTrue(dotgit.is_symlink())
-      with self.assertRaises(error.GitError):
+            self.assertEqual(
-        project.Project._MigrateOldWorkTreeGitDir(str(dotgit))
+                os.readlink(dotgit),
+                os.path.normpath("../../.repo/projects/src/test.git"),
-      # Make sure no content was actually changed.
+            )
-      self.assertTrue(dotgit.is_dir())
-      for name in self._FILES:
+            # Make sure files were moved over.
-        self.assertTrue((dotgit / name).is_file())
+            gitdir = tempdir / ".repo/projects/src/test.git"
-      for name in self._CLEAN_FILES:
+            for name in self._FILES:
-        self.assertTrue((dotgit / name).is_file())
+                self.assertEqual(name, (gitdir / name).read_text())
-      for name in self._SYMLINKS:
+            # Make sure files were removed.
-        self.assertTrue((dotgit / name).is_symlink())
+            for name in self._CLEAN_FILES:
+                self.assertFalse((gitdir / name).exists())
+    def test_unknown(self):
+        """A checkout with unknown files should abort."""
+        with self._simple_layout() as tempdir:
+            dotgit = tempdir / "src/test/.git"
+            (tempdir / ".repo/projects/src/test.git/random-file").write_text(
+                "one"
+            )
+            (dotgit / "random-file").write_text("two")
+            with self.assertRaises(error.GitError):
+                project.Project._MigrateOldWorkTreeGitDir(str(dotgit))
+            # Make sure no content was actually changed.
+            self.assertTrue(dotgit.is_dir())
+            for name in self._FILES:
+                self.assertTrue((dotgit / name).is_file())
+            for name in self._CLEAN_FILES:
+                self.assertTrue((dotgit / name).is_file())
+            for name in self._SYMLINKS:
+                self.assertTrue((dotgit / name).is_symlink())
 class ManifestPropertiesFetchedCorrectly(unittest.TestCase):
-  """Ensure properties are fetched properly."""
+    """Ensure properties are fetched properly."""
-  def setUpManifest(self, tempdir):
+    def setUpManifest(self, tempdir):
-    repodir = os.path.join(tempdir, '.repo')
+        repodir = os.path.join(tempdir, ".repo")
-    manifest_dir = os.path.join(repodir, 'manifests')
+        manifest_dir = os.path.join(repodir, "manifests")
-    manifest_file = os.path.join(
+        manifest_file = os.path.join(repodir, manifest_xml.MANIFEST_FILE_NAME)
-        repodir, manifest_xml.MANIFEST_FILE_NAME)
+        os.mkdir(repodir)
-    local_manifest_dir = os.path.join(
+        os.mkdir(manifest_dir)
-        repodir, manifest_xml.LOCAL_MANIFESTS_DIR_NAME)
+        manifest = manifest_xml.XmlManifest(repodir, manifest_file)
-    os.mkdir(repodir)
-    os.mkdir(manifest_dir)
-    manifest = manifest_xml.XmlManifest(repodir, manifest_file)
-    return project.ManifestProject(
+        return project.ManifestProject(
-        manifest, 'test/manifest', os.path.join(tempdir, '.git'), tempdir)
+            manifest, "test/manifest", os.path.join(tempdir, ".git"), tempdir
+        )
-  def test_manifest_config_properties(self):
+    def test_manifest_config_properties(self):
-    """Test we are fetching the manifest config properties correctly."""
+        """Test we are fetching the manifest config properties correctly."""
-    with TempGitTree() as tempdir:
+        with TempGitTree() as tempdir:
-      fakeproj = self.setUpManifest(tempdir)
+            fakeproj = self.setUpManifest(tempdir)
-      # Set property using the expected Set method, then ensure
+            # Set property using the expected Set method, then ensure
-      # the porperty functions are using the correct Get methods.
+            # the porperty functions are using the correct Get methods.
-      fakeproj.config.SetString(
+            fakeproj.config.SetString(
-          'manifest.standalone', 'https://chicken/manifest.git')
+                "manifest.standalone", "https://chicken/manifest.git"
-      self.assertEqual(
+            )
-          fakeproj.standalone_manifest_url, 'https://chicken/manifest.git')
+            self.assertEqual(
+                fakeproj.standalone_manifest_url, "https://chicken/manifest.git"
+            )
-      fakeproj.config.SetString('manifest.groups', 'test-group, admin-group')
+            fakeproj.config.SetString(
-      self.assertEqual(fakeproj.manifest_groups, 'test-group, admin-group')
+                "manifest.groups", "test-group, admin-group"
+            )
+            self.assertEqual(
+                fakeproj.manifest_groups, "test-group, admin-group"
+            )
-      fakeproj.config.SetString('repo.reference', 'mirror/ref')
+            fakeproj.config.SetString("repo.reference", "mirror/ref")
-      self.assertEqual(fakeproj.reference, 'mirror/ref')
+            self.assertEqual(fakeproj.reference, "mirror/ref")
-      fakeproj.config.SetBoolean('repo.dissociate', False)
+            fakeproj.config.SetBoolean("repo.dissociate", False)
-      self.assertFalse(fakeproj.dissociate)
+            self.assertFalse(fakeproj.dissociate)
-      fakeproj.config.SetBoolean('repo.archive', False)
+            fakeproj.config.SetBoolean("repo.archive", False)
-      self.assertFalse(fakeproj.archive)
+            self.assertFalse(fakeproj.archive)
-      fakeproj.config.SetBoolean('repo.mirror', False)
+            fakeproj.config.SetBoolean("repo.mirror", False)
-      self.assertFalse(fakeproj.mirror)
+            self.assertFalse(fakeproj.mirror)
-      fakeproj.config.SetBoolean('repo.worktree', False)
+            fakeproj.config.SetBoolean("repo.worktree", False)
-      self.assertFalse(fakeproj.use_worktree)
+            self.assertFalse(fakeproj.use_worktree)
-      fakeproj.config.SetBoolean('repo.clonebundle', False)
+            fakeproj.config.SetBoolean("repo.clonebundle", False)
-      self.assertFalse(fakeproj.clone_bundle)
+            self.assertFalse(fakeproj.clone_bundle)
-      fakeproj.config.SetBoolean('repo.submodules', False)
+            fakeproj.config.SetBoolean("repo.submodules", False)
-      self.assertFalse(fakeproj.submodules)
+            self.assertFalse(fakeproj.submodules)
-      fakeproj.config.SetBoolean('repo.git-lfs', False)
+            fakeproj.config.SetBoolean("repo.git-lfs", False)
-      self.assertFalse(fakeproj.git_lfs)
+            self.assertFalse(fakeproj.git_lfs)
-      fakeproj.config.SetBoolean('repo.superproject', False)
+            fakeproj.config.SetBoolean("repo.superproject", False)
-      self.assertFalse(fakeproj.use_superproject)
+            self.assertFalse(fakeproj.use_superproject)
-      fakeproj.config.SetBoolean('repo.partialclone', False)
+            fakeproj.config.SetBoolean("repo.partialclone", False)
-      self.assertFalse(fakeproj.partial_clone)
+            self.assertFalse(fakeproj.partial_clone)
-      fakeproj.config.SetString('repo.depth', '48')
+            fakeproj.config.SetString("repo.depth", "48")
-      self.assertEqual(fakeproj.depth, '48')
+            self.assertEqual(fakeproj.depth, "48")
-      fakeproj.config.SetString('repo.clonefilter', 'blob:limit=10M')
+            fakeproj.config.SetString("repo.clonefilter", "blob:limit=10M")
-      self.assertEqual(fakeproj.clone_filter, 'blob:limit=10M')
+            self.assertEqual(fakeproj.clone_filter, "blob:limit=10M")
-      fakeproj.config.SetString('repo.partialcloneexclude', 'third_party/big_repo')
+            fakeproj.config.SetString(
-      self.assertEqual(fakeproj.partial_clone_exclude, 'third_party/big_repo')
+                "repo.partialcloneexclude", "third_party/big_repo"
+            )
+            self.assertEqual(
+                fakeproj.partial_clone_exclude, "third_party/big_repo"
+            )
-      fakeproj.config.SetString('manifest.platform', 'auto')
+            fakeproj.config.SetString("manifest.platform", "auto")
-      self.assertEqual(fakeproj.manifest_platform, 'auto')
+            self.assertEqual(fakeproj.manifest_platform, "auto")
diff --git a/tests/test_repo_trace.py b/tests/test_repo_trace.py
index 5faf2938..e4aeb5de 100644
--- a/tests/test_repo_trace.py
+++ b/tests/test_repo_trace.py
@@ -22,35 +22,39 @@ import repo_trace
 class TraceTests(unittest.TestCase):
-  """Check Trace behavior."""
+    """Check Trace behavior."""
-  def testTrace_MaxSizeEnforced(self):
+    def testTrace_MaxSizeEnforced(self):
-    content = 'git chicken'
+        content = "git chicken"
-    with repo_trace.Trace(content, first_trace=True):
+        with repo_trace.Trace(content, first_trace=True):
-      pass
+            pass
-    first_trace_size = os.path.getsize(repo_trace._TRACE_FILE)
+        first_trace_size = os.path.getsize(repo_trace._TRACE_FILE)
-    with repo_trace.Trace(content):
+        with repo_trace.Trace(content):
-      pass
+            pass
-    self.assertGreater(
+        self.assertGreater(
-        os.path.getsize(repo_trace._TRACE_FILE), first_trace_size)
+            os.path.getsize(repo_trace._TRACE_FILE), first_trace_size
+        )
-    # Check we clear everything is the last chunk is larger than _MAX_SIZE.
-    with mock.patch('repo_trace._MAX_SIZE', 0):
+        # Check we clear everything is the last chunk is larger than _MAX_SIZE.
-      with repo_trace.Trace(content, first_trace=True):
+        with mock.patch("repo_trace._MAX_SIZE", 0):
-        pass
+            with repo_trace.Trace(content, first_trace=True):
-      self.assertEqual(first_trace_size,
+                pass
-                       os.path.getsize(repo_trace._TRACE_FILE))
+            self.assertEqual(
+                first_trace_size, os.path.getsize(repo_trace._TRACE_FILE)
-      # Check we only clear the chunks we need to.
+            )
-      repo_trace._MAX_SIZE = (first_trace_size + 1) / (1024 * 1024)
-      with repo_trace.Trace(content, first_trace=True):
+            # Check we only clear the chunks we need to.
-        pass
+            repo_trace._MAX_SIZE = (first_trace_size + 1) / (1024 * 1024)
-      self.assertEqual(first_trace_size * 2,
+            with repo_trace.Trace(content, first_trace=True):
-                       os.path.getsize(repo_trace._TRACE_FILE))
+                pass
+            self.assertEqual(
-      with repo_trace.Trace(content, first_trace=True):
+                first_trace_size * 2, os.path.getsize(repo_trace._TRACE_FILE)
-        pass
+            )
-      self.assertEqual(first_trace_size * 2,
-                       os.path.getsize(repo_trace._TRACE_FILE))
+            with repo_trace.Trace(content, first_trace=True):
+                pass
+            self.assertEqual(
+                first_trace_size * 2, os.path.getsize(repo_trace._TRACE_FILE)
+            )
diff --git a/tests/test_ssh.py b/tests/test_ssh.py
index ffb5cb94..a9c1be7f 100644
--- a/tests/test_ssh.py
+++ b/tests/test_ssh.py
@@ -23,52 +23,56 @@ import ssh
 class SshTests(unittest.TestCase):
-  """Tests the ssh functions."""
+    """Tests the ssh functions."""
-  def test_parse_ssh_version(self):
+    def test_parse_ssh_version(self):
-    """Check _parse_ssh_version() handling."""
+        """Check _parse_ssh_version() handling."""
-    ver = ssh._parse_ssh_version('Unknown\n')
+        ver = ssh._parse_ssh_version("Unknown\n")
-    self.assertEqual(ver, ())
+        self.assertEqual(ver, ())
-    ver = ssh._parse_ssh_version('OpenSSH_1.0\n')
+        ver = ssh._parse_ssh_version("OpenSSH_1.0\n")
-    self.assertEqual(ver, (1, 0))
+        self.assertEqual(ver, (1, 0))
-    ver = ssh._parse_ssh_version('OpenSSH_6.6.1p1 Ubuntu-2ubuntu2.13, OpenSSL 1.0.1f 6 Jan 2014\n')
+        ver = ssh._parse_ssh_version(
-    self.assertEqual(ver, (6, 6, 1))
+            "OpenSSH_6.6.1p1 Ubuntu-2ubuntu2.13, OpenSSL 1.0.1f 6 Jan 2014\n"
-    ver = ssh._parse_ssh_version('OpenSSH_7.6p1 Ubuntu-4ubuntu0.3, OpenSSL 1.0.2n  7 Dec 2017\n')
+        )
-    self.assertEqual(ver, (7, 6))
+        self.assertEqual(ver, (6, 6, 1))
+        ver = ssh._parse_ssh_version(
+            "OpenSSH_7.6p1 Ubuntu-4ubuntu0.3, OpenSSL 1.0.2n  7 Dec 2017\n"
+        )
+        self.assertEqual(ver, (7, 6))
-  def test_version(self):
+    def test_version(self):
-    """Check version() handling."""
+        """Check version() handling."""
-    with mock.patch('ssh._run_ssh_version', return_value='OpenSSH_1.2\n'):
+        with mock.patch("ssh._run_ssh_version", return_value="OpenSSH_1.2\n"):
-      self.assertEqual(ssh.version(), (1, 2))
+            self.assertEqual(ssh.version(), (1, 2))
-  def test_context_manager_empty(self):
+    def test_context_manager_empty(self):
-    """Verify context manager with no clients works correctly."""
+        """Verify context manager with no clients works correctly."""
-    with multiprocessing.Manager() as manager:
+        with multiprocessing.Manager() as manager:
-      with ssh.ProxyManager(manager):
+            with ssh.ProxyManager(manager):
-        pass
+                pass
-  def test_context_manager_child_cleanup(self):
+    def test_context_manager_child_cleanup(self):
-    """Verify orphaned clients & masters get cleaned up."""
+        """Verify orphaned clients & masters get cleaned up."""
-    with multiprocessing.Manager() as manager:
+        with multiprocessing.Manager() as manager:
-      with ssh.ProxyManager(manager) as ssh_proxy:
+            with ssh.ProxyManager(manager) as ssh_proxy:
-        client = subprocess.Popen(['sleep', '964853320'])
+                client = subprocess.Popen(["sleep", "964853320"])
-        ssh_proxy.add_client(client)
+                ssh_proxy.add_client(client)
-        master = subprocess.Popen(['sleep', '964853321'])
+                master = subprocess.Popen(["sleep", "964853321"])
-        ssh_proxy.add_master(master)
+                ssh_proxy.add_master(master)
-    # If the process still exists, these will throw timeout errors.
+        # If the process still exists, these will throw timeout errors.
-    client.wait(0)
+        client.wait(0)
-    master.wait(0)
+        master.wait(0)
-  def test_ssh_sock(self):
+    def test_ssh_sock(self):
-    """Check sock() function."""
+        """Check sock() function."""
-    manager = multiprocessing.Manager()
+        manager = multiprocessing.Manager()
-    proxy = ssh.ProxyManager(manager)
+        proxy = ssh.ProxyManager(manager)
-    with mock.patch('tempfile.mkdtemp', return_value='/tmp/foo'):
+        with mock.patch("tempfile.mkdtemp", return_value="/tmp/foo"):
-      # old ssh version uses port
+            # Old ssh version uses port.
-      with mock.patch('ssh.version', return_value=(6, 6)):
+            with mock.patch("ssh.version", return_value=(6, 6)):
-        self.assertTrue(proxy.sock().endswith('%p'))
+                self.assertTrue(proxy.sock().endswith("%p"))
-      proxy._sock_path = None
+            proxy._sock_path = None
-      # new ssh version uses hash
+            # New ssh version uses hash.
-      with mock.patch('ssh.version', return_value=(6, 7)):
+            with mock.patch("ssh.version", return_value=(6, 7)):
-        self.assertTrue(proxy.sock().endswith('%C'))
+                self.assertTrue(proxy.sock().endswith("%C"))
diff --git a/tests/test_subcmds.py b/tests/test_subcmds.py
index bc53051a..73b66e3f 100644
--- a/tests/test_subcmds.py
+++ b/tests/test_subcmds.py
@@ -21,53 +21,57 @@ import subcmds
 class AllCommands(unittest.TestCase):
-  """Check registered all_commands."""
+    """Check registered all_commands."""
-  def test_required_basic(self):
+    def test_required_basic(self):
-    """Basic checking of registered commands."""
+        """Basic checking of registered commands."""
-    # NB: We don't test all subcommands as we want to avoid "change detection"
+        # NB: We don't test all subcommands as we want to avoid "change
-    # tests, so we just look for the most common/important ones here that are
+        # detection" tests, so we just look for the most common/important ones
-    # unlikely to ever change.
+        # here that are unlikely to ever change.
-    for cmd in {'cherry-pick', 'help', 'init', 'start', 'sync', 'upload'}:
+        for cmd in {"cherry-pick", "help", "init", "start", "sync", "upload"}:
-      self.assertIn(cmd, subcmds.all_commands)
+            self.assertIn(cmd, subcmds.all_commands)
-  def test_naming(self):
+    def test_naming(self):
-    """Verify we don't add things that we shouldn't."""
+        """Verify we don't add things that we shouldn't."""
-    for cmd in subcmds.all_commands:
+        for cmd in subcmds.all_commands:
-      # Reject filename suffixes like "help.py".
+            # Reject filename suffixes like "help.py".
-      self.assertNotIn('.', cmd)
+            self.assertNotIn(".", cmd)
-      # Make sure all '_' were converted to '-'.
+            # Make sure all '_' were converted to '-'.
-      self.assertNotIn('_', cmd)
+            self.assertNotIn("_", cmd)
-      # Reject internal python paths like "__init__".
+            # Reject internal python paths like "__init__".
-      self.assertFalse(cmd.startswith('__'))
+            self.assertFalse(cmd.startswith("__"))
-  def test_help_desc_style(self):
+    def test_help_desc_style(self):
-    """Force some consistency in option descriptions.
+        """Force some consistency in option descriptions.
-    Python's optparse & argparse has a few default options like --help.  Their
+        Python's optparse & argparse has a few default options like --help.
-    option description text uses lowercase sentence fragments, so enforce our
+        Their option description text uses lowercase sentence fragments, so
-    options follow the same style so UI is consistent.
+        enforce our options follow the same style so UI is consistent.
-    We enforce:
+        We enforce:
-    * Text starts with lowercase.
+        * Text starts with lowercase.
-    * Text doesn't end with period.
+        * Text doesn't end with period.
-    """
+        """
-    for name, cls in subcmds.all_commands.items():
+        for name, cls in subcmds.all_commands.items():
-      cmd = cls()
+            cmd = cls()
-      parser = cmd.OptionParser
+            parser = cmd.OptionParser
-      for option in parser.option_list:
+            for option in parser.option_list:
-        if option.help == optparse.SUPPRESS_HELP:
+                if option.help == optparse.SUPPRESS_HELP:
-          continue
+                    continue
-        c = option.help[0]
+                c = option.help[0]
-        self.assertEqual(
+                self.assertEqual(
-            c.lower(), c,
+                    c.lower(),
-            msg=f'subcmds/{name}.py: {option.get_opt_string()}: help text '
+                    c,
-                f'should start with lowercase: "{option.help}"')
+                    msg=f"subcmds/{name}.py: {option.get_opt_string()}: "
+                    f'help text should start with lowercase: "{option.help}"',
+                )
-        self.assertNotEqual(
+                self.assertNotEqual(
-            option.help[-1], '.',
+                    option.help[-1],
-            msg=f'subcmds/{name}.py: {option.get_opt_string()}: help text '
+                    ".",
-                f'should not end in a period: "{option.help}"')
+                    msg=f"subcmds/{name}.py: {option.get_opt_string()}: "
+                    f'help text should not end in a period: "{option.help}"',
+                )
diff --git a/tests/test_subcmds_init.py b/tests/test_subcmds_init.py
index af4346de..25e5be56 100644
--- a/tests/test_subcmds_init.py
+++ b/tests/test_subcmds_init.py
@@ -20,30 +20,27 @@ from subcmds import init
 class InitCommand(unittest.TestCase):
-  """Check registered all_commands."""
+    """Check registered all_commands."""
-  def setUp(self):
+    def setUp(self):
-    self.cmd = init.Init()
+        self.cmd = init.Init()
-  def test_cli_parser_good(self):
+    def test_cli_parser_good(self):
-    """Check valid command line options."""
+        """Check valid command line options."""
-    ARGV = (
+        ARGV = ([],)
-        [],
+        for argv in ARGV:
-    )
+            opts, args = self.cmd.OptionParser.parse_args(argv)
-    for argv in ARGV:
+            self.cmd.ValidateOptions(opts, args)
-      opts, args = self.cmd.OptionParser.parse_args(argv)
-      self.cmd.ValidateOptions(opts, args)
+    def test_cli_parser_bad(self):
+        """Check invalid command line options."""
-  def test_cli_parser_bad(self):
+        ARGV = (
-    """Check invalid command line options."""
+            # Too many arguments.
-    ARGV = (
+            ["url", "asdf"],
-        # Too many arguments.
+            # Conflicting options.
-        ['url', 'asdf'],
+            ["--mirror", "--archive"],
+        )
-        # Conflicting options.
+        for argv in ARGV:
-        ['--mirror', '--archive'],
+            opts, args = self.cmd.OptionParser.parse_args(argv)
-    )
+            with self.assertRaises(SystemExit):
-    for argv in ARGV:
+                self.cmd.ValidateOptions(opts, args)
-      opts, args = self.cmd.OptionParser.parse_args(argv)
-      with self.assertRaises(SystemExit):
-        self.cmd.ValidateOptions(opts, args)
diff --git a/tests/test_subcmds_sync.py b/tests/test_subcmds_sync.py
index 236d54e5..5c8e606e 100644
--- a/tests/test_subcmds_sync.py
+++ b/tests/test_subcmds_sync.py
@@ -23,111 +23,138 @@ import command
 from subcmds import sync
-@pytest.mark.parametrize('use_superproject, cli_args, result', [
+@pytest.mark.parametrize(
-    (True, ['--current-branch'], True),
+    "use_superproject, cli_args, result",
-    (True, ['--no-current-branch'], True),
+    [
-    (True, [], True),
+        (True, ["--current-branch"], True),
-    (False, ['--current-branch'], True),
+        (True, ["--no-current-branch"], True),
-    (False, ['--no-current-branch'], False),
+        (True, [], True),
-    (False, [], None),
+        (False, ["--current-branch"], True),
-])
+        (False, ["--no-current-branch"], False),
+        (False, [], None),
+    ],
+)
 def test_get_current_branch_only(use_superproject, cli_args, result):
-  """Test Sync._GetCurrentBranchOnly logic.
+    """Test Sync._GetCurrentBranchOnly logic.
-  Sync._GetCurrentBranchOnly should return True if a superproject is requested,
+    Sync._GetCurrentBranchOnly should return True if a superproject is
-  and otherwise the value of the current_branch_only option.
+    requested, and otherwise the value of the current_branch_only option.
-  """
+    """
-  cmd = sync.Sync()
+    cmd = sync.Sync()
-  opts, _ = cmd.OptionParser.parse_args(cli_args)
+    opts, _ = cmd.OptionParser.parse_args(cli_args)
-  with mock.patch('git_superproject.UseSuperproject',
+    with mock.patch(
-                  return_value=use_superproject):
+        "git_superproject.UseSuperproject", return_value=use_superproject
-    assert cmd._GetCurrentBranchOnly(opts, cmd.manifest) == result
+    ):
+        assert cmd._GetCurrentBranchOnly(opts, cmd.manifest) == result
 # Used to patch os.cpu_count() for reliable results.
 OS_CPU_COUNT = 24
-@pytest.mark.parametrize('argv, jobs_manifest, jobs, jobs_net, jobs_check', [
-  # No user or manifest settings.
+@pytest.mark.parametrize(
-  ([], None, OS_CPU_COUNT, 1, command.DEFAULT_LOCAL_JOBS),
+    "argv, jobs_manifest, jobs, jobs_net, jobs_check",
-  # No user settings, so manifest settings control.
+    [
-  ([], 3, 3, 3, 3),
+        # No user or manifest settings.
-  # User settings, but no manifest.
+        ([], None, OS_CPU_COUNT, 1, command.DEFAULT_LOCAL_JOBS),
-  (['--jobs=4'], None, 4, 4, 4),
+        # No user settings, so manifest settings control.
-  (['--jobs=4', '--jobs-network=5'], None, 4, 5, 4),
+        ([], 3, 3, 3, 3),
-  (['--jobs=4', '--jobs-checkout=6'], None, 4, 4, 6),
+        # User settings, but no manifest.
-  (['--jobs=4', '--jobs-network=5', '--jobs-checkout=6'], None, 4, 5, 6),
+        (["--jobs=4"], None, 4, 4, 4),
-  (['--jobs-network=5'], None, OS_CPU_COUNT, 5, command.DEFAULT_LOCAL_JOBS),
+        (["--jobs=4", "--jobs-network=5"], None, 4, 5, 4),
-  (['--jobs-checkout=6'], None, OS_CPU_COUNT, 1, 6),
+        (["--jobs=4", "--jobs-checkout=6"], None, 4, 4, 6),
-  (['--jobs-network=5', '--jobs-checkout=6'], None, OS_CPU_COUNT, 5, 6),
+        (["--jobs=4", "--jobs-network=5", "--jobs-checkout=6"], None, 4, 5, 6),
-  # User settings with manifest settings.
+        (
-  (['--jobs=4'], 3, 4, 4, 4),
+            ["--jobs-network=5"],
-  (['--jobs=4', '--jobs-network=5'], 3, 4, 5, 4),
+            None,
-  (['--jobs=4', '--jobs-checkout=6'], 3, 4, 4, 6),
+            OS_CPU_COUNT,
-  (['--jobs=4', '--jobs-network=5', '--jobs-checkout=6'], 3, 4, 5, 6),
+            5,
-  (['--jobs-network=5'], 3, 3, 5, 3),
+            command.DEFAULT_LOCAL_JOBS,
-  (['--jobs-checkout=6'], 3, 3, 3, 6),
+        ),
-  (['--jobs-network=5', '--jobs-checkout=6'], 3, 3, 5, 6),
+        (["--jobs-checkout=6"], None, OS_CPU_COUNT, 1, 6),
-  # Settings that exceed rlimits get capped.
+        (["--jobs-network=5", "--jobs-checkout=6"], None, OS_CPU_COUNT, 5, 6),
-  (['--jobs=1000000'], None, 83, 83, 83),
+        # User settings with manifest settings.
-  ([], 1000000, 83, 83, 83),
+        (["--jobs=4"], 3, 4, 4, 4),
-])
+        (["--jobs=4", "--jobs-network=5"], 3, 4, 5, 4),
+        (["--jobs=4", "--jobs-checkout=6"], 3, 4, 4, 6),
+        (["--jobs=4", "--jobs-network=5", "--jobs-checkout=6"], 3, 4, 5, 6),
+        (["--jobs-network=5"], 3, 3, 5, 3),
+        (["--jobs-checkout=6"], 3, 3, 3, 6),
+        (["--jobs-network=5", "--jobs-checkout=6"], 3, 3, 5, 6),
+        # Settings that exceed rlimits get capped.
+        (["--jobs=1000000"], None, 83, 83, 83),
+        ([], 1000000, 83, 83, 83),
+    ],
+)
 def test_cli_jobs(argv, jobs_manifest, jobs, jobs_net, jobs_check):
-  """Tests --jobs option behavior."""
+    """Tests --jobs option behavior."""
-  mp = mock.MagicMock()
+    mp = mock.MagicMock()
-  mp.manifest.default.sync_j = jobs_manifest
+    mp.manifest.default.sync_j = jobs_manifest
-  cmd = sync.Sync()
+    cmd = sync.Sync()
-  opts, args = cmd.OptionParser.parse_args(argv)
+    opts, args = cmd.OptionParser.parse_args(argv)
-  cmd.ValidateOptions(opts, args)
+    cmd.ValidateOptions(opts, args)
-  with mock.patch.object(sync, '_rlimit_nofile', return_value=(256, 256)):
+    with mock.patch.object(sync, "_rlimit_nofile", return_value=(256, 256)):
-    with mock.patch.object(os, 'cpu_count', return_value=OS_CPU_COUNT):
+        with mock.patch.object(os, "cpu_count", return_value=OS_CPU_COUNT):
-      cmd._ValidateOptionsWithManifest(opts, mp)
+            cmd._ValidateOptionsWithManifest(opts, mp)
-      assert opts.jobs == jobs
+            assert opts.jobs == jobs
-      assert opts.jobs_network == jobs_net
+            assert opts.jobs_network == jobs_net
-      assert opts.jobs_checkout == jobs_check
+            assert opts.jobs_checkout == jobs_check
 class GetPreciousObjectsState(unittest.TestCase):
-  """Tests for _GetPreciousObjectsState."""
+    """Tests for _GetPreciousObjectsState."""
-  def setUp(self):
+    def setUp(self):
-    """Common setup."""
+        """Common setup."""
-    self.cmd = sync.Sync()
+        self.cmd = sync.Sync()
-    self.project = p = mock.MagicMock(use_git_worktrees=False,
+        self.project = p = mock.MagicMock(
-                                      UseAlternates=False)
+            use_git_worktrees=False, UseAlternates=False
-    p.manifest.GetProjectsWithName.return_value = [p]
+        )
+        p.manifest.GetProjectsWithName.return_value = [p]
-    self.opt = mock.Mock(spec_set=['this_manifest_only'])
-    self.opt.this_manifest_only = False
+        self.opt = mock.Mock(spec_set=["this_manifest_only"])
+        self.opt.this_manifest_only = False
-  def test_worktrees(self):
-    """False for worktrees."""
+    def test_worktrees(self):
-    self.project.use_git_worktrees = True
+        """False for worktrees."""
-    self.assertFalse(self.cmd._GetPreciousObjectsState(self.project, self.opt))
+        self.project.use_git_worktrees = True
+        self.assertFalse(
-  def test_not_shared(self):
+            self.cmd._GetPreciousObjectsState(self.project, self.opt)
-    """Singleton project."""
+        )
-    self.assertFalse(self.cmd._GetPreciousObjectsState(self.project, self.opt))
+    def test_not_shared(self):
-  def test_shared(self):
+        """Singleton project."""
-    """Shared project."""
+        self.assertFalse(
-    self.project.manifest.GetProjectsWithName.return_value = [
+            self.cmd._GetPreciousObjectsState(self.project, self.opt)
-        self.project, self.project
+        )
-    ]
-    self.assertTrue(self.cmd._GetPreciousObjectsState(self.project, self.opt))
+    def test_shared(self):
+        """Shared project."""
-  def test_shared_with_alternates(self):
+        self.project.manifest.GetProjectsWithName.return_value = [
-    """Shared project, with alternates."""
+            self.project,
-    self.project.manifest.GetProjectsWithName.return_value = [
+            self.project,
-        self.project, self.project
+        ]
-    ]
+        self.assertTrue(
-    self.project.UseAlternates = True
+            self.cmd._GetPreciousObjectsState(self.project, self.opt)
-    self.assertFalse(self.cmd._GetPreciousObjectsState(self.project, self.opt))
+        )
-  def test_not_found(self):
+    def test_shared_with_alternates(self):
-    """Project not found in manifest."""
+        """Shared project, with alternates."""
-    self.project.manifest.GetProjectsWithName.return_value = []
+        self.project.manifest.GetProjectsWithName.return_value = [
-    self.assertFalse(self.cmd._GetPreciousObjectsState(self.project, self.opt))
+            self.project,
+            self.project,
+        ]
+        self.project.UseAlternates = True
+        self.assertFalse(
+            self.cmd._GetPreciousObjectsState(self.project, self.opt)
+        )
+    def test_not_found(self):
+        """Project not found in manifest."""
+        self.project.manifest.GetProjectsWithName.return_value = []
+        self.assertFalse(
+            self.cmd._GetPreciousObjectsState(self.project, self.opt)
+        )
diff --git a/tests/test_update_manpages.py b/tests/test_update_manpages.py
index 0de85be9..12b19ec4 100644
--- a/tests/test_update_manpages.py
+++ b/tests/test_update_manpages.py
@@ -20,9 +20,9 @@ from release import update_manpages
 class UpdateManpagesTest(unittest.TestCase):
-  """Tests the update-manpages code."""
+    """Tests the update-manpages code."""
-  def test_replace_regex(self):
+    def test_replace_regex(self):
-    """Check that replace_regex works."""
+        """Check that replace_regex works."""
-    data = '\n\033[1mSummary\033[m\n'
+        data = "\n\033[1mSummary\033[m\n"
-    self.assertEqual(update_manpages.replace_regex(data),'\nSummary\n')
+        self.assertEqual(update_manpages.replace_regex(data), "\nSummary\n")
diff --git a/tests/test_wrapper.py b/tests/test_wrapper.py
index ef879a5d..21fa094d 100644
--- a/tests/test_wrapper.py
+++ b/tests/test_wrapper.py
@@ -28,528 +28,615 @@ import wrapper
 def fixture(*paths):
-  """Return a path relative to tests/fixtures.
+    """Return a path relative to tests/fixtures."""
-  """
+    return os.path.join(os.path.dirname(__file__), "fixtures", *paths)
-  return os.path.join(os.path.dirname(__file__), 'fixtures', *paths)
 class RepoWrapperTestCase(unittest.TestCase):
-  """TestCase for the wrapper module."""
+    """TestCase for the wrapper module."""
-  def setUp(self):
+    def setUp(self):
-    """Load the wrapper module every time."""
+        """Load the wrapper module every time."""
-    wrapper.Wrapper.cache_clear()
+        wrapper.Wrapper.cache_clear()
-    self.wrapper = wrapper.Wrapper()
+        self.wrapper = wrapper.Wrapper()
 class RepoWrapperUnitTest(RepoWrapperTestCase):
-  """Tests helper functions in the repo wrapper
+    """Tests helper functions in the repo wrapper"""
-  """
+    def test_version(self):
-  def test_version(self):
+        """Make sure _Version works."""
-    """Make sure _Version works."""
+        with self.assertRaises(SystemExit) as e:
-    with self.assertRaises(SystemExit) as e:
+            with mock.patch("sys.stdout", new_callable=StringIO) as stdout:
-      with mock.patch('sys.stdout', new_callable=StringIO) as stdout:
+                with mock.patch("sys.stderr", new_callable=StringIO) as stderr:
-        with mock.patch('sys.stderr', new_callable=StringIO) as stderr:
+                    self.wrapper._Version()
-          self.wrapper._Version()
+        self.assertEqual(0, e.exception.code)
-    self.assertEqual(0, e.exception.code)
+        self.assertEqual("", stderr.getvalue())
-    self.assertEqual('', stderr.getvalue())
+        self.assertIn("repo launcher version", stdout.getvalue())
-    self.assertIn('repo launcher version', stdout.getvalue())
+    def test_python_constraints(self):
-  def test_python_constraints(self):
+        """The launcher should never require newer than main.py."""
-    """The launcher should never require newer than main.py."""
+        self.assertGreaterEqual(
-    self.assertGreaterEqual(main.MIN_PYTHON_VERSION_HARD,
+            main.MIN_PYTHON_VERSION_HARD, self.wrapper.MIN_PYTHON_VERSION_HARD
-                            self.wrapper.MIN_PYTHON_VERSION_HARD)
+        )
-    self.assertGreaterEqual(main.MIN_PYTHON_VERSION_SOFT,
+        self.assertGreaterEqual(
-                            self.wrapper.MIN_PYTHON_VERSION_SOFT)
+            main.MIN_PYTHON_VERSION_SOFT, self.wrapper.MIN_PYTHON_VERSION_SOFT
-    # Make sure the versions are themselves in sync.
+        )
-    self.assertGreaterEqual(self.wrapper.MIN_PYTHON_VERSION_SOFT,
+        # Make sure the versions are themselves in sync.
-                            self.wrapper.MIN_PYTHON_VERSION_HARD)
+        self.assertGreaterEqual(
+            self.wrapper.MIN_PYTHON_VERSION_SOFT,
-  def test_init_parser(self):
+            self.wrapper.MIN_PYTHON_VERSION_HARD,
-    """Make sure 'init' GetParser works."""
+        )
-    parser = self.wrapper.GetParser(gitc_init=False)
-    opts, args = parser.parse_args([])
+    def test_init_parser(self):
-    self.assertEqual([], args)
+        """Make sure 'init' GetParser works."""
-    self.assertIsNone(opts.manifest_url)
+        parser = self.wrapper.GetParser(gitc_init=False)
+        opts, args = parser.parse_args([])
-  def test_gitc_init_parser(self):
+        self.assertEqual([], args)
-    """Make sure 'gitc-init' GetParser works."""
+        self.assertIsNone(opts.manifest_url)
-    parser = self.wrapper.GetParser(gitc_init=True)
-    opts, args = parser.parse_args([])
+    def test_gitc_init_parser(self):
-    self.assertEqual([], args)
+        """Make sure 'gitc-init' GetParser works."""
-    self.assertIsNone(opts.manifest_file)
+        parser = self.wrapper.GetParser(gitc_init=True)
+        opts, args = parser.parse_args([])
-  def test_get_gitc_manifest_dir_no_gitc(self):
+        self.assertEqual([], args)
-    """
+        self.assertIsNone(opts.manifest_file)
-    Test reading a missing gitc config file
-    """
+    def test_get_gitc_manifest_dir_no_gitc(self):
-    self.wrapper.GITC_CONFIG_FILE = fixture('missing_gitc_config')
+        """
-    val = self.wrapper.get_gitc_manifest_dir()
+        Test reading a missing gitc config file
-    self.assertEqual(val, '')
+        """
+        self.wrapper.GITC_CONFIG_FILE = fixture("missing_gitc_config")
-  def test_get_gitc_manifest_dir(self):
+        val = self.wrapper.get_gitc_manifest_dir()
-    """
+        self.assertEqual(val, "")
-    Test reading the gitc config file and parsing the directory
-    """
+    def test_get_gitc_manifest_dir(self):
-    self.wrapper.GITC_CONFIG_FILE = fixture('gitc_config')
+        """
-    val = self.wrapper.get_gitc_manifest_dir()
+        Test reading the gitc config file and parsing the directory
-    self.assertEqual(val, '/test/usr/local/google/gitc')
+        """
+        self.wrapper.GITC_CONFIG_FILE = fixture("gitc_config")
-  def test_gitc_parse_clientdir_no_gitc(self):
+        val = self.wrapper.get_gitc_manifest_dir()
-    """
+        self.assertEqual(val, "/test/usr/local/google/gitc")
-    Test parsing the gitc clientdir without gitc running
-    """
+    def test_gitc_parse_clientdir_no_gitc(self):
-    self.wrapper.GITC_CONFIG_FILE = fixture('missing_gitc_config')
+        """
-    self.assertEqual(self.wrapper.gitc_parse_clientdir('/something'), None)
+        Test parsing the gitc clientdir without gitc running
-    self.assertEqual(self.wrapper.gitc_parse_clientdir('/gitc/manifest-rw/test'), 'test')
+        """
+        self.wrapper.GITC_CONFIG_FILE = fixture("missing_gitc_config")
-  def test_gitc_parse_clientdir(self):
+        self.assertEqual(self.wrapper.gitc_parse_clientdir("/something"), None)
-    """
+        self.assertEqual(
-    Test parsing the gitc clientdir
+            self.wrapper.gitc_parse_clientdir("/gitc/manifest-rw/test"), "test"
-    """
+        )
-    self.wrapper.GITC_CONFIG_FILE = fixture('gitc_config')
-    self.assertEqual(self.wrapper.gitc_parse_clientdir('/something'), None)
+    def test_gitc_parse_clientdir(self):
-    self.assertEqual(self.wrapper.gitc_parse_clientdir('/gitc/manifest-rw/test'), 'test')
+        """
-    self.assertEqual(self.wrapper.gitc_parse_clientdir('/gitc/manifest-rw/test/'), 'test')
+        Test parsing the gitc clientdir
-    self.assertEqual(self.wrapper.gitc_parse_clientdir('/gitc/manifest-rw/test/extra'), 'test')
+        """
-    self.assertEqual(self.wrapper.gitc_parse_clientdir('/test/usr/local/google/gitc/test'), 'test')
+        self.wrapper.GITC_CONFIG_FILE = fixture("gitc_config")
-    self.assertEqual(self.wrapper.gitc_parse_clientdir('/test/usr/local/google/gitc/test/'), 'test')
+        self.assertEqual(self.wrapper.gitc_parse_clientdir("/something"), None)
-    self.assertEqual(self.wrapper.gitc_parse_clientdir('/test/usr/local/google/gitc/test/extra'),
+        self.assertEqual(
-                     'test')
+            self.wrapper.gitc_parse_clientdir("/gitc/manifest-rw/test"), "test"
-    self.assertEqual(self.wrapper.gitc_parse_clientdir('/gitc/manifest-rw/'), None)
+        )
-    self.assertEqual(self.wrapper.gitc_parse_clientdir('/test/usr/local/google/gitc/'), None)
+        self.assertEqual(
+            self.wrapper.gitc_parse_clientdir("/gitc/manifest-rw/test/"), "test"
+        )
+        self.assertEqual(
+            self.wrapper.gitc_parse_clientdir("/gitc/manifest-rw/test/extra"),
+            "test",
+        )
+        self.assertEqual(
+            self.wrapper.gitc_parse_clientdir(
+                "/test/usr/local/google/gitc/test"
+            ),
+            "test",
+        )
+        self.assertEqual(
+            self.wrapper.gitc_parse_clientdir(
+                "/test/usr/local/google/gitc/test/"
+            ),
+            "test",
+        )
+        self.assertEqual(
+            self.wrapper.gitc_parse_clientdir(
+                "/test/usr/local/google/gitc/test/extra"
+            ),
+            "test",
+        )
+        self.assertEqual(
+            self.wrapper.gitc_parse_clientdir("/gitc/manifest-rw/"), None
+        )
+        self.assertEqual(
+            self.wrapper.gitc_parse_clientdir("/test/usr/local/google/gitc/"),
+            None,
+        )
 class SetGitTrace2ParentSid(RepoWrapperTestCase):
-  """Check SetGitTrace2ParentSid behavior."""
+    """Check SetGitTrace2ParentSid behavior."""
-  KEY = 'GIT_TRACE2_PARENT_SID'
+    KEY = "GIT_TRACE2_PARENT_SID"
-  VALID_FORMAT = re.compile(r'^repo-[0-9]{8}T[0-9]{6}Z-P[0-9a-f]{8}$')
+    VALID_FORMAT = re.compile(r"^repo-[0-9]{8}T[0-9]{6}Z-P[0-9a-f]{8}$")
-  def test_first_set(self):
+    def test_first_set(self):
-    """Test env var not yet set."""
+        """Test env var not yet set."""
-    env = {}
+        env = {}
-    self.wrapper.SetGitTrace2ParentSid(env)
+        self.wrapper.SetGitTrace2ParentSid(env)
-    self.assertIn(self.KEY, env)
+        self.assertIn(self.KEY, env)
-    value = env[self.KEY]
+        value = env[self.KEY]
-    self.assertRegex(value, self.VALID_FORMAT)
+        self.assertRegex(value, self.VALID_FORMAT)
-  def test_append(self):
+    def test_append(self):
-    """Test env var is appended."""
+        """Test env var is appended."""
-    env = {self.KEY: 'pfx'}
+        env = {self.KEY: "pfx"}
-    self.wrapper.SetGitTrace2ParentSid(env)
+        self.wrapper.SetGitTrace2ParentSid(env)
-    self.assertIn(self.KEY, env)
+        self.assertIn(self.KEY, env)
-    value = env[self.KEY]
+        value = env[self.KEY]
-    self.assertTrue(value.startswith('pfx/'))
+        self.assertTrue(value.startswith("pfx/"))
-    self.assertRegex(value[4:], self.VALID_FORMAT)
+        self.assertRegex(value[4:], self.VALID_FORMAT)
-  def test_global_context(self):
+    def test_global_context(self):
-    """Check os.environ gets updated by default."""
+        """Check os.environ gets updated by default."""
-    os.environ.pop(self.KEY, None)
+        os.environ.pop(self.KEY, None)
-    self.wrapper.SetGitTrace2ParentSid()
+        self.wrapper.SetGitTrace2ParentSid()
-    self.assertIn(self.KEY, os.environ)
+        self.assertIn(self.KEY, os.environ)
-    value = os.environ[self.KEY]
+        value = os.environ[self.KEY]
-    self.assertRegex(value, self.VALID_FORMAT)
+        self.assertRegex(value, self.VALID_FORMAT)
 class RunCommand(RepoWrapperTestCase):
-  """Check run_command behavior."""
+    """Check run_command behavior."""
-  def test_capture(self):
+    def test_capture(self):
-    """Check capture_output handling."""
+        """Check capture_output handling."""
-    ret = self.wrapper.run_command(['echo', 'hi'], capture_output=True)
+        ret = self.wrapper.run_command(["echo", "hi"], capture_output=True)
-    # echo command appends OS specific linesep, but on Windows + Git Bash
+        # echo command appends OS specific linesep, but on Windows + Git Bash
-    # we get UNIX ending, so we allow both.
+        # we get UNIX ending, so we allow both.
-    self.assertIn(ret.stdout, ['hi' + os.linesep, 'hi\n'])
+        self.assertIn(ret.stdout, ["hi" + os.linesep, "hi\n"])
-  def test_check(self):
+    def test_check(self):
-    """Check check handling."""
+        """Check check handling."""
-    self.wrapper.run_command(['true'], check=False)
+        self.wrapper.run_command(["true"], check=False)
-    self.wrapper.run_command(['true'], check=True)
+        self.wrapper.run_command(["true"], check=True)
-    self.wrapper.run_command(['false'], check=False)
+        self.wrapper.run_command(["false"], check=False)
-    with self.assertRaises(self.wrapper.RunError):
+        with self.assertRaises(self.wrapper.RunError):
-      self.wrapper.run_command(['false'], check=True)
+            self.wrapper.run_command(["false"], check=True)
 class RunGit(RepoWrapperTestCase):
-  """Check run_git behavior."""
+    """Check run_git behavior."""
-  def test_capture(self):
+    def test_capture(self):
-    """Check capture_output handling."""
+        """Check capture_output handling."""
-    ret = self.wrapper.run_git('--version')
+        ret = self.wrapper.run_git("--version")
-    self.assertIn('git', ret.stdout)
+        self.assertIn("git", ret.stdout)
-  def test_check(self):
+    def test_check(self):
-    """Check check handling."""
+        """Check check handling."""
-    with self.assertRaises(self.wrapper.CloneFailure):
+        with self.assertRaises(self.wrapper.CloneFailure):
-      self.wrapper.run_git('--version-asdfasdf')
+            self.wrapper.run_git("--version-asdfasdf")
-    self.wrapper.run_git('--version-asdfasdf', check=False)
+        self.wrapper.run_git("--version-asdfasdf", check=False)
 class ParseGitVersion(RepoWrapperTestCase):
-  """Check ParseGitVersion behavior."""
+    """Check ParseGitVersion behavior."""
-  def test_autoload(self):
+    def test_autoload(self):
-    """Check we can load the version from the live git."""
+        """Check we can load the version from the live git."""
-    ret = self.wrapper.ParseGitVersion()
+        ret = self.wrapper.ParseGitVersion()
-    self.assertIsNotNone(ret)
+        self.assertIsNotNone(ret)
-  def test_bad_ver(self):
+    def test_bad_ver(self):
-    """Check handling of bad git versions."""
+        """Check handling of bad git versions."""
-    ret = self.wrapper.ParseGitVersion(ver_str='asdf')
+        ret = self.wrapper.ParseGitVersion(ver_str="asdf")
-    self.assertIsNone(ret)
+        self.assertIsNone(ret)
-  def test_normal_ver(self):
+    def test_normal_ver(self):
-    """Check handling of normal git versions."""
+        """Check handling of normal git versions."""
-    ret = self.wrapper.ParseGitVersion(ver_str='git version 2.25.1')
+        ret = self.wrapper.ParseGitVersion(ver_str="git version 2.25.1")
-    self.assertEqual(2, ret.major)
+        self.assertEqual(2, ret.major)
-    self.assertEqual(25, ret.minor)
+        self.assertEqual(25, ret.minor)
-    self.assertEqual(1, ret.micro)
+        self.assertEqual(1, ret.micro)
-    self.assertEqual('2.25.1', ret.full)
+        self.assertEqual("2.25.1", ret.full)
-  def test_extended_ver(self):
+    def test_extended_ver(self):
-    """Check handling of extended distro git versions."""
+        """Check handling of extended distro git versions."""
-    ret = self.wrapper.ParseGitVersion(
+        ret = self.wrapper.ParseGitVersion(
-        ver_str='git version 1.30.50.696.g5e7596f4ac-goog')
+            ver_str="git version 1.30.50.696.g5e7596f4ac-goog"
-    self.assertEqual(1, ret.major)
+        )
-    self.assertEqual(30, ret.minor)
+        self.assertEqual(1, ret.major)
-    self.assertEqual(50, ret.micro)
+        self.assertEqual(30, ret.minor)
-    self.assertEqual('1.30.50.696.g5e7596f4ac-goog', ret.full)
+        self.assertEqual(50, ret.micro)
+        self.assertEqual("1.30.50.696.g5e7596f4ac-goog", ret.full)
 class CheckGitVersion(RepoWrapperTestCase):
-  """Check _CheckGitVersion behavior."""
+    """Check _CheckGitVersion behavior."""
-  def test_unknown(self):
+    def test_unknown(self):
-    """Unknown versions should abort."""
+        """Unknown versions should abort."""
-    with mock.patch.object(self.wrapper, 'ParseGitVersion', return_value=None):
+        with mock.patch.object(
-      with self.assertRaises(self.wrapper.CloneFailure):
+            self.wrapper, "ParseGitVersion", return_value=None
-        self.wrapper._CheckGitVersion()
+        ):
+            with self.assertRaises(self.wrapper.CloneFailure):
-  def test_old(self):
+                self.wrapper._CheckGitVersion()
-    """Old versions should abort."""
-    with mock.patch.object(
+    def test_old(self):
-        self.wrapper, 'ParseGitVersion',
+        """Old versions should abort."""
-        return_value=self.wrapper.GitVersion(1, 0, 0, '1.0.0')):
+        with mock.patch.object(
-      with self.assertRaises(self.wrapper.CloneFailure):
+            self.wrapper,
-        self.wrapper._CheckGitVersion()
+            "ParseGitVersion",
+            return_value=self.wrapper.GitVersion(1, 0, 0, "1.0.0"),
-  def test_new(self):
+        ):
-    """Newer versions should run fine."""
+            with self.assertRaises(self.wrapper.CloneFailure):
-    with mock.patch.object(
+                self.wrapper._CheckGitVersion()
-        self.wrapper, 'ParseGitVersion',
-        return_value=self.wrapper.GitVersion(100, 0, 0, '100.0.0')):
+    def test_new(self):
-      self.wrapper._CheckGitVersion()
+        """Newer versions should run fine."""
+        with mock.patch.object(
+            self.wrapper,
+            "ParseGitVersion",
+            return_value=self.wrapper.GitVersion(100, 0, 0, "100.0.0"),
+        ):
+            self.wrapper._CheckGitVersion()
 class Requirements(RepoWrapperTestCase):
-  """Check Requirements handling."""
+    """Check Requirements handling."""
-  def test_missing_file(self):
+    def test_missing_file(self):
-    """Don't crash if the file is missing (old version)."""
+        """Don't crash if the file is missing (old version)."""
-    testdir = os.path.dirname(os.path.realpath(__file__))
+        testdir = os.path.dirname(os.path.realpath(__file__))
-    self.assertIsNone(self.wrapper.Requirements.from_dir(testdir))
+        self.assertIsNone(self.wrapper.Requirements.from_dir(testdir))
-    self.assertIsNone(self.wrapper.Requirements.from_file(
+        self.assertIsNone(
-        os.path.join(testdir, 'xxxxxxxxxxxxxxxxxxxxxxxx')))
+            self.wrapper.Requirements.from_file(
+                os.path.join(testdir, "xxxxxxxxxxxxxxxxxxxxxxxx")
-  def test_corrupt_data(self):
+            )
-    """If the file can't be parsed, don't blow up."""
+        )
-    self.assertIsNone(self.wrapper.Requirements.from_file(__file__))
-    self.assertIsNone(self.wrapper.Requirements.from_data(b'x'))
+    def test_corrupt_data(self):
+        """If the file can't be parsed, don't blow up."""
-  def test_valid_data(self):
+        self.assertIsNone(self.wrapper.Requirements.from_file(__file__))
-    """Make sure we can parse the file we ship."""
+        self.assertIsNone(self.wrapper.Requirements.from_data(b"x"))
-    self.assertIsNotNone(self.wrapper.Requirements.from_data(b'{}'))
-    rootdir = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+    def test_valid_data(self):
-    self.assertIsNotNone(self.wrapper.Requirements.from_dir(rootdir))
+        """Make sure we can parse the file we ship."""
-    self.assertIsNotNone(self.wrapper.Requirements.from_file(os.path.join(
+        self.assertIsNotNone(self.wrapper.Requirements.from_data(b"{}"))
-        rootdir, 'requirements.json')))
+        rootdir = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+        self.assertIsNotNone(self.wrapper.Requirements.from_dir(rootdir))
-  def test_format_ver(self):
+        self.assertIsNotNone(
-    """Check format_ver can format."""
+            self.wrapper.Requirements.from_file(
-    self.assertEqual('1.2.3', self.wrapper.Requirements._format_ver((1, 2, 3)))
+                os.path.join(rootdir, "requirements.json")
-    self.assertEqual('1', self.wrapper.Requirements._format_ver([1]))
+            )
+        )
-  def test_assert_all_unknown(self):
-    """Check assert_all works with incompatible file."""
+    def test_format_ver(self):
-    reqs = self.wrapper.Requirements({})
+        """Check format_ver can format."""
-    reqs.assert_all()
+        self.assertEqual(
+            "1.2.3", self.wrapper.Requirements._format_ver((1, 2, 3))
-  def test_assert_all_new_repo(self):
+        )
-    """Check assert_all accepts new enough repo."""
+        self.assertEqual("1", self.wrapper.Requirements._format_ver([1]))
-    reqs = self.wrapper.Requirements({'repo': {'hard': [1, 0]}})
-    reqs.assert_all()
+    def test_assert_all_unknown(self):
+        """Check assert_all works with incompatible file."""
-  def test_assert_all_old_repo(self):
+        reqs = self.wrapper.Requirements({})
-    """Check assert_all rejects old repo."""
+        reqs.assert_all()
-    reqs = self.wrapper.Requirements({'repo': {'hard': [99999, 0]}})
-    with self.assertRaises(SystemExit):
+    def test_assert_all_new_repo(self):
-      reqs.assert_all()
+        """Check assert_all accepts new enough repo."""
+        reqs = self.wrapper.Requirements({"repo": {"hard": [1, 0]}})
-  def test_assert_all_new_python(self):
+        reqs.assert_all()
-    """Check assert_all accepts new enough python."""
-    reqs = self.wrapper.Requirements({'python': {'hard': sys.version_info}})
+    def test_assert_all_old_repo(self):
-    reqs.assert_all()
+        """Check assert_all rejects old repo."""
+        reqs = self.wrapper.Requirements({"repo": {"hard": [99999, 0]}})
-  def test_assert_all_old_python(self):
+        with self.assertRaises(SystemExit):
-    """Check assert_all rejects old python."""
+            reqs.assert_all()
-    reqs = self.wrapper.Requirements({'python': {'hard': [99999, 0]}})
-    with self.assertRaises(SystemExit):
+    def test_assert_all_new_python(self):
-      reqs.assert_all()
+        """Check assert_all accepts new enough python."""
+        reqs = self.wrapper.Requirements({"python": {"hard": sys.version_info}})
-  def test_assert_ver_unknown(self):
+        reqs.assert_all()
-    """Check assert_ver works with incompatible file."""
-    reqs = self.wrapper.Requirements({})
+    def test_assert_all_old_python(self):
-    reqs.assert_ver('xxx', (1, 0))
+        """Check assert_all rejects old python."""
+        reqs = self.wrapper.Requirements({"python": {"hard": [99999, 0]}})
-  def test_assert_ver_new(self):
+        with self.assertRaises(SystemExit):
-    """Check assert_ver allows new enough versions."""
+            reqs.assert_all()
-    reqs = self.wrapper.Requirements({'git': {'hard': [1, 0], 'soft': [2, 0]}})
-    reqs.assert_ver('git', (1, 0))
+    def test_assert_ver_unknown(self):
-    reqs.assert_ver('git', (1, 5))
+        """Check assert_ver works with incompatible file."""
-    reqs.assert_ver('git', (2, 0))
+        reqs = self.wrapper.Requirements({})
-    reqs.assert_ver('git', (2, 5))
+        reqs.assert_ver("xxx", (1, 0))
-  def test_assert_ver_old(self):
+    def test_assert_ver_new(self):
-    """Check assert_ver rejects old versions."""
+        """Check assert_ver allows new enough versions."""
-    reqs = self.wrapper.Requirements({'git': {'hard': [1, 0], 'soft': [2, 0]}})
+        reqs = self.wrapper.Requirements(
-    with self.assertRaises(SystemExit):
+            {"git": {"hard": [1, 0], "soft": [2, 0]}}
-      reqs.assert_ver('git', (0, 5))
+        )
+        reqs.assert_ver("git", (1, 0))
+        reqs.assert_ver("git", (1, 5))
+        reqs.assert_ver("git", (2, 0))
+        reqs.assert_ver("git", (2, 5))
+    def test_assert_ver_old(self):
+        """Check assert_ver rejects old versions."""
+        reqs = self.wrapper.Requirements(
+            {"git": {"hard": [1, 0], "soft": [2, 0]}}
+        )
+        with self.assertRaises(SystemExit):
+            reqs.assert_ver("git", (0, 5))
 class NeedSetupGnuPG(RepoWrapperTestCase):
-  """Check NeedSetupGnuPG behavior."""
+    """Check NeedSetupGnuPG behavior."""
-  def test_missing_dir(self):
+    def test_missing_dir(self):
-    """The ~/.repoconfig tree doesn't exist yet."""
+        """The ~/.repoconfig tree doesn't exist yet."""
-    with tempfile.TemporaryDirectory(prefix='repo-tests') as tempdir:
+        with tempfile.TemporaryDirectory(prefix="repo-tests") as tempdir:
-      self.wrapper.home_dot_repo = os.path.join(tempdir, 'foo')
+            self.wrapper.home_dot_repo = os.path.join(tempdir, "foo")
-      self.assertTrue(self.wrapper.NeedSetupGnuPG())
+            self.assertTrue(self.wrapper.NeedSetupGnuPG())
-  def test_missing_keyring(self):
+    def test_missing_keyring(self):
-    """The keyring-version file doesn't exist yet."""
+        """The keyring-version file doesn't exist yet."""
-    with tempfile.TemporaryDirectory(prefix='repo-tests') as tempdir:
+        with tempfile.TemporaryDirectory(prefix="repo-tests") as tempdir:
-      self.wrapper.home_dot_repo = tempdir
+            self.wrapper.home_dot_repo = tempdir
-      self.assertTrue(self.wrapper.NeedSetupGnuPG())
+            self.assertTrue(self.wrapper.NeedSetupGnuPG())
-  def test_empty_keyring(self):
+    def test_empty_keyring(self):
-    """The keyring-version file exists, but is empty."""
+        """The keyring-version file exists, but is empty."""
-    with tempfile.TemporaryDirectory(prefix='repo-tests') as tempdir:
+        with tempfile.TemporaryDirectory(prefix="repo-tests") as tempdir:
-      self.wrapper.home_dot_repo = tempdir
+            self.wrapper.home_dot_repo = tempdir
-      with open(os.path.join(tempdir, 'keyring-version'), 'w'):
+            with open(os.path.join(tempdir, "keyring-version"), "w"):
-        pass
+                pass
-      self.assertTrue(self.wrapper.NeedSetupGnuPG())
+            self.assertTrue(self.wrapper.NeedSetupGnuPG())
-  def test_old_keyring(self):
+    def test_old_keyring(self):
-    """The keyring-version file exists, but it's old."""
+        """The keyring-version file exists, but it's old."""
-    with tempfile.TemporaryDirectory(prefix='repo-tests') as tempdir:
+        with tempfile.TemporaryDirectory(prefix="repo-tests") as tempdir:
-      self.wrapper.home_dot_repo = tempdir
+            self.wrapper.home_dot_repo = tempdir
-      with open(os.path.join(tempdir, 'keyring-version'), 'w') as fp:
+            with open(os.path.join(tempdir, "keyring-version"), "w") as fp:
-        fp.write('1.0\n')
+                fp.write("1.0\n")
-      self.assertTrue(self.wrapper.NeedSetupGnuPG())
+            self.assertTrue(self.wrapper.NeedSetupGnuPG())
-  def test_new_keyring(self):
+    def test_new_keyring(self):
-    """The keyring-version file exists, and is up-to-date."""
+        """The keyring-version file exists, and is up-to-date."""
-    with tempfile.TemporaryDirectory(prefix='repo-tests') as tempdir:
+        with tempfile.TemporaryDirectory(prefix="repo-tests") as tempdir:
-      self.wrapper.home_dot_repo = tempdir
+            self.wrapper.home_dot_repo = tempdir
-      with open(os.path.join(tempdir, 'keyring-version'), 'w') as fp:
+            with open(os.path.join(tempdir, "keyring-version"), "w") as fp:
-        fp.write('1000.0\n')
+                fp.write("1000.0\n")
-      self.assertFalse(self.wrapper.NeedSetupGnuPG())
+            self.assertFalse(self.wrapper.NeedSetupGnuPG())
 class SetupGnuPG(RepoWrapperTestCase):
-  """Check SetupGnuPG behavior."""
+    """Check SetupGnuPG behavior."""
-  def test_full(self):
+    def test_full(self):
-    """Make sure it works completely."""
+        """Make sure it works completely."""
-    with tempfile.TemporaryDirectory(prefix='repo-tests') as tempdir:
+        with tempfile.TemporaryDirectory(prefix="repo-tests") as tempdir:
-      self.wrapper.home_dot_repo = tempdir
+            self.wrapper.home_dot_repo = tempdir
-      self.wrapper.gpg_dir = os.path.join(self.wrapper.home_dot_repo, 'gnupg')
+            self.wrapper.gpg_dir = os.path.join(
-      self.assertTrue(self.wrapper.SetupGnuPG(True))
+                self.wrapper.home_dot_repo, "gnupg"
-      with open(os.path.join(tempdir, 'keyring-version'), 'r') as fp:
+            )
-        data = fp.read()
+            self.assertTrue(self.wrapper.SetupGnuPG(True))
-      self.assertEqual('.'.join(str(x) for x in self.wrapper.KEYRING_VERSION),
+            with open(os.path.join(tempdir, "keyring-version"), "r") as fp:
-                       data.strip())
+                data = fp.read()
+            self.assertEqual(
+                ".".join(str(x) for x in self.wrapper.KEYRING_VERSION),
+                data.strip(),
+            )
 class VerifyRev(RepoWrapperTestCase):
-  """Check verify_rev behavior."""
+    """Check verify_rev behavior."""
-  def test_verify_passes(self):
+    def test_verify_passes(self):
-    """Check when we have a valid signed tag."""
+        """Check when we have a valid signed tag."""
-    desc_result = self.wrapper.RunResult(0, 'v1.0\n', '')
+        desc_result = self.wrapper.RunResult(0, "v1.0\n", "")
-    gpg_result = self.wrapper.RunResult(0, '', '')
+        gpg_result = self.wrapper.RunResult(0, "", "")
-    with mock.patch.object(self.wrapper, 'run_git',
+        with mock.patch.object(
-                           side_effect=(desc_result, gpg_result)):
+            self.wrapper, "run_git", side_effect=(desc_result, gpg_result)
-      ret = self.wrapper.verify_rev('/', 'refs/heads/stable', '1234', True)
+        ):
-      self.assertEqual('v1.0^0', ret)
+            ret = self.wrapper.verify_rev(
+                "/", "refs/heads/stable", "1234", True
-  def test_unsigned_commit(self):
+            )
-    """Check we fall back to signed tag when we have an unsigned commit."""
+            self.assertEqual("v1.0^0", ret)
-    desc_result = self.wrapper.RunResult(0, 'v1.0-10-g1234\n', '')
-    gpg_result = self.wrapper.RunResult(0, '', '')
+    def test_unsigned_commit(self):
-    with mock.patch.object(self.wrapper, 'run_git',
+        """Check we fall back to signed tag when we have an unsigned commit."""
-                           side_effect=(desc_result, gpg_result)):
+        desc_result = self.wrapper.RunResult(0, "v1.0-10-g1234\n", "")
-      ret = self.wrapper.verify_rev('/', 'refs/heads/stable', '1234', True)
+        gpg_result = self.wrapper.RunResult(0, "", "")
-      self.assertEqual('v1.0^0', ret)
+        with mock.patch.object(
+            self.wrapper, "run_git", side_effect=(desc_result, gpg_result)
-  def test_verify_fails(self):
+        ):
-    """Check we fall back to signed tag when we have an unsigned commit."""
+            ret = self.wrapper.verify_rev(
-    desc_result = self.wrapper.RunResult(0, 'v1.0-10-g1234\n', '')
+                "/", "refs/heads/stable", "1234", True
-    gpg_result = Exception
+            )
-    with mock.patch.object(self.wrapper, 'run_git',
+            self.assertEqual("v1.0^0", ret)
-                           side_effect=(desc_result, gpg_result)):
-      with self.assertRaises(Exception):
+    def test_verify_fails(self):
-        self.wrapper.verify_rev('/', 'refs/heads/stable', '1234', True)
+        """Check we fall back to signed tag when we have an unsigned commit."""
+        desc_result = self.wrapper.RunResult(0, "v1.0-10-g1234\n", "")
+        gpg_result = Exception
+        with mock.patch.object(
+            self.wrapper, "run_git", side_effect=(desc_result, gpg_result)
+        ):
+            with self.assertRaises(Exception):
+                self.wrapper.verify_rev("/", "refs/heads/stable", "1234", True)
 class GitCheckoutTestCase(RepoWrapperTestCase):
-  """Tests that use a real/small git checkout."""
+    """Tests that use a real/small git checkout."""
-  GIT_DIR = None
+    GIT_DIR = None
-  REV_LIST = None
+    REV_LIST = None
-  @classmethod
+    @classmethod
-  def setUpClass(cls):
+    def setUpClass(cls):
-    # Create a repo to operate on, but do it once per-class.
+        # Create a repo to operate on, but do it once per-class.
-    cls.tempdirobj = tempfile.TemporaryDirectory(prefix='repo-rev-tests')
+        cls.tempdirobj = tempfile.TemporaryDirectory(prefix="repo-rev-tests")
-    cls.GIT_DIR = cls.tempdirobj.name
+        cls.GIT_DIR = cls.tempdirobj.name
-    run_git = wrapper.Wrapper().run_git
+        run_git = wrapper.Wrapper().run_git
-    remote = os.path.join(cls.GIT_DIR, 'remote')
+        remote = os.path.join(cls.GIT_DIR, "remote")
-    os.mkdir(remote)
+        os.mkdir(remote)
-    # Tests need to assume, that main is default branch at init,
+        # Tests need to assume, that main is default branch at init,
-    # which is not supported in config until 2.28.
+        # which is not supported in config until 2.28.
-    if git_command.git_require((2, 28, 0)):
+        if git_command.git_require((2, 28, 0)):
-      initstr = '--initial-branch=main'
+            initstr = "--initial-branch=main"
-    else:
+        else:
-      # Use template dir for init.
+            # Use template dir for init.
-      templatedir = tempfile.mkdtemp(prefix='.test-template')
+            templatedir = tempfile.mkdtemp(prefix=".test-template")
-      with open(os.path.join(templatedir, 'HEAD'), 'w') as fp:
+            with open(os.path.join(templatedir, "HEAD"), "w") as fp:
-        fp.write('ref: refs/heads/main\n')
+                fp.write("ref: refs/heads/main\n")
-      initstr = '--template=' + templatedir
+            initstr = "--template=" + templatedir
-    run_git('init', initstr, cwd=remote)
+        run_git("init", initstr, cwd=remote)
-    run_git('commit', '--allow-empty', '-minit', cwd=remote)
+        run_git("commit", "--allow-empty", "-minit", cwd=remote)
-    run_git('branch', 'stable', cwd=remote)
+        run_git("branch", "stable", cwd=remote)
-    run_git('tag', 'v1.0', cwd=remote)
+        run_git("tag", "v1.0", cwd=remote)
-    run_git('commit', '--allow-empty', '-m2nd commit', cwd=remote)
+        run_git("commit", "--allow-empty", "-m2nd commit", cwd=remote)
-    cls.REV_LIST = run_git('rev-list', 'HEAD', cwd=remote).stdout.splitlines()
+        cls.REV_LIST = run_git(
+            "rev-list", "HEAD", cwd=remote
-    run_git('init', cwd=cls.GIT_DIR)
+        ).stdout.splitlines()
-    run_git('fetch', remote, '+refs/heads/*:refs/remotes/origin/*', cwd=cls.GIT_DIR)
+        run_git("init", cwd=cls.GIT_DIR)
-  @classmethod
+        run_git(
-  def tearDownClass(cls):
+            "fetch",
-    if not cls.tempdirobj:
+            remote,
-      return
+            "+refs/heads/*:refs/remotes/origin/*",
+            cwd=cls.GIT_DIR,
-    cls.tempdirobj.cleanup()
+        )
+    @classmethod
+    def tearDownClass(cls):
+        if not cls.tempdirobj:
+            return
+        cls.tempdirobj.cleanup()
 class ResolveRepoRev(GitCheckoutTestCase):
-  """Check resolve_repo_rev behavior."""
+    """Check resolve_repo_rev behavior."""
-  def test_explicit_branch(self):
+    def test_explicit_branch(self):
-    """Check refs/heads/branch argument."""
+        """Check refs/heads/branch argument."""
-    rrev, lrev = self.wrapper.resolve_repo_rev(self.GIT_DIR, 'refs/heads/stable')
+        rrev, lrev = self.wrapper.resolve_repo_rev(
-    self.assertEqual('refs/heads/stable', rrev)
+            self.GIT_DIR, "refs/heads/stable"
-    self.assertEqual(self.REV_LIST[1], lrev)
+        )
+        self.assertEqual("refs/heads/stable", rrev)
-    with self.assertRaises(self.wrapper.CloneFailure):
+        self.assertEqual(self.REV_LIST[1], lrev)
-      self.wrapper.resolve_repo_rev(self.GIT_DIR, 'refs/heads/unknown')
+        with self.assertRaises(self.wrapper.CloneFailure):
-  def test_explicit_tag(self):
+            self.wrapper.resolve_repo_rev(self.GIT_DIR, "refs/heads/unknown")
-    """Check refs/tags/tag argument."""
-    rrev, lrev = self.wrapper.resolve_repo_rev(self.GIT_DIR, 'refs/tags/v1.0')
+    def test_explicit_tag(self):
-    self.assertEqual('refs/tags/v1.0', rrev)
+        """Check refs/tags/tag argument."""
-    self.assertEqual(self.REV_LIST[1], lrev)
+        rrev, lrev = self.wrapper.resolve_repo_rev(
+            self.GIT_DIR, "refs/tags/v1.0"
-    with self.assertRaises(self.wrapper.CloneFailure):
+        )
-      self.wrapper.resolve_repo_rev(self.GIT_DIR, 'refs/tags/unknown')
+        self.assertEqual("refs/tags/v1.0", rrev)
+        self.assertEqual(self.REV_LIST[1], lrev)
-  def test_branch_name(self):
-    """Check branch argument."""
+        with self.assertRaises(self.wrapper.CloneFailure):
-    rrev, lrev = self.wrapper.resolve_repo_rev(self.GIT_DIR, 'stable')
+            self.wrapper.resolve_repo_rev(self.GIT_DIR, "refs/tags/unknown")
-    self.assertEqual('refs/heads/stable', rrev)
-    self.assertEqual(self.REV_LIST[1], lrev)
+    def test_branch_name(self):
+        """Check branch argument."""
-    rrev, lrev = self.wrapper.resolve_repo_rev(self.GIT_DIR, 'main')
+        rrev, lrev = self.wrapper.resolve_repo_rev(self.GIT_DIR, "stable")
-    self.assertEqual('refs/heads/main', rrev)
+        self.assertEqual("refs/heads/stable", rrev)
-    self.assertEqual(self.REV_LIST[0], lrev)
+        self.assertEqual(self.REV_LIST[1], lrev)
-  def test_tag_name(self):
+        rrev, lrev = self.wrapper.resolve_repo_rev(self.GIT_DIR, "main")
-    """Check tag argument."""
+        self.assertEqual("refs/heads/main", rrev)
-    rrev, lrev = self.wrapper.resolve_repo_rev(self.GIT_DIR, 'v1.0')
+        self.assertEqual(self.REV_LIST[0], lrev)
-    self.assertEqual('refs/tags/v1.0', rrev)
-    self.assertEqual(self.REV_LIST[1], lrev)
+    def test_tag_name(self):
+        """Check tag argument."""
-  def test_full_commit(self):
+        rrev, lrev = self.wrapper.resolve_repo_rev(self.GIT_DIR, "v1.0")
-    """Check specific commit argument."""
+        self.assertEqual("refs/tags/v1.0", rrev)
-    commit = self.REV_LIST[0]
+        self.assertEqual(self.REV_LIST[1], lrev)
-    rrev, lrev = self.wrapper.resolve_repo_rev(self.GIT_DIR, commit)
-    self.assertEqual(commit, rrev)
+    def test_full_commit(self):
-    self.assertEqual(commit, lrev)
+        """Check specific commit argument."""
+        commit = self.REV_LIST[0]
-  def test_partial_commit(self):
+        rrev, lrev = self.wrapper.resolve_repo_rev(self.GIT_DIR, commit)
-    """Check specific (partial) commit argument."""
+        self.assertEqual(commit, rrev)
-    commit = self.REV_LIST[0][0:20]
+        self.assertEqual(commit, lrev)
-    rrev, lrev = self.wrapper.resolve_repo_rev(self.GIT_DIR, commit)
-    self.assertEqual(self.REV_LIST[0], rrev)
+    def test_partial_commit(self):
-    self.assertEqual(self.REV_LIST[0], lrev)
+        """Check specific (partial) commit argument."""
+        commit = self.REV_LIST[0][0:20]
-  def test_unknown(self):
+        rrev, lrev = self.wrapper.resolve_repo_rev(self.GIT_DIR, commit)
-    """Check unknown ref/commit argument."""
+        self.assertEqual(self.REV_LIST[0], rrev)
-    with self.assertRaises(self.wrapper.CloneFailure):
+        self.assertEqual(self.REV_LIST[0], lrev)
-      self.wrapper.resolve_repo_rev(self.GIT_DIR, 'boooooooya')
+    def test_unknown(self):
+        """Check unknown ref/commit argument."""
+        with self.assertRaises(self.wrapper.CloneFailure):
+            self.wrapper.resolve_repo_rev(self.GIT_DIR, "boooooooya")
 class CheckRepoVerify(RepoWrapperTestCase):
-  """Check check_repo_verify behavior."""
+    """Check check_repo_verify behavior."""
-  def test_no_verify(self):
+    def test_no_verify(self):
-    """Always fail with --no-repo-verify."""
+        """Always fail with --no-repo-verify."""
-    self.assertFalse(self.wrapper.check_repo_verify(False))
+        self.assertFalse(self.wrapper.check_repo_verify(False))
-  def test_gpg_initialized(self):
+    def test_gpg_initialized(self):
-    """Should pass if gpg is setup already."""
+        """Should pass if gpg is setup already."""
-    with mock.patch.object(self.wrapper, 'NeedSetupGnuPG', return_value=False):
+        with mock.patch.object(
-      self.assertTrue(self.wrapper.check_repo_verify(True))
+            self.wrapper, "NeedSetupGnuPG", return_value=False
+        ):
+            self.assertTrue(self.wrapper.check_repo_verify(True))
-  def test_need_gpg_setup(self):
+    def test_need_gpg_setup(self):
-    """Should pass/fail based on gpg setup."""
+        """Should pass/fail based on gpg setup."""
-    with mock.patch.object(self.wrapper, 'NeedSetupGnuPG', return_value=True):
+        with mock.patch.object(
-      with mock.patch.object(self.wrapper, 'SetupGnuPG') as m:
+            self.wrapper, "NeedSetupGnuPG", return_value=True
-        m.return_value = True
+        ):
-        self.assertTrue(self.wrapper.check_repo_verify(True))
+            with mock.patch.object(self.wrapper, "SetupGnuPG") as m:
+                m.return_value = True
+                self.assertTrue(self.wrapper.check_repo_verify(True))
-        m.return_value = False
+                m.return_value = False
-        self.assertFalse(self.wrapper.check_repo_verify(True))
+                self.assertFalse(self.wrapper.check_repo_verify(True))
 class CheckRepoRev(GitCheckoutTestCase):
-  """Check check_repo_rev behavior."""
+    """Check check_repo_rev behavior."""
-  def test_verify_works(self):
+    def test_verify_works(self):
-    """Should pass when verification passes."""
+        """Should pass when verification passes."""
-    with mock.patch.object(self.wrapper, 'check_repo_verify', return_value=True):
+        with mock.patch.object(
-      with mock.patch.object(self.wrapper, 'verify_rev', return_value='12345'):
+            self.wrapper, "check_repo_verify", return_value=True
-        rrev, lrev = self.wrapper.check_repo_rev(self.GIT_DIR, 'stable')
+        ):
-    self.assertEqual('refs/heads/stable', rrev)
+            with mock.patch.object(
-    self.assertEqual('12345', lrev)
+                self.wrapper, "verify_rev", return_value="12345"
+            ):
-  def test_verify_fails(self):
+                rrev, lrev = self.wrapper.check_repo_rev(self.GIT_DIR, "stable")
-    """Should fail when verification fails."""
+        self.assertEqual("refs/heads/stable", rrev)
-    with mock.patch.object(self.wrapper, 'check_repo_verify', return_value=True):
+        self.assertEqual("12345", lrev)
-      with mock.patch.object(self.wrapper, 'verify_rev', side_effect=Exception):
-        with self.assertRaises(Exception):
+    def test_verify_fails(self):
-          self.wrapper.check_repo_rev(self.GIT_DIR, 'stable')
+        """Should fail when verification fails."""
+        with mock.patch.object(
-  def test_verify_ignore(self):
+            self.wrapper, "check_repo_verify", return_value=True
-    """Should pass when verification is disabled."""
+        ):
-    with mock.patch.object(self.wrapper, 'verify_rev', side_effect=Exception):
+            with mock.patch.object(
-      rrev, lrev = self.wrapper.check_repo_rev(self.GIT_DIR, 'stable', repo_verify=False)
+                self.wrapper, "verify_rev", side_effect=Exception
-    self.assertEqual('refs/heads/stable', rrev)
+            ):
-    self.assertEqual(self.REV_LIST[1], lrev)
+                with self.assertRaises(Exception):
+                    self.wrapper.check_repo_rev(self.GIT_DIR, "stable")
+    def test_verify_ignore(self):
+        """Should pass when verification is disabled."""
+        with mock.patch.object(
+            self.wrapper, "verify_rev", side_effect=Exception
+        ):
+            rrev, lrev = self.wrapper.check_repo_rev(
+                self.GIT_DIR, "stable", repo_verify=False
+            )
+        self.assertEqual("refs/heads/stable", rrev)
+        self.assertEqual(self.REV_LIST[1], lrev)
diff --git a/tox.ini b/tox.ini
index 8d3cc43c..2575a713 100644
--- a/tox.ini
+++ b/tox.ini
@@ -27,6 +27,7 @@ python =
 [testenv]
 deps =
+    black
    pytest
    pytest-timeout
 commands = {envpython} run_tests {posargs}
diff --git a/wrapper.py b/wrapper.py
index 3099ad5d..d8823368 100644
--- a/wrapper.py
+++ b/wrapper.py
@@ -19,14 +19,14 @@ import os
 def WrapperPath():
-  return os.path.join(os.path.dirname(__file__), 'repo')
+    return os.path.join(os.path.dirname(__file__), "repo")
 @functools.lru_cache(maxsize=None)
 def Wrapper():
-  modname = 'wrapper'
+    modname = "wrapper"
-  loader = importlib.machinery.SourceFileLoader(modname, WrapperPath())
+    loader = importlib.machinery.SourceFileLoader(modname, WrapperPath())
-  spec = importlib.util.spec_from_loader(modname, loader)
+    spec = importlib.util.spec_from_loader(modname, loader)
-  module = importlib.util.module_from_spec(spec)
+    module = importlib.util.module_from_spec(spec)
-  loader.exec_module(module)
+    loader.exec_module(module)
-  return module
+    return module