[NaCl SDK] Convert python scripts from optparse to argparse.

native_client_sdk/src/build_tools/sdk_tools/sdk_update_main.py

 #!/usr/bin/env python

[binji, 2014/11/13 23:57:02]

I'd prefer doing the sdk_updater as a separate CL. It has a more complex
argument parsing scheme, and is used by external users (so maybe we don't want
to update it to 2.7 yet)

[Sam Clegg, 2014/11/30 17:55:11]

Done.

 # 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.
 
 # CMD code copied from git_cl.py in depot_tools.
 
 import config
 import cStringIO
 import download
 import logging
-import optparse
+import argparse
 import os
 import re
 import sdk_update_common
 from sdk_update_common import Error
 import sys
 import urllib2
 
 SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
 PARENT_DIR = os.path.dirname(SCRIPT_DIR)
 
@@ skipping 142 matching lines @@
     manifest.MergeManifest(LoadRemoteManifest(source))
   return manifest
 
 
 # Commands #####################################################################
 
 
 @usage('<bundle names...>')
 def CMDinfo(parser, args):
   """display information about a bundle"""
-  options, args = parser.parse_args(args)
-  if not args:
-    parser.error('No bundles given')
-    return 0
+  parser.add_argument('bundles', nargs='+')
+  options = parser.parse_args(args)
   cfg = LoadConfig()
   remote_manifest = LoadCombinedRemoteManifest(options.manifest_url, cfg)
-  command.info.Info(remote_manifest, args)
+  command.info.Info(remote_manifest, options.bundles)
   return 0
 
 
 def CMDlist(parser, args):
   """list all available bundles"""
-  parser.add_option('-r', '--revision', action='store_true',
+  parser.add_argument('-r', '--revision', action='store_true',
                     help='display revision numbers')
-  options, args = parser.parse_args(args)
-  if args:
-    parser.error('Unsupported argument(s): %s' % ', '.join(args))
+  options = parser.parse_args(args)
   local_manifest = LoadLocalManifest()
   cfg = LoadConfig()
   remote_manifest = LoadCombinedRemoteManifest(options.manifest_url, cfg)
   command.list.List(remote_manifest, local_manifest, options.revision)
   return 0
 
 
 @usage('<bundle names...>')
 def CMDupdate(parser, args):
   """update a bundle in the SDK to the latest version"""
-  parser.add_option('-F', '--force', action='store_true',
+  parser.add_argument('-F', '--force', action='store_true',
       help='Force updating bundles that already exist. The bundle will not be '
           'updated if the local revision matches the remote revision.')
-  options, args = parser.parse_args(args)
+  parser.add_argument('bundles', nargs='*',
+                      help='bundles to update',
+                      default=[command.update.RECOMMENDED])
+  options = parser.parse_args(args)
   local_manifest = LoadLocalManifest()
   cfg = LoadConfig()
   remote_manifest = LoadCombinedRemoteManifest(options.manifest_url, cfg)
 
-  if not args:
-    args = [command.update.RECOMMENDED]
-
   try:
     delegate = command.update.RealUpdateDelegate(USER_DATA_DIR,
                                                  DEFAULT_SDK_ROOT, cfg)
-    command.update.Update(delegate, remote_manifest, local_manifest, args,
-                          options.force)
+    command.update.Update(delegate, remote_manifest, local_manifest,
+                          options.bundles, options.force)
   finally:
     # Always write out the local manifest, we may have successfully updated one
     # or more bundles before failing.
     try:
       WriteLocalManifest(local_manifest)
     except Error as e:
       # Log the error writing to the manifest, but propagate the original
       # exception.
       logging.error(str(e))
 
   return 0
 
 
 def CMDinstall(parser, args):
   """install a bundle in the SDK"""
   # For now, forward to CMDupdate. We may want different behavior for this
   # in the future, though...
   return CMDupdate(parser, args)
 
 
 @usage('<bundle names...>')
 def CMDuninstall(parser, args):
   """uninstall the given bundles"""
-  _, args = parser.parse_args(args)
-  if not args:
-    parser.error('No bundles given')
-    return 0
+  parser.add_argument('bundles', nargs='+', help='bundles to uninstall')
+  options = parser.parse_args(args)
   local_manifest = LoadLocalManifest()
-  command.uninstall.Uninstall(DEFAULT_SDK_ROOT, local_manifest, args)
+  command.uninstall.Uninstall(DEFAULT_SDK_ROOT, local_manifest, options.bundles)
   WriteLocalManifest(local_manifest)
   return 0
 
 
 @usage('<bundle names...>')
 def CMDreinstall(parser, args):
   """restore the given bundles to their original state
 
   Note that if there is an update to a given bundle, reinstall will not
   automatically update to the newest version.
   """
-  _, args = parser.parse_args(args)
+  parser.add_argument('bundles', nargs='+')
+  options = parser.parse_args(args)
   local_manifest = LoadLocalManifest()
 
-  if not args:
-    parser.error('No bundles given')
-    return 0
-
   cfg = LoadConfig()
   try:
     delegate = command.update.RealUpdateDelegate(USER_DATA_DIR,
                                                  DEFAULT_SDK_ROOT, cfg)
-    command.update.Reinstall(delegate, local_manifest, args)
+    command.update.Reinstall(delegate, local_manifest, options.bundles)
   finally:
     # Always write out the local manifest, we may have successfully updated one
     # or more bundles before failing.
     try:
       WriteLocalManifest(local_manifest)
     except Error as e:
       # Log the error writing to the manifest, but propagate the original
       # exception.
       logging.error(str(e))
 
   return 0
 
 
 def CMDsources(parser, args):
   """manage external package sources"""
-  parser.add_option('-a', '--add', dest='url_to_add',
+  parser.add_argument('-a', '--add', dest='url_to_add',
                     help='Add an additional package source')
-  parser.add_option(
+  parser.add_argument(
       '-r', '--remove', dest='url_to_remove',
       help='Remove package source (use \'all\' for all additional sources)')
-  parser.add_option('-l', '--list', dest='do_list', action='store_true',
+  parser.add_argument('-l', '--list', dest='do_list', action='store_true',
                     help='List additional package sources')
-  options, args = parser.parse_args(args)
+  options = parser.parse_args(args)
 
   cfg = LoadConfig(True)
   write_config = False
   if options.url_to_add:
     command.sources.AddSource(cfg, options.url_to_add)
     write_config = True
   elif options.url_to_remove:
     command.sources.RemoveSource(cfg, options.url_to_remove)
     write_config = True
   elif options.do_list:
     command.sources.ListSources(cfg)
   else:
     parser.print_help()
 
   if write_config:
     WriteConfig(cfg)
 
   return 0
 
 
 def CMDversion(parser, args):
   """display version information"""
-  _, _ = parser.parse_args(args)
+  parser.parse_args(args)
   print "Native Client SDK Updater, version r%s" % REVISION
   return 0
 
 
 def CMDhelp(parser, args):
   """print list of commands or help for a specific command"""
-  _, args = parser.parse_args(args)
-  if len(args) == 1:
-    return main(args + ['--help'])
+  parser.add_argument('command', nargs='?', help=argparse.SUPPRESS)
+  options = parser.parse_args(args)
+  if options.command:
+    return main(options.command + ['--help'])
   parser.print_help()
   return 0
 
 
 def Command(name):
   return globals().get('CMD' + name, None)
 
 
 def GenUsage(parser, cmd):
   """Modify an OptParse object with the function's documentation."""
   obj = Command(cmd)
   more = getattr(obj, 'usage_more', '')
   if cmd == 'help':
     cmd = '<command>'
   else:
     # OptParser.description prefer nicely non-formatted strings.
     parser.description = re.sub('[\r\n ]{2,}', ' ', obj.__doc__)
-  parser.set_usage('usage: %%prog %s [options] %s' % (cmd, more))
+  parser.usage = '%%(prog)s %s [options] %s' % (cmd, more)
 
 
 def UpdateSDKTools(options, args):
   """update the sdk_tools bundle"""
 
   local_manifest = LoadLocalManifest()
   cfg = LoadConfig()
   remote_manifest = LoadCombinedRemoteManifest(options.manifest_url, cfg)
 
   try:
@@ skipping 16 matching lines @@
   # Get all commands...
   cmds = [fn[3:] for fn in dir(sys.modules[__name__]) if fn.startswith('CMD')]
   # Remove hidden commands...
   cmds = filter(lambda fn: not getattr(Command(fn), 'hide', 0), cmds)
   # Format for CMDhelp usage.
   CMDhelp.usage_more = ('\n\nCommands are:\n' + '\n'.join([
       '  %-10s %s' % (fn, Command(fn).__doc__.split('\n')[0].strip())
       for fn in cmds]))
 
   # Create the option parse and add --verbose support.
-  parser = optparse.OptionParser()
-  parser.add_option(
+  parser = argparse.ArgumentParser(description=__doc__)
+  parser.add_argument(
       '-v', '--verbose', action='count', default=0,
       help='Use 2 times for more debugging info')
-  parser.add_option('-U', '--manifest-url', dest='manifest_url',
+  parser.add_argument('-U', '--manifest-url', dest='manifest_url',
       default=GSTORE_URL + '/nacl/nacl_sdk/' + MANIFEST_FILENAME,
       metavar='URL', help='override the default URL for the NaCl manifest file')
-  parser.add_option('--update-sdk-tools', action='store_true',
-                    dest='update_sdk_tools', help=optparse.SUPPRESS_HELP)
+  parser.add_argument('--update-sdk-tools', action='store_true',
+      dest='update_sdk_tools', help=argparse.SUPPRESS)
 
   old_parser_args = parser.parse_args
   def Parse(args):
-    options, args = old_parser_args(args)
+    options = old_parser_args(args)
     if options.verbose >= 2:
       loglevel = logging.DEBUG
     elif options.verbose:
       loglevel = logging.INFO
     else:
       loglevel = logging.WARNING
 
-    fmt = '%(levelname)s:%(message)s'
-    logging.basicConfig(stream=sys.stdout, level=loglevel, format=fmt)
+    logging.basicConfig(stream=sys.stdout, level=loglevel,
+                        format='%(levelname)s:%(message)s')
 
     # If --update-sdk-tools is passed, circumvent any other command running.
     if options.update_sdk_tools:
       UpdateSDKTools(options, args)
       sys.exit(1)
 
-    return options, args
+    return options
   parser.parse_args = Parse
 
   if argv:
     cmd = Command(argv[0])
     if cmd:
       # "fix" the usage and the description now that we know the subcommand.
       GenUsage(parser, argv[0])
       return cmd(parser, argv[1:])
 
   # Not a known command. Default to help.
   GenUsage(parser, 'help')
   return CMDhelp(parser, argv)
 
 
 if __name__ == '__main__':
   try:
     sys.exit(main(sys.argv[1:]))
   except Error as e:
     logging.error(str(e))
     sys.exit(1)
   except KeyboardInterrupt:
     sys.stderr.write('naclsdk: interrupted\n')
     sys.exit(1)