CVS style argument parsing?

Josef Wolf jw at
Fri Jul 23 19:55:05 CEST 2004

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

>> > 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 " 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
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:,
 and 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:

  import sys
  from optparse import OptionParser
  class MyOptionParser:
      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.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()
              subcommand = subcommands[args[0]]
              (subopts, subargs) = subcommand["obj"].parse_args(args[1:])

  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.")

  import os
  import sys
  import Opt
  import Dump

Please visit and sign and
-- Josef Wolf -- jw at --

More information about the Python-list mailing list