add subcommand support

IPython/config/application.py

@@ -1,293 +1,360 b''
 # encoding: utf-8
 """
 A base class for a configurable application.
 
 Authors:
 
 * Brian Granger
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 from copy import deepcopy
 import logging
 import sys
 
 from IPython.config.configurable import SingletonConfigurable
 from IPython.config.loader import (
     KeyValueConfigLoader, PyFileConfigLoader, Config
 )
 
 from IPython.utils.traitlets import (
-    Unicode, List, Int, Enum, Dict
+    Unicode, List, Int, Enum, Dict, Instance
 )
+from IPython.utils.importstring import import_item
 from IPython.utils.text import indent
 
 #-----------------------------------------------------------------------------
 # Descriptions for the various sections
 #-----------------------------------------------------------------------------
 
 flag_description = """
 Flags are command-line arguments passed as '--<flag>'.
 These take no parameters, unlike regular key-value arguments.
 They are typically used for setting boolean flags, or enabling
 modes that involve setting multiple options together.
 """.strip() # trim newlines of front and back
 
 alias_description = """
 These are commonly set parameters, given abbreviated aliases for convenience.
 They are set in the same `name=value` way as class parameters, where
 <name> is replaced by the real parameter for which it is an alias.
 """.strip() # trim newlines of front and back
 
 keyvalue_description = """
 Parameters are set from command-line arguments of the form:
 `Class.trait=value`.  Parameters will *never* be prefixed with '-'.
 This line is evaluated in Python, so simple expressions are allowed, e.g.
     `C.a='range(3)'`   For setting C.a=[0,1,2]
 """.strip() # trim newlines of front and back
 
 #-----------------------------------------------------------------------------
 # Application class
 #-----------------------------------------------------------------------------
 
 
 class ApplicationError(Exception):
     pass
 
 
 class Application(SingletonConfigurable):
     """A singleton application with full configuration support."""
 
     # The name of the application, will usually match the name of the command
     # line application
     name = Unicode(u'application')
 
     # The description of the application that is printed at the beginning
     # of the help.
     description = Unicode(u'This is an application.')
     # default section descriptions
     flag_description = Unicode(flag_description)
     alias_description = Unicode(alias_description)
     keyvalue_description = Unicode(keyvalue_description)
     
 
     # A sequence of Configurable subclasses whose config=True attributes will
     # be exposed at the command line.
     classes = List([])
 
     # The version string of this application.
     version = Unicode(u'0.0')
 
     # The log level for the application
     log_level = Enum((0,10,20,30,40,50), default_value=logging.WARN,
                      config=True,
                      help="Set the log level.")
     
     # the alias map for configurables
     aliases = Dict(dict(log_level='Application.log_level'))
     
     # flags for loading Configurables or store_const style flags
     # flags are loaded from this dict by '--key' flags
     # this must be a dict of two-tuples, the first element being the Config/dict
     # and the second being the help string for the flag
     flags = Dict()
     
+    # subcommands for launching other applications
+    # if this is not empty, this will be a parent Application
+    # this must be a dict of two-tuples, the first element being the application class/import string
+    # and the second being the help string for the subcommand
+    subcommands = Dict()
+    # parse_command_line will initialize a subapp, if requested
+    subapp = Instance('IPython.config.application.Application', allow_none=True)
+    
 
     def __init__(self, **kwargs):
         SingletonConfigurable.__init__(self, **kwargs)
         # Add my class to self.classes so my attributes appear in command line
         # options.
         self.classes.insert(0, self.__class__)
         
         # ensure self.flags dict is valid
         for key,value in self.flags.iteritems():
             assert len(value) == 2, "Bad flag: %r:%s"%(key,value)
             assert isinstance(value[0], (dict, Config)), "Bad flag: %r:%s"%(key,value)
             assert isinstance(value[1], basestring), "Bad flag: %r:%s"%(key,value)
         self.init_logging()
 
     def _config_changed(self, name, old, new):
         SingletonConfigurable._config_changed(self, name, old, new)
         self.log.debug('Config changed:')
         self.log.debug(repr(new))
 
     def init_logging(self):
         """Start logging for this application.
 
         The default is to log to stdout using a StreaHandler. The log level
         starts at loggin.WARN, but this can be adjusted by setting the 
         ``log_level`` attribute.
         """
         self.log = logging.getLogger(self.__class__.__name__)
         self.log.setLevel(self.log_level)
         self._log_handler = logging.StreamHandler()
         self._log_formatter = logging.Formatter("[%(name)s] %(message)s")
         self._log_handler.setFormatter(self._log_formatter)
         self.log.addHandler(self._log_handler)
-
+    
+    def initialize(self, argv=None):
+        """Do the basic steps to configure me.
+        
+        Override in subclasses.
+        """
+        self.parse_command_line(argv)
+        
+    
+    def start(self):
+        """Start the app mainloop.
+        
+        Override in subclasses.
+        """
+        if self.subapp is not None:
+            return self.subapp.start()
+    
     def _log_level_changed(self, name, old, new):
         """Adjust the log level when log_level is set."""
         self.log.setLevel(new)
     
     def print_alias_help(self):
         """print the alias part of the help"""
         if not self.aliases:
             return
         
         lines = ['Aliases']
-        lines.append('_'*len(lines[0]))
+        lines.append('-'*len(lines[0]))
         lines.append(self.alias_description)
         lines.append('')
         
         classdict = {}
         for c in self.classes:
             classdict[c.__name__] = c
         
         for alias, longname in self.aliases.iteritems():
             classname, traitname = longname.split('.',1)
             cls = classdict[classname]
             
             trait = cls.class_traits(config=True)[traitname]
             help = cls.class_get_trait_help(trait)
             help = help.replace(longname, "%s (%s)"%(alias, longname), 1)
             lines.append(help)
-            # header = "%s (%s) : %s"%(alias, longname, trait.__class__.__name__)
-            # lines.append(header)
-            # help = cls.class_get_trait_help(trait)
-            # if help:
-            #     lines.append(indent(help, flatten=True))
         lines.append('')
         print '\n'.join(lines)
     
     def print_flag_help(self):
         """print the flag part of the help"""
         if not self.flags:
             return
         
         lines = ['Flags']
-        lines.append('_'*len(lines[0]))
+        lines.append('-'*len(lines[0]))
         lines.append(self.flag_description)
         lines.append('')
         
         for m, (cfg,help) in self.flags.iteritems():
             lines.append('--'+m)
             lines.append(indent(help, flatten=True))
         lines.append('')
         print '\n'.join(lines)
     
+    def print_subcommands(self):
+        """print the subcommand part of the help"""
+        if not self.subcommands:
+            return
+        
+        lines = ["Subcommands"]
+        lines.append('-'*len(lines[0]))
+        for subc, cls,help in self.subcommands:
+            lines.append("%s : %s"%(subc, cls))
+            if help:
+                lines.append(indent(help, flatten=True))
+        lines.append('')
+        print '\n'.join(lines)
+    
     def print_help(self, classes=False):
         """Print the help for each Configurable class in self.classes.
         
         If classes=False (the default), only flags and aliases are printed
         """
         self.print_flag_help()
         self.print_alias_help()
         
         if classes:
             if self.classes:
                 print "Class parameters"
                 print "----------------"
                 print self.keyvalue_description
                 print
         
             for cls in self.classes:
                 cls.class_print_help()
                 print
         else:
             print "To see all available configurables, use `--help-all`"
             print
 
     def print_description(self):
         """Print the application description."""
         print self.description
         print
 
     def print_version(self):
         """Print the version string."""
         print self.version
 
     def update_config(self, config):
         """Fire the traits events when the config is updated."""
         # Save a copy of the current config.
         newconfig = deepcopy(self.config)
         # Merge the new config into the current one.
         newconfig._merge(config)
         # Save the combined config as self.config, which triggers the traits
         # events.
         self.config = newconfig
-
+    
+    def initialize_subcommand(self, subc, argv=None):
+        """Initialize a subcommand with argv"""
+        if '-h' in subc:
+            # requested help
+            self.print_description()
+            self.print_subcommands()
+            self.exit(0)
+        subapp = self.subcommands.get(subc, None)
+        if subapp is None:
+            self.print_description()
+            print "No such subcommand: %r"%subc
+            print
+            self.print_subcommands()
+            self.exit(1)
+            
+        if isinstance(subapp, basestring):
+            subapp = import_item(subapp)
+        
+        # instantiate
+        self.subapp = subapp()
+        # and initialize subapp
+        self.subapp.initialize(argv)
+        
     def parse_command_line(self, argv=None):
         """Parse the command line arguments."""
         argv = sys.argv[1:] if argv is None else argv
 
+        if self.subcommands:
+            # we have subcommands
+            if len(argv) == 0:
+                # none specified
+                self.print_description()
+                self.print_subcommands()
+                self.exit(1)
+            
+            return self.initialize_subcommand(argv[0], argv[1:])
+            
         if '-h' in argv or '--help' in argv or '--help-all' in argv:
             self.print_description()
             self.print_help('--help-all' in argv)
             self.exit(0)
 
         if '--version' in argv:
             self.print_version()
             self.exit(0)
         
         loader = KeyValueConfigLoader(argv=argv, aliases=self.aliases,
                                         flags=self.flags)
         config = loader.load_config()
         self.update_config(config)
 
     def load_config_file(self, filename, path=None):
         """Load a .py based config file by filename and path."""
         loader = PyFileConfigLoader(filename, path=path)
         config = loader.load_config()
         self.update_config(config)
 
     def exit(self, exit_status=0):
         self.log.debug("Exiting application: %s" % self.name)
         sys.exit(exit_status)
 
 #-----------------------------------------------------------------------------
 # utility functions, for convenience
 #-----------------------------------------------------------------------------
 
 def boolean_flag(name, configurable, set_help='', unset_help=''):
     """helper for building basic --trait, --no-trait flags
     
     Parameters
     ----------
     
     name : str
         The name of the flag.
     configurable : str
         The 'Class.trait' string of the trait to be set/unset with the flag
     set_help : unicode
         help string for --name flag
     unset_help : unicode
         help string for --no-name flag
     
     Returns
     -------
     
     cfg : dict
         A dict with two keys: 'name', and 'no-name', for setting and unsetting
         the trait, respectively.
     """
     # default helpstrings
     set_help = set_help or "set %s=True"%configurable
     unset_help = unset_help or "set %s=False"%configurable
     
     cls,trait = configurable.split('.')
     
     setter = Config()
     setter[cls][trait] = True
     unsetter = Config()
     unsetter[cls][trait] = False
     return {name : (setter, set_help), 'no-'+name : (unsetter, unset_help)}

docs/examples/core/appconfig.py

@@ -1,96 +1,101 b''
 """A simple example of how to use IPython.config.application.Application.
 
 This should serve as a simple example that shows how the IPython config
 system works. The main classes are:
 
 * IPython.config.configurable.Configurable
 * IPython.config.configurable.SingletonConfigurable
 * IPython.config.loader.Config
 * IPython.config.application.Application
 
 To see the command line option help, run this program from the command line::
 
     $ python appconfig.py -h
 
 To make one of your classes configurable (from the command line and config
 files) inherit from Configurable and declare class attributes as traits (see
 classes Foo and Bar below). To make the traits configurable, you will need
 to set the following options:
 
 * ``config``: set to ``True`` to make the attribute configurable.
 * ``shortname``: by default, configurable attributes are set using the syntax
   "Classname.attributename". At the command line, this is a bit verbose, so
   we allow "shortnames" to be declared. Setting a shortname is optional, but
   when you do this, you can set the option at the command line using the
   syntax: "shortname=value".
 * ``help``: set the help string to display a help message when the ``-h``
   option is given at the command line. The help string should be valid ReST.
 
 When the config attribute of an Application is updated, it will fire all of
 the trait's events for all of the config=True attributes.
 """
 
 import sys
 
 from IPython.config.configurable import Configurable
 from IPython.config.application import Application
 from IPython.utils.traitlets import (
     Bool, Unicode, Int, Float, List, Dict
 )
 
 
 class Foo(Configurable):
     """A class that has configurable, typed attributes.
 
     """
 
     i = Int(0, config=True, help="The integer i.")
     j = Int(1, config=True, help="The integer j.")
     name = Unicode(u'Brian', config=True, help="First name.")
 
 
 class Bar(Configurable):
 
     enabled = Bool(True, config=True, help="Enable bar.")
 
 
 class MyApp(Application):
 
     name = Unicode(u'myapp')
     running = Bool(False, config=True,
                    help="Is the app running?")
     classes = List([Bar, Foo])
     config_file = Unicode(u'', config=True,
                    help="Load this config file")
     
     aliases = Dict(dict(i='Foo.i',j='Foo.j',name='Foo.name', running='MyApp.running',
                         enabled='Bar.enabled', log_level='MyApp.log_level'))
     
     flags = Dict(dict(enable=({'Bar': {'enabled' : True}}, "Enable Bar"),
                   disable=({'Bar': {'enabled' : False}}, "Disable Bar"),
                   debug=({'MyApp':{'log_level':10}}, "Set loglevel to DEBUG")
             ))
     
     def init_foo(self):
         # Pass config to other classes for them to inherit the config.
         self.foo = Foo(config=self.config)
 
     def init_bar(self):
         # Pass config to other classes for them to inherit the config.
         self.bar = Bar(config=self.config)
 
+    def initialize(self, argv=None):
+        self.parse_command_line(argv)
+        if self.config_file:
+            self.load_config_file(self.config_file)
+        self.init_foo()
+        self.init_bar()
+    
+    def start(self):
+        print "app.config:"
+        print self.config
 
 
 def main():
     app = MyApp()
-    app.parse_command_line()
-    if app.config_file:
-        app.load_config_file(app.config_file)
-    app.init_foo()
-    app.init_bar()
-    print "app.config:"
-    print app.config
+    app.initialize()
+    app.start()
 
 
 if __name__ == "__main__":
     main()