git_cl: convert to print_function

git_cl.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 # Copyright (C) 2008 Evan Martin <martine@danga.com>
 
 """A git-command for integrating reviews on Rietveld and Gerrit."""
 
+from __future__ import print_function
+
 from distutils.version import LooseVersion
 from multiprocessing.pool import ThreadPool
 import base64
 import collections
 import glob
 import httplib
 import json
 import logging
 import multiprocessing
 import optparse
@@ skipping 56 matching lines @@
 DEFAULT_LINT_IGNORE_REGEX = r"$^"
 
 # Shortcut since it quickly becomes redundant.
 Fore = colorama.Fore
 
 # Initialized in main()
 settings = None
 
 
 def DieWithError(message):
-  print >> sys.stderr, message
+  print(message, file=sys.stderr)
   sys.exit(1)
 
 
 def GetNoGitPagerEnv():
   env = os.environ.copy()
   # 'cat' is a magical git string that disables pagers on all platforms.
   env['GIT_PAGER'] = 'cat'
   return env
 
 
@@ skipping 262 matching lines @@
   _buildbucket_retry(
       'triggering tryjobs',
       http,
       buildbucket_put_url,
       'PUT',
       body=json.dumps(batch_req_body),
       headers={'Content-Type': 'application/json'}
   )
   print_text.append('To see results here, run:        git cl try-results')
   print_text.append('To see results in browser, run:  git cl web')
-  print '\n'.join(print_text)
+  print('\n'.join(print_text))
 
 
 def fetch_try_jobs(auth_config, changelist, options):
   """Fetches tryjobs from buildbucket.
 
   Returns a map from build id to build info as json dictionary.
   """
   rietveld_url = settings.GetDefaultServerUrl()
   rietveld_host = urlparse.urlparse(rietveld_url).hostname
   authenticator = auth.get_authenticator_for_host(rietveld_host, auth_config)
   if authenticator.has_cached_credentials():
     http = authenticator.authorize(httplib2.Http())
   else:
-    print ('Warning: Some results might be missing because %s' %
-           # Get the message on how to login.
-           auth.LoginRequiredError(rietveld_host).message)
+    print('Warning: Some results might be missing because %s' %
+          # Get the message on how to login.
+          (auth.LoginRequiredError(rietveld_host).message,))
     http = httplib2.Http()
 
   http.force_exception_to_status_code = True
 
   buildset = 'patch/rietveld/{hostname}/{issue}/{patch}'.format(
       hostname=rietveld_host,
       issue=changelist.GetIssue(),
       patch=options.patchset)
   params = {'tag': 'buildset:%s' % buildset}
 
   builds = {}
   while True:
     url = 'https://{hostname}/_ah/api/buildbucket/v1/search?{params}'.format(
         hostname=options.buildbucket_host,
         params=urllib.urlencode(params))
     content = _buildbucket_retry('fetching tryjobs', http, url, 'GET')
     for build in content.get('builds', []):
       builds[build['id']] = build
     if 'next_cursor' in content:
       params['start_cursor'] = content['next_cursor']
     else:
       break
   return builds
 
 
 def print_tryjobs(options, builds):
   """Prints nicely result of fetch_try_jobs."""
   if not builds:
-    print 'No tryjobs scheduled'
+    print('No tryjobs scheduled')
     return
 
   # Make a copy, because we'll be modifying builds dictionary.
   builds = builds.copy()
   builder_names_cache = {}
 
   def get_builder(b):
     try:
       return builder_names_cache[b['id']]
     except KeyError:
       try:
         parameters = json.loads(b['parameters_json'])
         name = parameters['builder_name']
       except (ValueError, KeyError) as error:
-        print 'WARNING: failed to get builder name for build %s: %s' % (
-              b['id'], error)
+        print('WARNING: failed to get builder name for build %s: %s' % (
+              b['id'], error))
         name = None
       builder_names_cache[b['id']] = name
       return name
 
   def get_bucket(b):
     bucket = b['bucket']
     if bucket.startswith('master.'):
       return bucket[len('master.'):]
     return bucket
 
@@ skipping 19 matching lines @@
       colorize = str
     else:
       colorize = lambda x: '%s%s%s' % (color, x, Fore.RESET)
 
     result = []
     for b in builds.values():
       if all(b.get(k) == v for k, v in kwargs.iteritems()):
         builds.pop(b['id'])
         result.append(b)
     if result:
-      print colorize(title)
+      print(colorize(title))
       for b in sorted(result, key=sort_key):
-        print ' ', colorize('\t'.join(map(str, f(b))))
+        print(' ', colorize('\t'.join(map(str, f(b)))))
 
   total = len(builds)
   pop(status='COMPLETED', result='SUCCESS',
       title='Successes:', color=Fore.GREEN,
       f=lambda b: (get_name(b), b.get('url')))
   pop(status='COMPLETED', result='FAILURE', failure_reason='INFRA_FAILURE',
       title='Infra Failures:', color=Fore.MAGENTA,
       f=lambda b: (get_name(b), b.get('url')))
   pop(status='COMPLETED', result='FAILURE', failure_reason='BUILD_FAILURE',
       title='Failures:', color=Fore.RED,
@@ skipping 14 matching lines @@
   pop(status='STARTED',
       title='Started:', color=Fore.YELLOW,
       f=lambda b: (get_name(b), b.get('url')))
   pop(status='SCHEDULED',
       title='Scheduled:',
       f=lambda b: (get_name(b), 'id=%s' % b['id']))
   # The last section is just in case buildbucket API changes OR there is a bug.
   pop(title='Other:',
       f=lambda b: (get_name(b), 'id=%s' % b['id']))
   assert len(builds) == 0
-  print 'Total: %d tryjobs' % total
+  print('Total: %d tryjobs' % total)
 
 
 def MatchSvnGlob(url, base_url, glob_spec, allow_wildcards):
   """Return the corresponding git ref if |base_url| together with |glob_spec|
   matches the full |url|.
 
   If |allow_wildcards| is true, |glob_spec| can contain wildcards (see below).
   """
   fetch_suburl, as_ref = glob_spec.split(':')
   if allow_wildcards:
@@ skipping 596 matching lines @@
         self._remote = (remote, branch.replace('refs/', 'refs/remotes/'))
       else:
         self._remote = (remote, 'refs/remotes/%s/%s' % (remote, branch))
     return self._remote
 
   def GitSanityChecks(self, upstream_git_obj):
     """Checks git repo status and ensures diff is from local commits."""
 
     if upstream_git_obj is None:
       if self.GetBranch() is None:
-        print >> sys.stderr, (
-            'ERROR: unable to determine current branch (detached HEAD?)')
+        print('ERROR: unable to determine current branch (detached HEAD?)',
+              file=sys.stderr)
       else:
-        print >> sys.stderr, (
-            'ERROR: no upstream branch')
+        print('ERROR: no upstream branch', file=sys.stderr)
       return False
 
     # Verify the commit we're diffing against is in our current branch.
     upstream_sha = RunGit(['rev-parse', '--verify', upstream_git_obj]).strip()
     common_ancestor = RunGit(['merge-base', upstream_sha, 'HEAD']).strip()
     if upstream_sha != common_ancestor:
-      print >> sys.stderr, (
-          'ERROR: %s is not in the current branch.  You may need to rebase '
-          'your tracking branch' % upstream_sha)
+      print('ERROR: %s is not in the current branch.  You may need to rebase '
+            'your tracking branch' % upstream_sha, file=sys.stderr)
       return False
 
     # List the commits inside the diff, and verify they are all local.
     commits_in_diff = RunGit(
         ['rev-list', '^%s' % upstream_sha, 'HEAD']).splitlines()
     code, remote_branch = RunGitWithCode(['config', 'gitcl.remotebranch'])
     remote_branch = remote_branch.strip()
     if code != 0:
       _, remote_branch = self.GetRemoteBranch()
 
     commits_in_remote = RunGit(
         ['rev-list', '^%s' % upstream_sha, remote_branch]).splitlines()
 
     common_commits = set(commits_in_diff) & set(commits_in_remote)
     if common_commits:
-      print >> sys.stderr, (
-          'ERROR: Your diff contains %d commits already in %s.\n'
-          'Run "git log --oneline %s..HEAD" to get a list of commits in '
-          'the diff.  If you are using a custom git flow, you can override'
-          ' the reference used for this check with "git config '
-          'gitcl.remotebranch <git-ref>".' % (
-              len(common_commits), remote_branch, upstream_git_obj))
+      print('ERROR: Your diff contains %d commits already in %s.\n'
+            'Run "git log --oneline %s..HEAD" to get a list of commits in '
+            'the diff.  If you are using a custom git flow, you can override'
+            ' the reference used for this check with "git config '
+            'gitcl.remotebranch <git-ref>".' % (
+                len(common_commits), remote_branch, upstream_git_obj),
+            file=sys.stderr)
       return False
     return True
 
   def GetGitBaseUrlFromConfig(self):
     """Return the configured base URL from branch.<branchname>.baseurl.
 
     Returns None if it is not set.
     """
     return RunGit(['config', 'branch.%s.base-url' % self.GetBranch()],
                   error_ok=True).strip()
@@ skipping 212 matching lines @@
       if not hook_results.should_continue():
         return 1
       if not options.reviewers and hook_results.reviewers:
         options.reviewers = hook_results.reviewers.split(',')
 
     if self.GetIssue():
       latest_patchset = self.GetMostRecentPatchset()
       local_patchset = self.GetPatchset()
       if (latest_patchset and local_patchset and
           local_patchset != latest_patchset):
-        print ('The last upload made from this repository was patchset #%d but '
-               'the most recent patchset on the server is #%d.'
-               % (local_patchset, latest_patchset))
-        print ('Uploading will still work, but if you\'ve uploaded to this '
-               'issue from another machine or branch the patch you\'re '
-               'uploading now might not include those changes.')
+        print('The last upload made from this repository was patchset #%d but '
+              'the most recent patchset on the server is #%d.'
+              % (local_patchset, latest_patchset))
+        print('Uploading will still work, but if you\'ve uploaded to this '
+              'issue from another machine or branch the patch you\'re '
+              'uploading now might not include those changes.')
         ask_for_data('About to upload; enter to confirm.')
 
     print_stats(options.similarity, options.find_copies, git_diff_args)
     ret = self.CMDUploadChange(options, git_diff_args, change)
     if not ret:
       git_set_branch_value('last-upload-hash',
                            RunGit(['rev-parse', 'HEAD']).strip())
       # Run post upload hooks, if specified.
       if settings.GetRunPostUploadHook():
         presubmit_support.DoPostUploadExecuter(
             change,
             self,
             settings.GetRoot(),
             options.verbose,
             sys.stdout)
 
       # Upload all dependencies if specified.
       if options.dependencies:
-        print
-        print '--dependencies has been specified.'
-        print 'All dependent local branches will be re-uploaded.'
-        print
+        print()
+        print('--dependencies has been specified.')
+        print('All dependent local branches will be re-uploaded.')
+        print()
         # Remove the dependencies flag from args so that we do not end up in a
         # loop.
         orig_args.remove('--dependencies')
         ret = upload_branch_deps(self, orig_args)
     return ret
 
   def SetCQState(self, new_state):
     """Update the CQ state for latest patchset.
 
     Issue must have been already uploaded and known.
@@ skipping 188 matching lines @@
              'error. It is likely that you deleted this '
              'issue on the server. If this is the\n'
              'case, please run\n\n'
              '    git cl issue 0\n\n'
              'to clear the association with the deleted issue. Then run '
              'this command again.') % issue)
       else:
         DieWithError(
             '\nFailed to fetch issue description. HTTP error %d' % e.code)
     except urllib2.URLError as e:
-      print >> sys.stderr, (
-          'Warning: Failed to retrieve CL description due to network '
-          'failure.')
+      print('Warning: Failed to retrieve CL description due to network '
+            'failure.', file=sys.stderr)
       return ''
 
   def GetMostRecentPatchset(self):
     return self.GetIssueProperties()['patchsets'][-1]
 
   def GetPatchSetDiff(self, issue, patchset):
     return self.RpcServer().get(
         '/download/issue%s_%s.diff' % (issue, patchset))
 
   def GetIssueProperties(self):
@@ skipping 171 matching lines @@
     if directory:
       cmd.extend(('--directory', directory))
     if reject:
       cmd.append('--reject')
     elif IsGitVersionAtLeast('1.7.12'):
       cmd.append('--3way')
     try:
       subprocess2.check_call(cmd, env=GetNoGitPagerEnv(),
                              stdin=patch_data, stdout=subprocess2.VOID)
     except subprocess2.CalledProcessError:
-      print 'Failed to apply the patch'
+      print('Failed to apply the patch')
       return 1
 
     # If we had an issue, commit the current state and register the issue.
     if not nocommit:
       RunGit(['commit', '-m', (self.GetDescription() + '\n\n' +
                                'patch from issue %(i)s at patchset '
                                '%(p)s (http://crrev.com/%(i)s#ps%(p)s)'
                                % {'i': self.GetIssue(), 'p': patchset})])
       self.SetIssue(self.GetIssue())
       self.SetPatchset(patchset)
-      print "Committed patch locally."
+      print('Committed patch locally.')
     else:
-      print "Patch applied to index."
+      print('Patch applied to index.')
     return 0
 
   @staticmethod
   def ParseIssueURL(parsed_url):
     if not parsed_url.scheme or not parsed_url.scheme.startswith('http'):
       return None
     # Typical url: https://domain/<issue_number>[/[other]]
     match = re.match('/(\d+)(/.*)?$', parsed_url.path)
     if match:
       return _RietveldParsedIssueNumberArgument(
@@ skipping 21 matching lines @@
 
     if options.email is not None:
       upload_args.extend(['--email', options.email])
 
     if self.GetIssue():
       if options.title:
         upload_args.extend(['--title', options.title])
       if options.message:
         upload_args.extend(['--message', options.message])
       upload_args.extend(['--issue', str(self.GetIssue())])
-      print ('This branch is associated with issue %s. '
-             'Adding patch to that issue.' % self.GetIssue())
+      print('This branch is associated with issue %s. '
+            'Adding patch to that issue.' % self.GetIssue())
     else:
       if options.title:
         upload_args.extend(['--title', options.title])
       message = (options.title or options.message or
                  CreateDescriptionFromLog(args))
       change_desc = ChangeDescription(message)
       if options.reviewers or options.tbr_owners:
         change_desc.update_reviewers(options.reviewers,
                                      options.tbr_owners,
                                      change)
       if not options.force:
         change_desc.prompt()
 
       if not change_desc.description:
-        print "Description is empty; aborting."
+        print('Description is empty; aborting.')
         return 1
 
       upload_args.extend(['--message', change_desc.description])
       if change_desc.get_reviewers():
         upload_args.append('--reviewers=%s' % ','.join(
             change_desc.get_reviewers()))
       if options.send_mail:
         if not change_desc.get_reviewers():
           DieWithError("Must specify reviewers to send email.")
         upload_args.append('--send_mail')
@@ skipping 37 matching lines @@
       if target_ref:
         upload_args.extend(['--target_ref', target_ref])
 
       # Look for dependent patchsets. See crbug.com/480453 for more details.
       remote, upstream_branch = self.FetchUpstreamTuple(self.GetBranch())
       upstream_branch = ShortBranchName(upstream_branch)
       if remote is '.':
         # A local branch is being tracked.
         local_branch = upstream_branch
         if settings.GetIsSkipDependencyUpload(local_branch):
-          print
-          print ('Skipping dependency patchset upload because git config '
-                 'branch.%s.skip-deps-uploads is set to True.' % local_branch)
-          print
+          print()
+          print('Skipping dependency patchset upload because git config '
+                'branch.%s.skip-deps-uploads is set to True.' % local_branch)
+          print()
         else:
           auth_config = auth.extract_auth_config_from_options(options)
           branch_cl = Changelist(branchref='refs/heads/'+local_branch,
                                  auth_config=auth_config)
           branch_cl_issue_url = branch_cl.GetIssueURL()
           branch_cl_issue = branch_cl.GetIssue()
           branch_cl_patchset = branch_cl.GetPatchset()
           if branch_cl_issue_url and branch_cl_issue and branch_cl_patchset:
             upload_args.extend(
                 ['--depends_on_patchset', '%s:%s' % (
@@ skipping 604 matching lines @@
 
   def _AddChangeIdToCommitMessage(self, options, args):
     """Re-commits using the current message, assumes the commit hook is in
     place.
     """
     log_desc = options.message or CreateDescriptionFromLog(args)
     git_command = ['commit', '--amend', '-m', log_desc]
     RunGit(git_command)
     new_log_desc = CreateDescriptionFromLog(args)
     if git_footers.get_footer_change_id(new_log_desc):
-      print 'git-cl: Added Change-Id to commit message.'
+      print('git-cl: Added Change-Id to commit message.')
       return new_log_desc
     else:
       DieWithError('ERROR: Gerrit commit-msg hook not installed.')
 
   def SetCQState(self, new_state):
     """Sets the Commit-Queue label assuming canonical CQ config for Gerrit."""
     # TODO(tandrii): maybe allow configurability in codereview.settings or by
     # self-discovery of label config for this CL using REST API.
     vote_map = {
         _CQState.NONE:    0,
@@ skipping 383 matching lines @@
   LoadCodereviewSettingsFromFile(urllib2.urlopen(url))
   return 0
 
 
 def CMDbaseurl(parser, args):
   """Gets or sets base-url for this branch."""
   branchref = RunGit(['symbolic-ref', 'HEAD']).strip()
   branch = ShortBranchName(branchref)
   _, args = parser.parse_args(args)
   if not args:
-    print("Current base-url:")
+    print('Current base-url:')
     return RunGit(['config', 'branch.%s.base-url' % branch],
                   error_ok=False).strip()
   else:
-    print("Setting base-url to %s" % args[0])
+    print('Setting base-url to %s' % args[0])
     return RunGit(['config', 'branch.%s.base-url' % branch, args[0]],
                   error_ok=False).strip()
 
 
 def color_for_status(status):
   """Maps a Changelist status to color, for CMDstatus and other tools."""
   return {
     'unsent': Fore.RED,
     'waiting': Fore.BLUE,
     'reply': Fore.YELLOW,
@@ skipping 94 matching lines @@
 
   # Create a dictionary of all local branches to the branches that are dependent
   # on it.
   tracked_to_dependents = collections.defaultdict(list)
   for b in branches.splitlines():
     tokens = b.split()
     if len(tokens) == 2:
       branch_name, tracked = tokens
       tracked_to_dependents[tracked].append(branch_name)
 
-  print
-  print 'The dependent local branches of %s are:' % root_branch
+  print()
+  print('The dependent local branches of %s are:' % root_branch)
   dependents = []
   def traverse_dependents_preorder(branch, padding=''):
     dependents_to_process = tracked_to_dependents.get(branch, [])
     padding += '  '
     for dependent in dependents_to_process:
-      print '%s%s' % (padding, dependent)
+      print('%s%s' % (padding, dependent))
       dependents.append(dependent)
       traverse_dependents_preorder(dependent, padding)
   traverse_dependents_preorder(root_branch)
-  print
+  print()
 
   if not dependents:
-    print 'There are no dependent local branches for %s' % root_branch
+    print('There are no dependent local branches for %s' % root_branch)
     return 0
 
-  print ('This command will checkout all dependent branches and run '
-         '"git cl upload".')
+  print('This command will checkout all dependent branches and run '
+        '"git cl upload".')
   ask_for_data('[Press enter to continue or ctrl-C to quit]')
 
   # Add a default patchset title to all upload calls in Rietveld.
   if not cl.IsGerrit():
     args.extend(['-t', 'Updated patchset dependency'])
 
   # Record all dependents that failed to upload.
   failures = {}
   # Go through all dependents, checkout the branch and upload.
   try:
     for dependent_branch in dependents:
-      print
-      print '--------------------------------------'
-      print 'Running "git cl upload" from %s:' % dependent_branch
+      print()
+      print('--------------------------------------')
+      print('Running "git cl upload" from %s:' % dependent_branch)
       RunGit(['checkout', '-q', dependent_branch])
-      print
+      print()
       try:
         if CMDupload(OptionParser(), args) != 0:
-          print 'Upload failed for %s!' % dependent_branch
+          print('Upload failed for %s!' % dependent_branch)
           failures[dependent_branch] = 1
       except:  # pylint: disable=W0702
         failures[dependent_branch] = 1
-      print
+      print()
   finally:
     # Swap back to the original root branch.
     RunGit(['checkout', '-q', root_branch])
 
-  print
-  print 'Upload complete for dependent branches!'
+  print()
+  print('Upload complete for dependent branches!')
   for dependent_branch in dependents:
     upload_status = 'failed' if failures.get(dependent_branch) else 'succeeded'
-    print '  %s : %s' % (dependent_branch, upload_status)
-  print
+    print('  %s : %s' % (dependent_branch, upload_status))
+  print()
 
   return 0
 
 
 def CMDarchive(parser, args):
   """Archives and deletes branches associated with closed changelists."""
   parser.add_option(
       '-j', '--maxjobs', action='store', type=int,
       help='The maximum number of jobs to use when retrieving review status')
   parser.add_option(
       '-f', '--force', action='store_true',
       help='Bypasses the confirmation prompt.')
 
   auth.add_auth_options(parser)
   options, args = parser.parse_args(args)
   if args:
     parser.error('Unsupported args: %s' % ' '.join(args))
   auth_config = auth.extract_auth_config_from_options(options)
 
   branches = RunGit(['for-each-ref', '--format=%(refname)', 'refs/heads'])
   if not branches:
     return 0
 
-  print 'Finding all branches associated with closed issues...'
+  print('Finding all branches associated with closed issues...')
   changes = [Changelist(branchref=b, auth_config=auth_config)
               for b in branches.splitlines()]
   alignment = max(5, max(len(c.GetBranch()) for c in changes))
   statuses = get_cl_statuses(changes,
                              fine_grained=True,
                              max_processes=options.maxjobs)
   proposal = [(cl.GetBranch(),
                'git-cl-archived-%s-%s' % (cl.GetIssue(), cl.GetBranch()))
               for cl, status in statuses
               if status == 'closed']
   proposal.sort()
 
   if not proposal:
-    print 'No branches with closed codereview issues found.'
+    print('No branches with closed codereview issues found.')
     return 0
 
   current_branch = GetCurrentBranch()
 
-  print '\nBranches with closed issues that will be archived:\n'
-  print '%*s | %s' % (alignment, 'Branch name', 'Archival tag name')
+  print('\nBranches with closed issues that will be archived:\n')
+  print('%*s | %s' % (alignment, 'Branch name', 'Archival tag name'))
   for next_item in proposal:
-    print '%*s   %s' % (alignment, next_item[0], next_item[1])
+    print('%*s   %s' % (alignment, next_item[0], next_item[1]))
 
   if any(branch == current_branch for branch, _ in proposal):
     print('You are currently on a branch \'%s\' which is associated with a '
           'closed codereview issue, so archive cannot proceed. Please '
           'checkout another branch and run this command again.' %
           current_branch)
     return 1
 
   if not options.force:
     if ask_for_data('\nProceed with deletion (Y/N)? ').lower() != 'y':
-      print 'Aborted.'
+      print('Aborted.')
       return 1
 
   for branch, tagname in proposal:
     RunGit(['tag', tagname, branch])
     RunGit(['branch', '-D', branch])
-  print '\nJob\'s done!'
+  print('\nJob\'s done!')
 
   return 0
 
 
 def CMDstatus(parser, args):
   """Show status of changelists.
 
   Colors are used to tell the state of the CL unless --fast is used:
     - Red      not sent for review or broken
     - Blue     waiting for review
@@ skipping 14 matching lines @@
 
   auth.add_auth_options(parser)
   options, args = parser.parse_args(args)
   if args:
     parser.error('Unsupported args: %s' % args)
   auth_config = auth.extract_auth_config_from_options(options)
 
   if options.field:
     cl = Changelist(auth_config=auth_config)
     if options.field.startswith('desc'):
-      print cl.GetDescription()
+      print(cl.GetDescription())
     elif options.field == 'id':
       issueid = cl.GetIssue()
       if issueid:
-        print issueid
+        print(issueid)
     elif options.field == 'patch':
       patchset = cl.GetPatchset()
       if patchset:
-        print patchset
+        print(patchset)
     elif options.field == 'url':
       url = cl.GetIssueURL()
       if url:
-        print url
+        print(url)
     return 0
 
   branches = RunGit(['for-each-ref', '--format=%(refname)', 'refs/heads'])
   if not branches:
     print('No local branch found.')
     return 0
 
   changes = [
       Changelist(branchref=b, auth_config=auth_config)
       for b in branches.splitlines()]
-  print 'Branches associated with reviews:'
+  print('Branches associated with reviews:')
   output = get_cl_statuses(changes,
                            fine_grained=not options.fast,
                            max_processes=options.maxjobs)
 
   branch_statuses = {}
   alignment = max(5, max(len(ShortBranchName(c.GetBranch())) for c in changes))
   for cl in sorted(changes, key=lambda c: c.GetBranch()):
     branch = cl.GetBranch()
     while branch not in branch_statuses:
       c, status = output.next()
       branch_statuses[c.GetBranch()] = status
     status = branch_statuses.pop(branch)
     url = cl.GetIssueURL()
     if url and (not status or status == 'error'):
       # The issue probably doesn't exist anymore.
       url += ' (broken)'
 
     color = color_for_status(status)
     reset = Fore.RESET
     if not setup_color.IS_TTY:
       color = ''
       reset = ''
     status_str = '(%s)' % status if status else ''
-    print '  %*s : %s%s %s%s' % (
+    print('  %*s : %s%s %s%s' % (
           alignment, ShortBranchName(branch), color, url,
-          status_str, reset)
+          status_str, reset))
 
   cl = Changelist(auth_config=auth_config)
-  print
-  print 'Current branch:',
-  print cl.GetBranch()
+  print()
+  print('Current branch:',)
+  print(cl.GetBranch())
   if not cl.GetIssue():
-    print 'No issue assigned.'
+    print('No issue assigned.')
     return 0
-  print 'Issue number: %s (%s)' % (cl.GetIssue(), cl.GetIssueURL())
+  print('Issue number: %s (%s)' % (cl.GetIssue(), cl.GetIssueURL()))
   if not options.fast:
-    print 'Issue description:'
-    print cl.GetDescription(pretty=True)
+    print('Issue description:')
+    print(cl.GetDescription(pretty=True))
   return 0
 
 
 def colorize_CMDstatus_doc():
   """To be called once in main() to add colors to git cl status help."""
   colors = [i for i in dir(Fore) if i[0].isupper()]
 
   def colorize_line(line):
     for color in colors:
       if color in line.upper():
@@ skipping 27 matching lines @@
     # Reverse issue lookup.
     issue_branch_map = {}
     for branch in branches:
       cl = Changelist(branchref=branch)
       issue_branch_map.setdefault(cl.GetIssue(), []).append(branch)
     if not args:
       args = sorted(issue_branch_map.iterkeys())
     for issue in args:
       if not issue:
         continue
-      print 'Branch for issue number %s: %s' % (
-          issue, ', '.join(issue_branch_map.get(int(issue)) or ('None',)))
+      print('Branch for issue number %s: %s' % (
+          issue, ', '.join(issue_branch_map.get(int(issue)) or ('None',))))
   else:
     cl = Changelist(codereview=options.forced_codereview)
     if len(args) > 0:
       try:
         issue = int(args[0])
       except ValueError:
         DieWithError('Pass a number to set the issue or none to list it.\n'
                      'Maybe you want to run git cl status?')
       cl.SetIssue(issue)
-    print 'Issue number: %s (%s)' % (cl.GetIssue(), cl.GetIssueURL())
+    print('Issue number: %s (%s)' % (cl.GetIssue(), cl.GetIssueURL()))
   return 0
 
 
 def CMDcomments(parser, args):
   """Shows or posts review comments for any changelist."""
   parser.add_option('-a', '--add-comment', dest='comment',
                     help='comment to add to an issue')
   parser.add_option('-i', dest='issue',
                     help="review issue id (defaults to current issue)")
   parser.add_option('-j', '--json-file',
@@ skipping 28 matching lines @@
     if message['disapproval']:
       color = Fore.RED
       summary[-1]['not lgtm'] = True
     elif message['approval']:
       color = Fore.GREEN
       summary[-1]['lgtm'] = True
     elif message['sender'] == data['owner_email']:
       color = Fore.MAGENTA
     else:
       color = Fore.BLUE
-    print '\n%s%s  %s%s' % (
+    print('\n%s%s  %s%s' % (
         color, message['date'].split('.', 1)[0], message['sender'],
-        Fore.RESET)
+        Fore.RESET))
     if message['text'].strip():
-      print '\n'.join('  ' + l for l in message['text'].splitlines())
+      print('\n'.join('  ' + l for l in message['text'].splitlines()))
   if options.json_file:
     with open(options.json_file, 'wb') as f:
       json.dump(summary, f)
   return 0
 
 
 @subcommand.usage('[codereview url or issue id]')
 def CMDdescription(parser, args):
   """Brings up the editor for the current CL's description."""
   parser.add_option('-d', '--display', action='store_true',
@@ skipping 18 matching lines @@
 
   cl = Changelist(
       auth_config=auth_config, issue=target_issue,
       codereview=options.forced_codereview)
 
   if not cl.GetIssue():
     DieWithError('This branch has no associated changelist.')
   description = ChangeDescription(cl.GetDescription())
 
   if options.display:
-    print description.description
+    print(description.description)
     return 0
 
   if options.new_description:
     text = options.new_description
     if text == '-':
       text = '\n'.join(l.rstrip() for l in sys.stdin)
 
     description.set_description(text)
   else:
     description.prompt()
@@ skipping 24 matching lines @@
   auth.add_auth_options(parser)
   options, args = parser.parse_args(args)
   auth_config = auth.extract_auth_config_from_options(options)
 
   # Access to a protected member _XX of a client class
   # pylint: disable=W0212
   try:
     import cpplint
     import cpplint_chromium
   except ImportError:
-    print "Your depot_tools is missing cpplint.py and/or cpplint_chromium.py."
+    print('Your depot_tools is missing cpplint.py and/or cpplint_chromium.py.')
     return 1
 
   # Change the current working directory before calling lint so that it
   # shows the correct base.
   previous_cwd = os.getcwd()
   os.chdir(settings.GetRoot())
   try:
     cl = Changelist(auth_config=auth_config)
     change = cl.GetChange(cl.GetCommonAncestorWithUpstream(), None)
     files = [f.LocalPath() for f in change.AffectedFiles()]
     if not files:
-      print "Cannot lint an empty CL"
+      print('Cannot lint an empty CL')
       return 1
 
     # Process cpplints arguments if any.
     command = args + files
     if options.filter:
       command = ['--filter=' + ','.join(options.filter)] + command
     filenames = cpplint.ParseArguments(command)
 
     white_regex = re.compile(settings.GetLintRegex())
     black_regex = re.compile(settings.GetLintIgnoreRegex())
     extra_check_functions = [cpplint_chromium.CheckPointerDeclarationWhitespace]
     for filename in filenames:
       if white_regex.match(filename):
         if black_regex.match(filename):
-          print "Ignoring file %s" % filename
+          print('Ignoring file %s' % filename)
         else:
           cpplint.ProcessFile(filename, cpplint._cpplint_state.verbose_level,
                               extra_check_functions)
       else:
-        print "Skipping file %s" % filename
+        print('Skipping file %s' % filename)
   finally:
     os.chdir(previous_cwd)
-  print "Total errors found: %d\n" % cpplint._cpplint_state.error_count
+  print('Total errors found: %d\n' % cpplint._cpplint_state.error_count)
   if cpplint._cpplint_state.error_count != 0:
     return 1
   return 0
 
 
 def CMDpresubmit(parser, args):
   """Runs presubmit tests on the current changelist."""
   parser.add_option('-u', '--upload', action='store_true',
                     help='Run upload hook instead of the push/dcommit hook')
   parser.add_option('-f', '--force', action='store_true',
                     help='Run checks even if tree is dirty')
   auth.add_auth_options(parser)
   options, args = parser.parse_args(args)
   auth_config = auth.extract_auth_config_from_options(options)
 
   if not options.force and git_common.is_dirty_git_tree('presubmit'):
-    print 'use --force to check even if tree is dirty.'
+    print('use --force to check even if tree is dirty.')
     return 1
 
   cl = Changelist(auth_config=auth_config)
   if args:
     base_branch = args[0]
   else:
     # Default to diffing against the common ancestor of the upstream branch.
     base_branch = cl.GetCommonAncestorWithUpstream()
 
   cl.RunHook(
@@ skipping 231 matching lines @@
           'Before uploading a commit to Gerrit, ensure it\'s author field is '
           'the contributor\'s "name <email>". If you can\'t upload such a '
           'commit for review, contact your repository admin and request'
           '"Forge-Author" permission.')
     return cl._codereview_impl.CMDLand(options.force, options.bypass_hooks,
                                        options.verbose)
 
   current = cl.GetBranch()
   remote, upstream_branch = cl.FetchUpstreamTuple(cl.GetBranch())
   if not settings.GetIsGitSvn() and remote == '.':
-    print
-    print 'Attempting to push branch %r into another local branch!' % current
-    print
-    print 'Either reparent this branch on top of origin/master:'
-    print '  git reparent-branch --root'
-    print
-    print 'OR run `git rebase-update` if you think the parent branch is already'
-    print 'committed.'
-    print
-    print '  Current parent: %r' % upstream_branch
+    print()
+    print('Attempting to push branch %r into another local branch!' % current)
+    print()
+    print('Either reparent this branch on top of origin/master:')
+    print('  git reparent-branch --root')
+    print()
+    print('OR run `git rebase-update` if you think the parent branch is ')
+    print('already committed.')
+    print()
+    print('  Current parent: %r' % upstream_branch)
     return 1
 
   if not args or cmd == 'land':
     # Default to merging against our best guess of the upstream branch.
     args = [cl.GetUpstreamBranch()]
 
   if options.contributor:
     if not re.match('^.*\s<\S+@\S+>$', options.contributor):
-      print "Please provide contibutor as 'First Last <email@example.com>'"
+      print("Please provide contibutor as 'First Last <email@example.com>'")
       return 1
 
   base_branch = args[0]
   base_has_submodules = IsSubmoduleMergeCommit(base_branch)
 
   if git_common.is_dirty_git_tree(cmd):
     return 1
 
   # This rev-list syntax means "show all commits not in my branch that
   # are in base_branch".
   upstream_commits = RunGit(['rev-list', '^' + cl.GetBranchRef(),
                              base_branch]).splitlines()
   if upstream_commits:
-    print ('Base branch "%s" has %d commits '
-           'not in this branch.' % (base_branch, len(upstream_commits)))
-    print 'Run "git merge %s" before attempting to %s.' % (base_branch, cmd)
+    print('Base branch "%s" has %d commits '
+          'not in this branch.' % (base_branch, len(upstream_commits)))
+    print('Run "git merge %s" before attempting to %s.' % (base_branch, cmd))
     return 1
 
   # This is the revision `svn dcommit` will commit on top of.
   svn_head = None
   if cmd == 'dcommit' or base_has_submodules:
     svn_head = RunGit(['log', '--grep=^git-svn-id:', '-1',
                        '--pretty=format:%H'])
 
   if cmd == 'dcommit':
     # If the base_head is a submodule merge commit, the first parent of the
     # base_head should be a git-svn commit, which is what we're interested in.
     base_svn_head = base_branch
     if base_has_submodules:
       base_svn_head += '^1'
 
     extra_commits = RunGit(['rev-list', '^' + svn_head, base_svn_head])
     if extra_commits:
-      print ('This branch has %d additional commits not upstreamed yet.'
-             % len(extra_commits.splitlines()))
-      print ('Upstream "%s" or rebase this branch on top of the upstream trunk '
-             'before attempting to %s.' % (base_branch, cmd))
+      print('This branch has %d additional commits not upstreamed yet.'
+            % len(extra_commits.splitlines()))
+      print('Upstream "%s" or rebase this branch on top of the upstream trunk '
+            'before attempting to %s.' % (base_branch, cmd))
       return 1
 
   merge_base = RunGit(['merge-base', base_branch, 'HEAD']).strip()
   if not options.bypass_hooks:
     author = None
     if options.contributor:
       author = re.search(r'\<(.*)\>', options.contributor).group(1)
     hook_results = cl.RunHook(
         committing=True,
         may_prompt=not options.force,
@@ skipping 14 matching lines @@
       return 1
 
   change_desc = ChangeDescription(options.message)
   if not change_desc.description and cl.GetIssue():
     change_desc = ChangeDescription(cl.GetDescription())
 
   if not change_desc.description:
     if not cl.GetIssue() and options.bypass_hooks:
       change_desc = ChangeDescription(CreateDescriptionFromLog([merge_base]))
     else:
-      print 'No description set.'
-      print 'Visit %s/edit to set it.' % (cl.GetIssueURL())
+      print('No description set.')
+      print('Visit %s/edit to set it.' % (cl.GetIssueURL()))
       return 1
 
   # Keep a separate copy for the commit message, because the commit message
   # contains the link to the Rietveld issue, while the Rietveld message contains
   # the commit viewvc url.
   # Keep a separate copy for the commit message.
   if cl.GetIssue():
     change_desc.update_reviewers(cl.GetApprovingReviewers())
 
   commit_desc = ChangeDescription(change_desc.description)
@@ skipping 97 matching lines @@
           '.*?\nCommitted r(\\d+)', output, re.DOTALL).group(1)
     logging.debug(output)
   finally:
     # And then swap back to the original branch and clean up.
     RunGit(['checkout', '-q', cl.GetBranch()])
     RunGit(['branch', '-D', MERGE_BRANCH])
     if base_has_submodules:
       RunGit(['branch', '-D', CHERRY_PICK_BRANCH])
 
   if not revision:
-    print 'Failed to push. If this persists, please file a bug.'
+    print('Failed to push. If this persists, please file a bug.')
     return 1
 
   killed = False
   if pushed_to_pending:
     try:
       revision = WaitForRealCommit(remote, revision, base_branch, branch)
       # We set pushed_to_pending to False, since it made it all the way to the
       # real ref.
       pushed_to_pending = False
     except KeyboardInterrupt:
       killed = True
 
   if cl.GetIssue():
     to_pending = ' to pending queue' if pushed_to_pending else ''
     viewvc_url = settings.GetViewVCUrl()
     if not to_pending:
       if viewvc_url and revision:
         change_desc.append_footer(
             'Committed: %s%s' % (viewvc_url, revision))
       elif revision:
         change_desc.append_footer('Committed: %s' % (revision,))
-    print ('Closing issue '
-           '(you may be prompted for your codereview password)...')
+    print('Closing issue '
+          '(you may be prompted for your codereview password)...')
     cl.UpdateDescription(change_desc.description)
     cl.CloseIssue()
     props = cl.GetIssueProperties()
     patch_num = len(props['patchsets'])
     comment = "Committed patchset #%d (id:%d)%s manually as %s" % (
         patch_num, props['patchsets'][-1], to_pending, revision)
     if options.bypass_hooks:
       comment += ' (tree was closed).' if GetTreeStatus() == 'closed' else '.'
     else:
       comment += ' (presubmit successful).'
     cl.RpcServer().add_comment(cl.GetIssue(), comment)
     cl.SetIssue(None)
 
   if pushed_to_pending:
     _, branch = cl.FetchUpstreamTuple(cl.GetBranch())
-    print 'The commit is in the pending queue (%s).' % pending_ref
-    print (
-        'It will show up on %s in ~1 min, once it gets a Cr-Commit-Position '
-        'footer.' % branch)
+    print('The commit is in the pending queue (%s).' % pending_ref)
+    print('It will show up on %s in ~1 min, once it gets a Cr-Commit-Position '
+          'footer.' % branch)
 
   hook = POSTUPSTREAM_HOOK_PATTERN % cmd
   if os.path.isfile(hook):
     RunCommand([hook, merge_base], error_ok=True)
 
   return 1 if killed else 0
 
 
 def WaitForRealCommit(remote, pushed_commit, local_base_ref, real_ref):
-  print
-  print 'Waiting for commit to be landed on %s...' % real_ref
-  print '(If you are impatient, you may Ctrl-C once without harm)'
+  print()
+  print('Waiting for commit to be landed on %s...' % real_ref)
+  print('(If you are impatient, you may Ctrl-C once without harm)')
   target_tree = RunGit(['rev-parse', '%s:' % pushed_commit]).strip()
   current_rev = RunGit(['rev-parse', local_base_ref]).strip()
   mirror = settings.GetGitMirror(remote)
 
   loop = 0
   while True:
     sys.stdout.write('fetching (%d)...        \r' % loop)
     sys.stdout.flush()
     loop += 1
 
     if mirror:
       mirror.populate()
     RunGit(['retry', 'fetch', remote, real_ref], stderr=subprocess2.VOID)
     to_rev = RunGit(['rev-parse', 'FETCH_HEAD']).strip()
     commits = RunGit(['rev-list', '%s..%s' % (current_rev, to_rev)])
     for commit in commits.splitlines():
       if RunGit(['rev-parse', '%s:' % commit]).strip() == target_tree:
-        print 'Found commit on %s' % real_ref
+        print('Found commit on %s' % real_ref)
         return commit
 
     current_rev = to_rev
 
 
 def PushToGitPending(remote, pending_ref, upstream_ref):
   """Fetches pending_ref, cherry-picks current HEAD on top of it, pushes.
 
   Returns:
     (retcode of last operation, output log of last operation).
   """
   assert pending_ref.startswith('refs/'), pending_ref
   local_pending_ref = 'refs/git-cl/' + pending_ref[len('refs/'):]
   cherry = RunGit(['rev-parse', 'HEAD']).strip()
   code = 0
   out = ''
   max_attempts = 3
   attempts_left = max_attempts
   while attempts_left:
     if attempts_left != max_attempts:
-      print 'Retrying, %d attempts left...' % (attempts_left - 1,)
+      print('Retrying, %d attempts left...' % (attempts_left - 1,))
     attempts_left -= 1
 
     # Fetch. Retry fetch errors.
-    print 'Fetching pending ref %s...' % pending_ref
+    print('Fetching pending ref %s...' % pending_ref)
     code, out = RunGitWithCode(
         ['retry', 'fetch', remote, '+%s:%s' % (pending_ref, local_pending_ref)])
     if code:
-      print 'Fetch failed with exit code %d.' % code
+      print('Fetch failed with exit code %d.' % code)
       if out.strip():
-        print out.strip()
+        print(out.strip())
       continue
 
     # Try to cherry pick. Abort on merge conflicts.
-    print 'Cherry-picking commit on top of pending ref...'
+    print('Cherry-picking commit on top of pending ref...')
     RunGitWithCode(['checkout', local_pending_ref], suppress_stderr=True)
     code, out = RunGitWithCode(['cherry-pick', cherry])
     if code:
-      print (
-          'Your patch doesn\'t apply cleanly to ref \'%s\', '
-          'the following files have merge conflicts:' % pending_ref)
-      print RunGit(['diff', '--name-status', '--diff-filter=U']).strip()
-      print 'Please rebase your patch and try again.'
+      print('Your patch doesn\'t apply cleanly to ref \'%s\', '
+            'the following files have merge conflicts:' % pending_ref)
+      print(RunGit(['diff', '--name-status', '--diff-filter=U']).strip())
+      print('Please rebase your patch and try again.')
       RunGitWithCode(['cherry-pick', '--abort'])
       return code, out
 
     # Applied cleanly, try to push now. Retry on error (flake or non-ff push).
-    print 'Pushing commit to %s... It can take a while.' % pending_ref
+    print('Pushing commit to %s... It can take a while.' % pending_ref)
     code, out = RunGitWithCode(
         ['retry', 'push', '--porcelain', remote, 'HEAD:%s' % pending_ref])
     if code == 0:
       # Success.
-      print 'Commit pushed to pending ref successfully!'
+      print('Commit pushed to pending ref successfully!')
       return code, out
 
-    print 'Push failed with exit code %d.' % code
+    print('Push failed with exit code %d.' % code)
     if out.strip():
-      print out.strip()
+      print(out.strip())
     if IsFatalPushFailure(out):
-      print (
-          'Fatal push error. Make sure your .netrc credentials and git '
-          'user.email are correct and you have push access to the repo.')
+      print('Fatal push error. Make sure your .netrc credentials and git '
+            'user.email are correct and you have push access to the repo.')
       return code, out
 
-  print 'All attempts to push to pending ref failed.'
+  print('All attempts to push to pending ref failed.')
   return code, out
 
 
 def IsFatalPushFailure(push_stdout):
   """True if retrying push won't help."""
   return '(prohibited by Gerrit)' in push_stdout
 
 
 @subcommand.usage('[upstream branch to apply against]')
 def CMDdcommit(parser, args):
@@ skipping 181 matching lines @@
       elif result_master != cur_master:
         return None, 'The builders do not belong to the same master.'
   return result_master, None
 
 
 def CMDtree(parser, args):
   """Shows the status of the tree."""
   _, args = parser.parse_args(args)
   status = GetTreeStatus()
   if 'unset' == status:
-    print 'You must configure your tree status URL by running "git cl config".'
+    print('You must configure your tree status URL by running "git cl config".')
     return 2
 
-  print "The tree is %s" % status
-  print
-  print GetTreeStatusReason()
+  print('The tree is %s' % status)
+  print()
+  print(GetTreeStatusReason())
   if status != 'open':
     return 1
   return 0
 
 
 def CMDtry(parser, args):
   """Triggers try jobs through BuildBucket."""
   group = optparse.OptionGroup(parser, "Try job options")
   group.add_option(
       "-b", "--bot", action="append",
@@ skipping 146 matching lines @@
 
     # Return a master map with one master to be backwards compatible. The
     # master name defaults to an empty string, which will cause the master
     # not to be set on rietveld (deprecated).
     return {options.master: builders_and_tests}
 
   masters = GetMasterMap()
 
   for builders in masters.itervalues():
     if any('triggered' in b for b in builders):
-      print >> sys.stderr, (
-          'ERROR You are trying to send a job to a triggered bot. This type of'
-          ' bot requires an\ninitial job from a parent (usually a builder).  '
-          'Instead send your job to the parent.\n'
-          'Bot list: %s' % builders)
+      print('ERROR You are trying to send a job to a triggered bot. This type '
+            'of bot requires an\ninitial job from a parent (usually a builder).'
+            '  Instead send your job to the parent.\n'
+            'Bot list: %s' % builders, file=sys.stderr)
       return 1
 
   patchset = cl.GetMostRecentPatchset()
   if patchset and patchset != cl.GetPatchset():
     print(
         '\nWARNING Mismatch between local config and server. Did a previous '
         'upload fail?\ngit-cl try always uses latest patchset from rietveld. '
         'Continuing using\npatchset %s.\n' % patchset)
   if options.luci:
     trigger_luci_job(cl, masters, options)
   elif not options.use_rietveld:
     try:
       trigger_try_jobs(auth_config, cl, options, masters, 'git_cl_try')
     except BuildbucketResponseException as ex:
-      print 'ERROR: %s' % ex
+      print('ERROR: %s' % ex)
       return 1
     except Exception as e:
       stacktrace = (''.join(traceback.format_stack()) + traceback.format_exc())
-      print 'ERROR: Exception when trying to trigger tryjobs: %s\n%s' % (
-          e, stacktrace)
+      print('ERROR: Exception when trying to trigger tryjobs: %s\n%s' %
+            (e, stacktrace))
       return 1
   else:
     try:
       cl.RpcServer().trigger_distributed_try_jobs(
           cl.GetIssue(), patchset, options.name, options.clobber,
           options.revision, masters)
     except urllib2.HTTPError as e:
       if e.code == 404:
         print('404 from rietveld; '
               'did you mean to use "git try" instead of "git cl try"?')
         return 1
     print('Tried jobs on:')
 
     for (master, builders) in sorted(masters.iteritems()):
       if master:
-        print 'Master: %s' % master
+        print('Master: %s' % master)
       length = max(len(builder) for builder in builders)
       for builder in sorted(builders):
-        print '  %*s: %s' % (length, builder, ','.join(builders[builder]))
+        print('  %*s: %s' % (length, builder, ','.join(builders[builder])))
   return 0
 
 
 def CMDtry_results(parser, args):
   group = optparse.OptionGroup(parser, "Try job results options")
   group.add_option(
       "-p", "--patchset", type=int, help="patchset number if not current.")
   group.add_option(
       "--print-master", action='store_true', help="print master name as well.")
   group.add_option(
@@ skipping 16 matching lines @@
   if not options.patchset:
     options.patchset = cl.GetMostRecentPatchset()
     if options.patchset and options.patchset != cl.GetPatchset():
       print(
           '\nWARNING Mismatch between local config and server. Did a previous '
           'upload fail?\ngit-cl try always uses latest patchset from rietveld. '
           'Continuing using\npatchset %s.\n' % options.patchset)
   try:
     jobs = fetch_try_jobs(auth_config, cl, options)
   except BuildbucketResponseException as ex:
-    print 'Buildbucket error: %s' % ex
+    print('Buildbucket error: %s' % ex)
     return 1
   except Exception as e:
     stacktrace = (''.join(traceback.format_stack()) + traceback.format_exc())
-    print 'ERROR: Exception when trying to fetch tryjobs: %s\n%s' % (
-        e, stacktrace)
+    print('ERROR: Exception when trying to fetch tryjobs: %s\n%s' %
+          (e, stacktrace))
     return 1
   print_tryjobs(options, jobs)
   return 0
 
 
 @subcommand.usage('[new upstream branch]')
 def CMDupstream(parser, args):
   """Prints or sets the name of the upstream branch, if any."""
   _, args = parser.parse_args(args)
   if len(args) > 1:
     parser.error('Unrecognized args: %s' % ' '.join(args))
 
   cl = Changelist()
   if args:
     # One arg means set upstream branch.
     branch = cl.GetBranch()
     RunGit(['branch', '--set-upstream', branch, args[0]])
     cl = Changelist()
-    print "Upstream branch set to " + cl.GetUpstreamBranch()
+    print('Upstream branch set to %s' % (cl.GetUpstreamBranch(),))
 
     # Clear configured merge-base, if there is one.
     git_common.remove_merge_base(branch)
   else:
-    print cl.GetUpstreamBranch()
+    print(cl.GetUpstreamBranch())
   return 0
 
 
 def CMDweb(parser, args):
   """Opens the current CL in the web browser."""
   _, args = parser.parse_args(args)
   if args:
     parser.error('Unrecognized args: %s' % ' '.join(args))
 
   issue_url = Changelist().GetIssueURL()
   if not issue_url:
-    print >> sys.stderr, 'ERROR No issue to open'
+    print('ERROR No issue to open', file=sys.stderr)
     return 1
 
   webbrowser.open(issue_url)
   return 0
 
 
 def CMDset_commit(parser, args):
   """Sets the commit bit to trigger the Commit Queue."""
   parser.add_option('-d', '--dry-run', action='store_true',
                     help='trigger in dry run mode')
@@ skipping 245 matching lines @@
     try:
       command = [dart_format.FindDartFmtToolInChromiumTree()]
       if not opts.dry_run and not opts.diff:
         command.append('-w')
       command.extend(dart_diff_files)
 
       stdout = RunCommand(command, cwd=top_dir)
       if opts.dry_run and stdout:
         return_value = 2
     except dart_format.NotFoundError as e:
-      print ('Warning: Unable to check Dart code formatting. Dart SDK not ' +
-             'found in this checkout. Files in other languages are still ' +
-             'formatted.')
+      print('Warning: Unable to check Dart code formatting. Dart SDK not '
+            'found in this checkout. Files in other languages are still '
+            'formatted.')
 
   # Format GN build files. Always run on full build files for canonical form.
   if gn_diff_files:
     cmd = ['gn', 'format']
     if not opts.dry_run and not opts.diff:
       cmd.append('--in-place')
     for gn_diff_file in gn_diff_files:
       stdout = RunCommand(cmd + [gn_diff_file],
                           shell=sys.platform == 'win32',
                           cwd=top_dir)
@@ skipping 23 matching lines @@
                      r'branch\..*\.%s' % issueprefix],
                      error_ok=True)
     for key, issue in [x.split() for x in output.splitlines()]:
       if issue == target_issue:
         yield re.sub(r'branch\.(.*)\.%s' % issueprefix, r'\1', key)
 
   branches = []
   for cls in _CODEREVIEW_IMPLEMENTATIONS.values():
     branches.extend(find_issues(cls.IssueSettingSuffix()))
   if len(branches) == 0:
-    print 'No branch found for issue %s.' % target_issue
+    print('No branch found for issue %s.' % target_issue)
     return 1
   if len(branches) == 1:
     RunGit(['checkout', branches[0]])
   else:
-    print 'Multiple branches match issue %s:' % target_issue
+    print('Multiple branches match issue %s:' % target_issue)
     for i in range(len(branches)):
-      print '%d: %s' % (i, branches[i])
+      print('%d: %s' % (i, branches[i]))
     which = raw_input('Choose by index: ')
     try:
       RunGit(['checkout', branches[int(which)]])
     except (IndexError, ValueError):
-      print 'Invalid selection, not checking out any branch.'
+      print('Invalid selection, not checking out any branch.')
       return 1
 
   return 0
 
 
 def CMDlol(parser, args):
   # This command is intentionally undocumented.
-  print zlib.decompress(base64.b64decode(
+  print(zlib.decompress(base64.b64decode(
       'eNptkLEOwyAMRHe+wupCIqW57v0Vq84WqWtXyrcXnCBsmgMJ+/SSAxMZgRB6NzE'
       'E2ObgCKJooYdu4uAQVffUEoE1sRQLxAcqzd7uK2gmStrll1ucV3uZyaY5sXyDd9'
       'JAnN+lAXsOMJ90GANAi43mq5/VeeacylKVgi8o6F1SC63FxnagHfJUTfUYdCR/W'
-      'Ofe+0dHL7PicpytKP750Fh1q2qnLVof4w8OZWNY'))
+      'Ofe+0dHL7PicpytKP750Fh1q2qnLVof4w8OZWNY')))
   return 0
 
 
 class OptionParser(optparse.OptionParser):
   """Creates the option parse and add --verbose support."""
   def __init__(self, *args, **kwargs):
     optparse.OptionParser.__init__(
         self, *args, prog='git cl', version=__version__, **kwargs)
     self.add_option(
         '-v', '--verbose', action='count', default=0,
         help='Use 2 times for more debugging info')
 
   def parse_args(self, args=None, values=None):
     options, args = optparse.OptionParser.parse_args(self, args, values)
     levels = [logging.WARNING, logging.INFO, logging.DEBUG]
     logging.basicConfig(level=levels[min(options.verbose, len(levels) - 1)])
     return options, args
 
 
 def main(argv):
   if sys.hexversion < 0x02060000:
-    print >> sys.stderr, (
-        '\nYour python version %s is unsupported, please upgrade.\n' %
-        sys.version.split(' ', 1)[0])
+    print('\nYour python version %s is unsupported, please upgrade.\n' %
+          (sys.version.split(' ', 1)[0],), file=sys.stderr)
     return 2
 
   # Reload settings.
   global settings
   settings = Settings()
 
   colorize_CMDstatus_doc()
   dispatcher = subcommand.CommandDispatcher(__name__)
   try:
     return dispatcher.execute(OptionParser(), argv)
@@ skipping 11 matching lines @@
 if __name__ == '__main__':
   # These affect sys.stdout so do it outside of main() to simplify mocks in
   # unit testing.
   fix_encoding.fix_encoding()
   setup_color.init()
   try:
     sys.exit(main(sys.argv[1:]))
   except KeyboardInterrupt:
     sys.stderr.write('interrupted\n')
     sys.exit(1)