CVS style argument parsing?

[Josef Wolf]

Jeff Epler schrieb im Artikel <mailman.660.1090417425.5135.python-list at python.org>:

>> > By using parser.disable_interspersed_args() you can make the parsing of
>>                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>> Aaaahhh, this was the bit of information I was missing.  Is it "legal" to
>> use this method?  It seems not to be documented in the library reference?

I tried it now and it mostly seems to work as expected.  But there are
some cosmetic drawbacks:

1. When called "main.py dump -h" then _first_ the help for the subcommand
   is printed and after that the help for the global options are printed.
   I think this is because I am doing something very stupid with the
   exception?
2. When invalid options are given, only the usage information is printed.
   The list of available options is missing.  (This is for both, the global
   options as well as the subcommand options.)
3. When I replace the call to parser.print_help() in the exception handler
   with a "pass" statement, (1.) seems to be fixed, but then no help at
   all is printed when no subcommand is given.

Maybe someone could give me hints what I am doing wrong?

(I have attached the script (consiting of three modules: main.py, Opt.py
 and Dump.py) at the end of this posting.)

PS: I am very interested in comments how to make things more python-ish.
    I am new to python and am probably doing very stupid things :)

> I agree, it doesn't seem to be in the documentation.  It's been in the
> module since at least 2002, when it was called Optik, and has been
> suggested many times to people who want to implement "cvs-like"
> commandline parsers, according to a few google searches I performed.

I have tried to google, but could not find anything.  I get either
thousands of hits (alsmost all related to perforce) or nothing at all.
What keywords have you used?


here come the scripts:

#File Opt.py:
  import sys
  from optparse import OptionParser
  
  class MyOptionParser:
      subcommands={}
  
      def __init__(self, mode, callback, help):
          self.__parser=OptionParser("%%prog %s [%s-options]" % (mode,mode))
          MyOptionParser.subcommands[mode] = {"obj"  : self,
                                              "func" : callback,
                                              "help" : help}
  
      def __getattr__(self, name):
          return getattr(self.__parser, name)
  
      def global_parser():
          global opts, args, subopts, subargs
          global subcommand
        
          subcommands = MyOptionParser.subcommands
        
          parser = OptionParser()
          parser.disable_interspersed_args()
          
          parser.add_option("-f", help="Foo option.")
          parser.add_option("-b", help="Bar option.")
          
          parser.set_usage("%prog [options]" +
                           " subcommand [subcommand-options]:\n\n" +
                           "Available subcommands:\n" +
                           "\n".join(["  %-8s  %s" % (k,subcommands[k]["help"])
                                      for k in subcommands.keys()]))
  
          (opts, args) = parser.parse_args()
          
          try:
              subcommand = subcommands[args[0]]
              (subopts, subargs) = subcommand["obj"].parse_args(args[1:])
              subcommand["func"](subargs)
          
          except:
              parser.print_help()
  
          sys.exit()
  
      global_parser=staticmethod(global_parser)


#File Dump.py:
  import Opt
  
  def main(args):
      print Opt.opts
      print Opt.subopts
      print Opt.subargs

  def init_main():
      opt_dump=Opt.MyOptionParser("dump", main, "Dump database contents.")
      opt_dump.add_option("-z", help="Baz option.")
      opt_dump.add_option("-b", help="Blah option.")
  
  init_main()


#File main.py:
  import os
  import sys
  
  import Opt
  import Dump
  
  Opt.MyOptionParser.global_parser()


-- 
Please visit and sign http://petition-eurolinux.org and http://www.ffii.org
-- Josef Wolf -- jw at raven.inka.de --