default config files are automatically generated

and are not staged by default.

IPython/config/application.py

@@ -19,10 +19,11 b' Authors:'
 # Imports
 #-----------------------------------------------------------------------------
 
-from copy import deepcopy
 import logging
+import os
 import re
 import sys
+from copy import deepcopy
 
 from IPython.config.configurable import SingletonConfigurable
 from IPython.config.loader import (
@@ -98,9 +99,13 b' class Application(SingletonConfigurable):'
     version = Unicode(u'0.0')
 
     # The log level for the application
-    log_level = Enum((0,10,20,30,40,50), default_value=logging.WARN,
+    log_level = Enum((0,10,20,30,40,50,'DEBUG','INFO','WARN','ERROR','CRITICAL'),
+                    default_value=logging.WARN,
                      config=True,
-                     help="Set the log level.")
+                    help="Set the log level by value or name.")
+    def _log_level_changed(self, name, old, new):
+        if isinstance(new, basestring):
+            self.log_level = getattr(logging, new)
     
     # the alias map for configurables
     aliases = Dict(dict(log_level='Application.log_level'))
@@ -337,6 +342,16 b' class Application(SingletonConfigurable):'
         config = loader.load_config()
         self.update_config(config)
 
+    def generate_config_file(self):
+        """generate default config file from Configurables"""
+        lines = ["# Configuration file for %s."%self.name]
+        lines.append('')
+        lines.append('c = get_config()')
+        lines.append('')
+        for cls in self.classes:
+            lines.append(cls.class_config_section())
+        return '\n'.join(lines)
+
     def exit(self, exit_status=0):
         self.log.debug("Exiting application: %s" % self.name)
         sys.exit(exit_status)

IPython/config/configurable.py

@@ -180,6 +180,38 b' class Configurable(HasTraits):'
         """Get the help string for a single trait and print it."""
         print cls.class_get_help()
 
+    @classmethod
+    def class_config_section(cls):
+        """Get the config class config section"""
+        def c(s):
+            """return a commented, wrapped block."""
+            s = '\n\n'.join(wrap_paragraphs(s, 78))
+            
+            return '# ' + s.replace('\n', '\n# ')
+        
+        # section header
+        breaker = '#' + '-'*78
+        s = "# %s configuration"%cls.__name__
+        lines = [breaker, s, breaker, '']
+        # get the description trait
+        desc = cls.class_traits().get('description')
+        if desc:
+            desc = desc.default_value
+        else:
+            # no description trait, use __doc__
+            desc = getattr(cls, '__doc__', '')
+        if desc:
+            lines.append(c(desc))
+            lines.append('')
+        
+        for name,trait in cls.class_traits(config=True).iteritems():
+            help = trait.get_metadata('help') or ''
+            lines.append(c(help))
+            lines.append('# c.%s.%s = %r'%(cls.__name__, name, trait.get_default_value()))
+            lines.append('')
+        return '\n'.join(lines)
+    
+    
 
 class SingletonConfigurable(Configurable):
     """A configurable that only allows one instance.

IPython/core/application.py

@@ -82,6 +82,8 b' class BaseIPythonApplication(Application):'
     config_file_specified = Bool(False)
     
     config_file_name = Unicode(u'ipython_config.py')
+    def _config_file_name_default(self):
+        return self.name.replace('-','_') + u'_config.py'
     def _config_file_name_changed(self, name, old, new):
         if new != old:
             self.config_file_specified = True
@@ -103,7 +105,6 b' class BaseIPythonApplication(Application):'
                 get_ipython_package_dir(), u'config', u'profile', new
         )
         
-
     ipython_dir = Unicode(get_ipython_dir(), config=True, 
         help="""
         The name of the IPython directory. This directory is used for logging
@@ -123,7 +124,11 b' class BaseIPythonApplication(Application):'
         return [u'ipython_config.py']
     
     copy_config_files = Bool(False, config=True,
-        help="""Whether to copy the default config files into the profile dir.""")
+        help="""Whether to install the default config files into the profile dir.
+        If a new profile is being created, and IPython contains config files for that
+        profile, then they will be staged into the new directory.  Otherwise,
+        default config files will be automatically generated.
+        """)
 
     # The class to use as the crash handler.
     crash_handler_class = Type(crashhandler.CrashHandler)
@@ -162,6 +167,21 b' class BaseIPythonApplication(Application):'
         printed on screen. For testing, the suppress_errors option is set
         to False, so errors will make tests fail.
         """
+        base_config = 'ipython_config.py'
+        self.log.debug("Attempting to load config file: %s" %
+                       base_config)
+        try:
+            Application.load_config_file(
+                self,
+                base_config, 
+                path=self.config_file_paths
+            )
+        except IOError:
+            # ignore errors loading parent
+            pass
+        if self.config_file_name == base_config:
+            # don't load secondary config
+            return
         self.log.debug("Attempting to load config file: %s" %
                        self.config_file_name)
         try:
@@ -235,21 +255,32 b' class BaseIPythonApplication(Application):'
         if self.copy_config_files:
             path = self.builtin_profile_dir
             src = self.profile
-            if not os.path.exists(path):
-                # use default if new profile doesn't have a preset
-                path = None
-                src = 'default'
             
-            self.log.debug("Staging %s config files into %r [overwrite=%s]"%(
-                    src, self.profile_dir.location, self.overwrite)
+            cfg = self.config_file_name
+            if path and os.path.exists(os.path.join(path, cfg)):
+                self.log.warn("Staging %r from %s into %r [overwrite=%s]"%(
+                        cfg, src, self.profile_dir.location, self.overwrite)
             )
-            
-            for cfg in self.config_files:
                 self.profile_dir.copy_config_file(cfg, path=path, overwrite=self.overwrite)
+            else:
+                self.stage_default_config_file()
+    
+    def stage_default_config_file(self):
+        """auto generate default config file, and stage it into the profile."""
+        s = self.generate_config_file()
+        fname = os.path.join(self.profile_dir.location, self.config_file_name)
+        if self.overwrite or not os.path.exists(fname):
+            self.log.warn("Generating default config file: %r"%(fname))
+            with open(fname, 'w') as f:
+                f.write(s)
+        
     
     def initialize(self, argv=None):
         self.init_crash_handler()
         self.parse_command_line(argv)
+        if self.subapp is not None:
+            # stop here if subapp is taking over
+            return
         cl_config = self.config
         self.init_profile_dir()
         self.init_config_files()

IPython/core/profileapp.py

@@ -163,6 +163,42 b' class ProfileCreate(BaseIPythonApplication):'
     
     classes = [ProfileDir]
 
+    def init_config_files(self):
+        super(ProfileCreate, self).init_config_files()
+        # use local imports, since these classes may import from here
+        from IPython.frontend.terminal.ipapp import TerminalIPythonApp
+        apps = [TerminalIPythonApp]
+        try:
+            from IPython.frontend.qt.console.qtconsoleapp import IPythonQtConsoleApp
+        except ImportError:
+            pass
+        else:
+            apps.append(IPythonQtConsoleApp)
+        if self.cluster:
+            from IPython.parallel.apps.ipcontrollerapp import IPControllerApp
+            from IPython.parallel.apps.ipengineapp import IPEngineApp
+            from IPython.parallel.apps.ipclusterapp import IPClusterStart
+            from IPython.parallel.apps.iploggerapp import IPLoggerApp
+            apps.extend([
+                IPControllerApp,
+                IPEngineApp,
+                IPClusterStart,
+                IPLoggerApp,
+            ])
+        for App in apps:
+            app = App()
+            app.config.update(self.config)
+            app.log = self.log
+            app.overwrite = self.overwrite
+            app.copy_config_files=True
+            app.profile = self.profile
+            app.init_profile_dir()
+            app.init_config_files()
+        print 'tic'
+    
+    def stage_default_config_file(self):
+        pass
+
 class ProfileApp(Application):
     name = u'ipython-profile'
     description = profile_help

IPython/frontend/terminal/ipapp.py

@@ -208,9 +208,8 b' class TerminalIPythonApp(BaseIPythonApplication, InteractiveShellApp):'
             "Create and manage IPython profiles.")
     ))
     
-    # *do* autocreate requested profile
+    # *do* autocreate requested profile, but don't create the config file.
     auto_create=Bool(True)
-    copy_config_files=Bool(True)
     # configurables
     ignore_old_config=Bool(False, config=True,
         help="Suppress warning messages about legacy config files"

IPython/parallel/apps/ipclusterapp.py

@@ -322,7 +322,7 b' class IPClusterStart(IPClusterEngines):'
     classes = List()
     def _classes_default(self,):
         from IPython.parallel.apps import launcher
-        return [ProfileDir]+launcher.all_launchers
+        return [ProfileDir] + [IPClusterEngines] + launcher.all_launchers
     
     clean_logs = Bool(True, config=True, 
         help="whether to cleanup old logs before starting")
@@ -410,12 +410,11 b' class IPClusterStart(IPClusterEngines):'
 
 base='IPython.parallel.apps.ipclusterapp.IPCluster'
 
-class IPBaseParallelApplication(Application):
+class IPClusterApp(Application):
     name = u'ipcluster'
     description = _description
     
-    subcommands = {'create' : (base+'Create', create_help),
-                'list' : (base+'List', list_help),
+    subcommands = {
                 'start' : (base+'Start', start_help),
                 'stop' : (base+'Stop', stop_help),
                 'engines' : (base+'Engines', engines_help),

IPython/parallel/apps/ipengineapp.py

@@ -103,7 +103,7 b' class MPI(Configurable):'
 
 class IPEngineApp(BaseParallelApplication):
 
-    app_name = Unicode(u'ipengine')
+    name = Unicode(u'ipengine')
     description = Unicode(_description)
     config_file_name = Unicode(default_config_file_name)
     classes = List([ProfileDir, Session, EngineFactory, Kernel, MPI])

IPython/parallel/apps/iploggerapp.py

@@ -61,7 +61,7 b" aliases.update(dict(url='LogWatcher.url', topics='LogWatcher.topics'))"
 
 class IPLoggerApp(BaseParallelApplication):
 
-    name = u'iploggerz'
+    name = u'iplogger'
     description = _description
     config_file_name = Unicode(default_config_file_name)