git cl upload: stop using deprecated except syntax

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 128 matching lines @@
 
   """
   last_email_file_name = os.path.expanduser("~/.last_codereview_email_address")
   last_email = ""
   if os.path.exists(last_email_file_name):
     try:
       last_email_file = open(last_email_file_name, "r")
       last_email = last_email_file.readline().strip("\n")
       last_email_file.close()
       prompt += " [%s]" % last_email
-    except IOError, e:
+    except IOError as e:
       pass
   email = raw_input(prompt + ": ").strip()
   if email:
     try:
       last_email_file = open(last_email_file_name, "w")
       last_email_file.write(email)
       last_email_file.close()
-    except IOError, e:
+    except IOError as e:
       pass
   else:
     email = last_email
   return email
 
 
 def StatusUpdate(msg):
   """Print a status message to stdout.
 
   If 'verbosity' is greater than 0, print the message.
@@ skipping 113 matching lines @@
             "source": "rietveld-codereview-upload",
             "accountType": account_type,
         }),
     )
     try:
       response = self.opener.open(req)
       response_body = response.read()
       response_dict = dict(x.split("=")
                            for x in response_body.split("\n") if x)
       return response_dict["Auth"]
-    except urllib2.HTTPError, e:
+    except urllib2.HTTPError as e:
       if e.code == 403:
         body = e.read()
         response_dict = dict(x.split("=", 1) for x in body.split("\n") if x)
         raise ClientLoginError(req.get_full_url(), e.code, e.msg,
                                e.headers, response_dict)
       else:
         raise
 
   def _GetAuthCookie(self, auth_token):
     """Fetches authentication cookies for an authentication token.
 
     Args:
       auth_token: The authentication token returned by ClientLogin.
 
     Raises:
       HTTPError: If there was an error fetching the authentication cookies.
     """
     # This is a dummy value to allow us to identify when we're successful.
     continue_location = "http://localhost/"
     args = {"continue": continue_location, "auth": auth_token}
     req = self._CreateRequest("%s/_ah/login?%s" %
                               (self.host, urllib.urlencode(args)))
     try:
       response = self.opener.open(req)
-    except urllib2.HTTPError, e:
+    except urllib2.HTTPError as e:
       response = e
     if (response.code != 302 or
         response.info()["location"] != continue_location):
       raise urllib2.HTTPError(req.get_full_url(), response.code, response.msg,
                               response.headers, response.fp)
     self.authenticated = True
 
   def _Authenticate(self, force_refresh):
     """Authenticates the user.
 
@@ skipping 23 matching lines @@
           error_map = {
               "badauth": "BadAuthentication",
               "cr": "CaptchaRequired",
               "adel": "AccountDeleted",
               "adis": "AccountDisabled",
               "sdis": "ServiceDisabled",
               "ire": "ServiceUnavailable",
           }
           auth_token = self._GetAuthToken(credentials[0], credentials[1],
                                           internal=True)
-        except ClientLoginError, exc:
+        except ClientLoginError as exc:
           e = exc
       if e:
         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 "
@@ skipping 72 matching lines @@
         req = self._CreateRequest(url=url, data=payload)
         req.add_header("Content-Type", content_type)
         if extra_headers:
           for header, value in extra_headers.items():
             req.add_header(header, value)
         try:
           f = self.opener.open(req, timeout=70)
           response = f.read()
           f.close()
           return response
-        except urllib2.HTTPError, e:
+        except urllib2.HTTPError as e:
           if tries > 3:
             raise
           elif e.code in (302, 401, 403):
             if not self.auth_function:
               raise
             # Already tried force refresh, didn't help -> give up with error.
             if auth_attempted:
               raise auth.AuthenticationError(
                   'Access to %s is denied (server returned HTTP %d).'
                   % (self.host, e.code))
@@ skipping 528 matching lines @@
                      ("is_current", str(not is_base)),
                     ]
       if file_too_large:
         form_fields.append(("file_too_large", "1"))
       if options.email:
         form_fields.append(("user", options.email))
       ctype, body = EncodeMultipartFormData(form_fields,
                                             [("data", filename, content)])
       try:
         response_body = rpc_server.Send(url, body, content_type=ctype)
-      except urllib2.HTTPError, e:
+      except urllib2.HTTPError as e:
         response_body = ("Failed to upload file for %s. Got %d status code." %
             (filename, e.code))
 
       if not response_body.startswith("OK"):
         StatusUpdate("  --> %s" % response_body)
         sys.exit(1)
 
       return result
 
     patches = dict()
@@ skipping 1049 matching lines @@
   def UploadFile(filename, data):
     form_fields = [("filename", filename)]
     if not options.download_base:
       form_fields.append(("content_upload", "1"))
     files = [("data", "data.diff", data)]
     ctype, body = EncodeMultipartFormData(form_fields, files)
     url = "/%d/upload_patch/%d" % (int(issue), int(patchset))
 
     try:
       response_body = rpc_server.Send(url, body, content_type=ctype)
-    except urllib2.HTTPError, e:
+    except urllib2.HTTPError as e:
       response_body = ("Failed to upload patch for %s. Got %d status code." %
           (filename, e.code))
 
     lines = response_body.splitlines()
     if not lines or lines[0] != "OK":
       StatusUpdate("  --> %s" % response_body)
       sys.exit(1)
     return ("Uploaded patch for " + filename, [lines[1], filename])
 
   threads = []
@@ skipping 43 matching lines @@
   def RunDetectCommand(vcs_type, command):
     """Helper to detect VCS by executing command.
 
     Returns:
        A pair (vcs, output) or None. Throws exception on error.
     """
     try:
       out, returncode = RunShellWithReturnCode(command)
       if returncode == 0:
         return (vcs_type, out.strip())
-    except OSError, (errcode, message):
-      if errcode != errno.ENOENT:  # command not found code
+    except OSError as e:
+      if e.errno != errno.ENOENT:  # command not found code
         raise
 
   # Mercurial has a command to get the base directory of a repository
   # Try running it, but don't die if we don't have hg installed.
   # NOTE: we try Mercurial first as it can sit on top of an SVN working copy.
   res = RunDetectCommand(VCS_MERCURIAL, ["hg", "root"])
   if res != None:
     return res
 
   # Subversion from 1.7 has a single centralized .svn folder
@@ skipping 398 matching lines @@
     print
     StatusUpdate("Interrupted.")
     sys.exit(1)
   except auth.AuthenticationError as e:
     print(e, file=sys.stderr)
     sys.exit(1)
 
 
 if __name__ == "__main__":
   main()