git cl upload: convert to print_function

third_party/upload.py

 #!/usr/bin/env python
 # coding: utf-8
 #
 # Copyright 2007 Google Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #     http://www.apache.org/licenses/LICENSE-2.0
@@ skipping 16 matching lines @@
   Subversion
   Perforce
   CVS
 
 It is important for Git/Mercurial users to specify a tree/node/branch to diff
 against by using the '--rev' option.
 """
 # This code is derived from appcfg.py in the App Engine SDK (open source),
 # and from ASPN recipe #146306.
 
+from __future__ import print_function
+
 import ConfigParser
 import cookielib
 import errno
 import fnmatch
 import getpass
 import logging
 import marshal
 import mimetypes
 import optparse
 import os
@@ skipping 114 matching lines @@
 
 def StatusUpdate(msg):
   """Print a status message to stdout.
 
   If 'verbosity' is greater than 0, print the message.
 
   Args:
     msg: The string to print.
   """
   if verbosity > 0:
-    print msg
+    print(msg)
 
 
 def ErrorExit(msg):
   """Print an error message to stderr and exit."""
-  print >> sys.stderr, msg
+  print(msg, file=sys.stderr)
   sys.exit(1)
 
 
 class ClientLoginError(urllib2.HTTPError):
   """Raised to indicate there was an error authenticating with ClientLogin."""
 
   def __init__(self, url, code, msg, headers, args):
     urllib2.HTTPError.__init__(self, url, code, msg, headers, None)
     self.args = args
     self._reason = args["Error"]
@@ skipping 164 matching lines @@
               "adel": "AccountDeleted",
               "adis": "AccountDisabled",
               "sdis": "ServiceDisabled",
               "ire": "ServiceUnavailable",
           }
           auth_token = self._GetAuthToken(credentials[0], credentials[1],
                                           internal=True)
         except ClientLoginError, exc:
           e = exc
       if e:
-        print >> sys.stderr, ''
+        print('', file=sys.stderr)
         error_message = e.reason
         if error_map:
           error_message = error_map.get(error_message, error_message)
         if error_message == "BadAuthentication":
           if e.info == "InvalidSecondFactor":
             print >> sys.stderr, (
                 "Use an application-specific password instead "
                 "of your regular account password.\n"
                 "See http://www.google.com/"
                 "support/accounts/bin/answer.py?answer=185833")
           else:
-            print >> sys.stderr, "Invalid username or password."
+            print("Invalid username or password.", file=sys.stderr)
         elif error_message == "CaptchaRequired":
           print >> sys.stderr, (
               "Please go to\n"
               "https://www.google.com/accounts/DisplayUnlockCaptcha\n"
               "and verify you are a human.  Then try again.\n"
               "If you are using a Google Apps account the URL is:\n"
               "https://www.google.com/a/yourdomain.com/UnlockCaptcha")
         elif error_message == "NotVerified":
-          print >> sys.stderr, "Account not verified."
+          print("Account not verified.", file=sys.stderr)
         elif error_message == "TermsNotAgreed":
-          print >> sys.stderr, "User has not agreed to TOS."
+          print("User has not agreed to TOS.", file=sys.stderr)
         elif error_message == "AccountDeleted":
-          print >> sys.stderr, "The user account has been deleted."
+          print("The user account has been deleted.", file=sys.stderr)
         elif error_message == "AccountDisabled":
-          print >> sys.stderr, "The user account has been disabled."
+          print("The user account has been disabled.", file=sys.stderr)
           break
         elif error_message == "ServiceDisabled":
-          print >> sys.stderr, ("The user's access to the service has been "
-                               "disabled.")
+          print("The user's access to the service has been disabled.",
+                file=sys.stderr)
         elif error_message == "ServiceUnavailable":
-          print >> sys.stderr, "The service is not available; try again later."
+          print("The service is not available; try again later.",
+                file=sys.stderr)
         else:
           # Unknown error.
           raise e
-        print >> sys.stderr, ''
+        print('', file=sys.stderr)
         continue
       self._GetAuthCookie(auth_token)
       return
 
   def Send(self, request_path, payload=None,
            content_type="application/octet-stream",
            timeout=None,
            extra_headers=None,
            **kwargs):
     """Sends an RPC and returns the response.
@@ skipping 304 matching lines @@
     email = self.email
     if email is None:
       email = GetEmail("Email (login for uploading to %s)" % self.server)
     password = None
     if keyring and not email in self.accounts_seen:
       try:
         password = keyring.get_password(self.host, email)
       except:
         # Sadly, we have to trap all errors here as
         # gnomekeyring.IOError inherits from object. :/
-        print "Failed to get password from keyring"
+        print("Failed to get password from keyring")
         keyring = None
     if password is not None:
-      print "Using password from system keyring."
+      print("Using password from system keyring.")
       self.accounts_seen.add(email)
     else:
       password = getpass.getpass("Password for %s: " % email)
       if keyring:
         answer = raw_input("Store password in system keyring?(y/N) ").strip()
         if answer == "y":
           keyring.set_password(self.host, email, password)
           self.accounts_seen.add(email)
     return (email, password)
 
@@ skipping 176 matching lines @@
 
   def GetUnknownFiles(self):
     """Return a list of files unknown to the VCS."""
     raise NotImplementedError(
         "abstract method -- subclass %s must override" % self.__class__)
 
   def CheckForUnknownFiles(self):
     """Show an "are you sure?" prompt if there are unknown files."""
     unknown_files = self.GetUnknownFiles()
     if unknown_files:
-      print "The following files are not added to version control:"
+      print("The following files are not added to version control:")
       for line in unknown_files:
-        print line
+        print(line)
       prompt = "Are you sure to continue?(y/N) "
       answer = raw_input(prompt).strip()
       if answer != "y":
         ErrorExit("User aborted")
 
   def GetBaseFile(self, filename):
     """Get the content of the upstream version of a file.
 
     Returns:
       A tuple (base_content, new_content, is_binary, status)
@@ skipping 86 matching lines @@
       if base_content != None:
         t = thread_pool.apply_async(UploadFile, args=(filename,
             file_id, base_content, is_binary, status, True))
         threads.append(t)
       if new_content != None:
         t = thread_pool.apply_async(UploadFile, args=(filename,
             file_id, new_content, is_binary, status, False))
         threads.append(t)
 
     for t in threads:
-      print t.get(timeout=60)
+      print(t.get(timeout=60))
 
   def IsImage(self, filename):
     """Returns true if the filename has an image extension."""
     mimetype =  mimetypes.guess_type(filename)[0]
     if not mimetype:
       return False
     return (mimetype.startswith("image/") and
             not mimetype.startswith("image/svg"))
 
   def IsBinaryData(self, data):
@@ skipping 653 matching lines @@
 
     def ConfirmLogin():
       # Make sure we have a valid perforce session
       while True:
         data, retcode = self.RunPerforceCommandWithReturnCode(
             ["login", "-s"], marshal_output=True)
         if not data:
           ErrorExit("Error checking perforce login")
         if not retcode and (not "code" in data or data["code"] != "error"):
           break
-        print "Enter perforce password: "
+        print("Enter perforce password: ")
         self.RunPerforceCommandWithReturnCode(["login"])
 
     super(PerforceVCS, self).__init__(options)
 
     self.p4_changelist = options.p4_changelist
     if not self.p4_changelist:
       ErrorExit("A changelist id is required")
     if (options.revision):
       ErrorExit("--rev is not supported for perforce")
 
@@ skipping 359 matching lines @@
       sys.exit(1)
     return ("Uploaded patch for " + filename, [lines[1], filename])
 
   threads = []
   thread_pool = ThreadPool(options.num_upload_threads)
 
   patches = SplitPatch(data)
   rv = []
   for patch in patches:
     if len(patch[1]) > MAX_UPLOAD_SIZE:
-      print ("Not uploading the patch for " + patch[0] +
-             " because the file is too large.")
+      print("Not uploading the patch for %s because the file is too large." %
+            (patch[0],))
       continue
 
     filename = patch[0]
     data = patch[1]
 
     t = thread_pool.apply_async(UploadFile, args=(filename, data))
     threads.append(t)
 
   for t in threads:
     result = t.get(timeout=60)
-    print result[0]
+    print(result[0])
     rv.append(result[1])
 
   return rv
 
 
 def GuessVCSName(options):
   """Helper to guess the version control system.
 
   This examines the current directory, guesses which VersionControlSystem
   we're using, and returns an string indicating which VCS is detected.
@@ skipping 256 matching lines @@
 
   vcs = GuessVCS(options)
 
   base = options.base_url
   if isinstance(vcs, SubversionVCS):
     # Guessing the base field is only supported for Subversion.
     # Note: Fetching base files may become deprecated in future releases.
     guessed_base = vcs.GuessBase(options.download_base)
     if base:
       if guessed_base and base != guessed_base:
-        print "Using base URL \"%s\" from --base_url instead of \"%s\"" % \
-            (base, guessed_base)
+        print("Using base URL \"%s\" from --base_url instead of \"%s\"" %
+              (base, guessed_base))
     else:
       base = guessed_base
 
   if not base and options.download_base:
     options.download_base = True
     LOGGER.info("Enabled upload of base file")
   if not options.assume_yes:
     vcs.CheckForUnknownFiles()
   if data is None:
     data = vcs.GenerateDiff(args)
   data = vcs.PostProcessDiff(data)
   if options.print_diffs:
-    print "Rietveld diff start:*****"
-    print data
-    print "Rietveld diff end:*****"
+    print("Rietveld diff start:*****")
+    print(data)
+    print("Rietveld diff end:*****")
   files = vcs.GetBaseFiles(data)
   if verbosity >= 1:
-    print "Upload server:", options.server, "(change with -s/--server)"
+    print("Upload server:", options.server, "(change with -s/--server)")
 
   auth_config = auth.extract_auth_config_from_options(options)
   rpc_server = GetRpcServer(options.server, auth_config, options.email)
   form_fields = []
 
   repo_guid = vcs.GetGUID()
   if repo_guid:
     form_fields.append(("repo_guid", repo_guid))
   if base:
     b = urlparse.urlparse(base)
@@ skipping 65 matching lines @@
   base_hashes = ""
   for file, info in files.iteritems():
     if not info[0] is None:
       checksum = md5(info[0]).hexdigest()
       if base_hashes:
         base_hashes += "|"
       base_hashes += checksum + ":" + file
   form_fields.append(("base_hashes", base_hashes))
   if options.private:
     if options.issue:
-      print "Warning: Private flag ignored when updating an existing issue."
+      print("Warning: Private flag ignored when updating an existing issue.")
     else:
       form_fields.append(("private", "1"))
   if options.send_patch:
     options.send_mail = True
   if not options.download_base:
     form_fields.append(("content_upload", "1"))
   if len(data) > MAX_UPLOAD_SIZE:
-    print "Patch is large, so uploading file patches separately."
+    print("Patch is large, so uploading file patches separately.")
     uploaded_diff_file = []
     form_fields.append(("separate_patches", "1"))
   else:
     uploaded_diff_file = [("data", "data.diff", data)]
   ctype, body = EncodeMultipartFormData(form_fields, uploaded_diff_file)
   response_body = rpc_server.Send("/upload", body, content_type=ctype)
   issue, patchset = None, None
   if not options.download_base or not uploaded_diff_file:
     lines = response_body.splitlines()
     if len(lines) >= 2:
@@ skipping 38 matching lines @@
   try:
     logging.basicConfig(format=("%(asctime).19s %(levelname)s %(filename)s:"
                                 "%(lineno)s %(message)s "))
     os.environ['LC_ALL'] = 'C'
     RealMain(sys.argv)
   except KeyboardInterrupt:
     print
     StatusUpdate("Interrupted.")
     sys.exit(1)
   except auth.AuthenticationError as e:
-    print >> sys.stderr, e
+    print(e, file=sys.stderr)
     sys.exit(1)
 
 
 if __name__ == "__main__":
   main()