Simplify options handling code by using argparse argument_default.

The argparse.ArgumentParser class supports an instance-wide default, so we
can set that once instead of having every argument configured with the same
default always.

IPython/config/loader.py

@@ -1,373 +1,376 b''
 # coding: utf-8
 """A simple configuration system.
 
 Authors
 -------
 * Brian Granger
 * Fernando Perez
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2009  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
 #-----------------------------------------------------------------------------
 
 import __builtin__
 import os
 import sys
 
 from IPython.external import argparse
 from IPython.utils.genutils import filefind
 
 #-----------------------------------------------------------------------------
 # Exceptions
 #-----------------------------------------------------------------------------
 
 
 class ConfigError(Exception):
     pass
 
 
 class ConfigLoaderError(ConfigError):
     pass
 
 #-----------------------------------------------------------------------------
 # Argparse fix
 #-----------------------------------------------------------------------------
 # Unfortunately argparse by default prints help messages to stderr instead of
 # stdout.  This makes it annoying to capture long help screens at the command
 # line, since one must know how to pipe stderr, which many users don't know how
 # to do.  So we override the print_help method with one that defaults to
 # stdout and use our class instead.
 
 class ArgumentParser(argparse.ArgumentParser):
     """Simple argparse subclass that prints help to stdout by default."""
     
     def print_help(self, file=None):
         if file is None:
             file = sys.stdout
         return super(ArgumentParser, self).print_help(file)
     
     print_help.__doc__ = argparse.ArgumentParser.print_help.__doc__
     
 #-----------------------------------------------------------------------------
 # Config class for holding config information
 #-----------------------------------------------------------------------------
 
 
 class Config(dict):
     """An attribute based dict that can do smart merges."""
 
     def __init__(self, *args, **kwds):
         dict.__init__(self, *args, **kwds)
         # This sets self.__dict__ = self, but it has to be done this way
         # because we are also overriding __setattr__.
         dict.__setattr__(self, '__dict__', self)
 
     def _merge(self, other):
         to_update = {}
         for k, v in other.items():
             if not self.has_key(k):
                 to_update[k] = v
             else: # I have this key
                 if isinstance(v, Config):
                     # Recursively merge common sub Configs
                     self[k]._merge(v)
                 else:
                     # Plain updates for non-Configs
                     to_update[k] = v
 
         self.update(to_update)
 
     def _is_section_key(self, key):
         if key[0].upper()==key[0] and not key.startswith('_'):
             return True
         else:
             return False
 
     def has_key(self, key):
         if self._is_section_key(key):
             return True
         else:
             return dict.has_key(self, key)
 
     def _has_section(self, key):
         if self._is_section_key(key):
             if dict.has_key(self, key):
                 return True
         return False
 
     def copy(self):
         return type(self)(dict.copy(self))
 
     def __copy__(self):
         return self.copy()
 
     def __deepcopy__(self, memo):
         import copy
         return type(self)(copy.deepcopy(self.items()))
 
     def __getitem__(self, key):
         # Because we use this for an exec namespace, we need to delegate
         # the lookup of names in __builtin__ to itself.  This means
         # that you can't have section or attribute names that are 
         # builtins.
         try:
             return getattr(__builtin__, key)
         except AttributeError:
             pass
         if self._is_section_key(key):
             try:
                 return dict.__getitem__(self, key)
             except KeyError:
                 c = Config()
                 dict.__setitem__(self, key, c)
                 return c
         else:
             return dict.__getitem__(self, key)
 
     def __setitem__(self, key, value):
         # Don't allow names in __builtin__ to be modified.
         if hasattr(__builtin__, key):
             raise ConfigError('Config variable names cannot have the same name '
                               'as a Python builtin: %s' % key)
         if self._is_section_key(key):
             if not isinstance(value, Config):
                 raise ValueError('values whose keys begin with an uppercase '
                                  'char must be Config instances: %r, %r' % (key, value))
         else:
             dict.__setitem__(self, key, value)
 
     def __getattr__(self, key):
         try:
             return self.__getitem__(key)
         except KeyError, e:
             raise AttributeError(e)
 
     def __setattr__(self, key, value):
         try:
             self.__setitem__(key, value)
         except KeyError, e:
             raise AttributeError(e)
 
     def __delattr__(self, key):
         try:
             dict.__delitem__(self, key)
         except KeyError, e:
             raise AttributeError(e)
 
 
 #-----------------------------------------------------------------------------
 # Config loading classes
 #-----------------------------------------------------------------------------
 
 
 class ConfigLoader(object):
     """A object for loading configurations from just about anywhere.
     
     The resulting configuration is packaged as a :class:`Struct`.
     
     Notes
     -----
     A :class:`ConfigLoader` does one thing: load a config from a source 
     (file, command line arguments) and returns the data as a :class:`Struct`.
     There are lots of things that :class:`ConfigLoader` does not do.  It does
     not implement complex logic for finding config files.  It does not handle
     default values or merge multiple configs.  These things need to be 
     handled elsewhere.
     """
 
     def __init__(self):
         """A base class for config loaders.
         
         Examples
         --------
         
         >>> cl = ConfigLoader()
         >>> config = cl.load_config()
         >>> config
         {}
         """
         self.clear()
 
     def clear(self):
         self.config = Config()
 
     def load_config(self):
         """Load a config from somewhere, return a Struct.
         
         Usually, this will cause self.config to be set and then returned.
         """
         return self.config
 
 
 class FileConfigLoader(ConfigLoader):
     """A base class for file based configurations.
 
     As we add more file based config loaders, the common logic should go
     here.
     """
     pass
 
 
 class PyFileConfigLoader(FileConfigLoader):
     """A config loader for pure python files.
     
     This calls execfile on a plain python file and looks for attributes
     that are all caps.  These attribute are added to the config Struct.
     """
 
     def __init__(self, filename, path=None):
         """Build a config loader for a filename and path.
 
         Parameters
         ----------
         filename : str
             The file name of the config file.
         path : str, list, tuple
             The path to search for the config file on, or a sequence of
             paths to try in order.
         """
         super(PyFileConfigLoader, self).__init__()
         self.filename = filename
         self.path = path
         self.full_filename = ''
         self.data = None
 
     def load_config(self):
         """Load the config from a file and return it as a Struct."""
         self._find_file()
         self._read_file_as_dict()
         self._convert_to_config()
         return self.config
 
     def _find_file(self):
         """Try to find the file by searching the paths."""
         self.full_filename = filefind(self.filename, self.path)
 
     def _read_file_as_dict(self):
         """Load the config file into self.config, with recursive loading."""
         # This closure is made available in the namespace that is used
         # to exec the config file.  This allows users to call
         # load_subconfig('myconfig.py') to load config files recursively.
         # It needs to be a closure because it has references to self.path
         # and self.config.  The sub-config is loaded with the same path
         # as the parent, but it uses an empty config which is then merged
         # with the parents.
         def load_subconfig(fname):
             loader = PyFileConfigLoader(fname, self.path)
             try:
                 sub_config = loader.load_config()
             except IOError:
                 # Pass silently if the sub config is not there. This happens
                 # when a user us using a profile, but not the default config.
                 pass
             else:
                 self.config._merge(sub_config)
 
         # Again, this needs to be a closure and should be used in config
         # files to get the config being loaded.
         def get_config():
             return self.config
 
         namespace = dict(load_subconfig=load_subconfig, get_config=get_config)
         execfile(self.full_filename, namespace)
 
     def _convert_to_config(self):
         if self.data is None:
             ConfigLoaderError('self.data does not exist')
 
 
 class CommandLineConfigLoader(ConfigLoader):
     """A config loader for command line arguments.
 
     As we add more command line based loaders, the common logic should go
     here.
     """
 
 
 class __NoConfigDefault(object): pass
 NoConfigDefault = __NoConfigDefault()
 
 
 class ArgParseConfigLoader(CommandLineConfigLoader):
+    #: Global default for arguments (see argparse docs for details)
+    argument_default = NoConfigDefault
     
     def __init__(self, argv=None, arguments=(), *args, **kw):
         """Create a config loader for use with argparse.
 
         With the exception of ``argv`` and ``arguments``, other args and kwargs
         arguments here are passed onto the constructor of
         :class:`argparse.ArgumentParser`.
 
         Parameters
         ----------
 
         argv : optional, list
           If given, used to read command-line arguments from, otherwise
           sys.argv[1:] is used.
 
         arguments : optional, tuple
           Description of valid command-line arguments, to be called in sequence
           with parser.add_argument() to configure the parser.
         """
         super(CommandLineConfigLoader, self).__init__()
         if argv == None:
             argv = sys.argv[1:]
         self.argv = argv
         self.arguments = arguments
         self.args = args
-        self.kw = kw
+        kwargs = dict(argument_default=self.argument_default)
+        kwargs.update(kw)
+        self.kw = kwargs
 
     def load_config(self, args=None):
         """Parse command line arguments and return as a Struct.
 
         Parameters
         ----------
 
         args : optional, list
           If given, a list with the structure of sys.argv[1:] to parse arguments
           from.  If not given, the instance's self.argv attribute (given at
           construction time) is used."""
         
         if args is None:
             args = self.argv
         self._create_parser()
         self._parse_args(args)
         self._convert_to_config()
         return self.config
 
     def get_extra_args(self):
         if hasattr(self, 'extra_args'):
             return self.extra_args
         else:
             return []
 
     def _create_parser(self):
         self.parser = ArgumentParser(*self.args, **self.kw)
         self._add_arguments()
         self._add_other_arguments()
 
-    def _add_other_arguments(self):
-        pass
-
     def _add_arguments(self):
         for argument in self.arguments:
-            argument[1].setdefault('default', NoConfigDefault)
             self.parser.add_argument(*argument[0],**argument[1])
 
+    def _add_other_arguments(self):
+        pass
+
     def _parse_args(self, args):
         """self.parser->self.parsed_data""" 
         self.parsed_data, self.extra_args = self.parser.parse_known_args(args)
 
     def _convert_to_config(self):
         """self.parsed_data->self.config"""
         for k, v in vars(self.parsed_data).items():
             if v is not NoConfigDefault:
                 exec_str = 'self.config.' + k + '= v'
                 exec exec_str in locals(), globals()

IPython/core/application.py

@@ -1,422 +1,417 b''
 #!/usr/bin/env python
 # encoding: utf-8
 """
 An application for IPython.
 
 All top-level applications should use the classes in this module for
 handling configuration and creating componenets.
 
 The job of an :class:`Application` is to create the master configuration 
 object and then create the components, passing the config to them.
 
 Authors:
 
 * Brian Granger
 * Fernando Perez
 
 Notes
 -----
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2009  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
 #-----------------------------------------------------------------------------
 
 import logging
 import os
 import sys
 
 from IPython.core import release, crashhandler
 from IPython.utils.genutils import get_ipython_dir, get_ipython_package_dir
 from IPython.config.loader import (
     PyFileConfigLoader,
     ArgParseConfigLoader,
     Config,
-    NoConfigDefault
 )
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
 class ApplicationError(Exception):
     pass
 
 
 app_cl_args = (
     (('--ipython-dir', ), dict(
         dest='Global.ipython_dir',type=unicode,
         help=
         """Set to override default location of the IPython directory
         IPYTHON_DIR, stored as Global.ipython_dir.  This can also be specified
         through the environment variable IPYTHON_DIR.""",
-        default=NoConfigDefault,
         metavar='Global.ipython_dir') ),
     (('-p', '--profile',), dict(
         dest='Global.profile',type=unicode,
         help=
         """The string name of the ipython profile to be used.  Assume that your
         config file is ipython_config-<name>.py (looks in current dir first,
         then in IPYTHON_DIR). This is a quick way to keep and load multiple
         config files for different tasks, especially if include your basic one
         in your more specialized ones.  You can keep a basic
         IPYTHON_DIR/ipython_config.py file and then have other 'profiles' which
         include this one and load extra things for particular tasks.""",
-        default=NoConfigDefault,
         metavar='Global.profile') ),
     (('--log-level',), dict(
         dest="Global.log_level",type=int,
         help='Set the log level (0,10,20,30,40,50).  Default is 30.',
-        default=NoConfigDefault,
         metavar='Global.log_level')),
     (('--config-file',), dict(
         dest='Global.config_file',type=unicode,
         help=
         """Set the config file name to override default.  Normally IPython
         loads ipython_config.py (from current directory) or
         IPYTHON_DIR/ipython_config.py.  If the loading of your config file
         fails, IPython starts with a bare bones configuration (no modules
         loaded at all).""",
-        default=NoConfigDefault,
         metavar='Global.config_file')),
     )
 
 class Application(object):
     """Load a config, construct components and set them running."""
 
     name = u'ipython'
     description = 'IPython: an enhanced interactive Python shell.'
     #: usage message printed by argparse. If None, auto-generate
     usage = None
     config_file_name = u'ipython_config.py'
     # Track the default and actual separately because some messages are
     # only printed if we aren't using the default.
     default_config_file_name = config_file_name
     default_log_level = logging.WARN
     # Set by --profile option
     profile_name = None
     #: User's ipython directory, typically ~/.ipython/
     ipython_dir = None
     #: A reference to the argv to be used (typically ends up being sys.argv[1:])
     argv = None
     #: Default command line arguments.  Subclasses should create a new tuple
     #: that *includes* these.
     cl_arguments = app_cl_args
 
     # Private attributes
     _exiting = False
     _initialized = False
 
     # Class choices for things that will be instantiated at runtime.
     _CrashHandler = crashhandler.CrashHandler
 
     def __init__(self, argv=None):
         self.argv = sys.argv[1:] if argv is None else argv
         self.init_logger()
 
     def init_logger(self):
         self.log = logging.getLogger(self.__class__.__name__)
         # This is used as the default until the command line arguments are read.
         self.log.setLevel(self.default_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 _set_log_level(self, level):
         self.log.setLevel(level)
 
     def _get_log_level(self):
         return self.log.level
 
     log_level = property(_get_log_level, _set_log_level)
 
     def initialize(self):
         """Start the application."""
         
         if self._initialized:
             return
 
         # The first part is protected with an 'attempt' wrapper, that will log
         # failures with the basic system traceback machinery.  Once our crash
         # handler is in place, we can let any subsequent exception propagate,
         # as our handler will log it with much better detail than the default.
         self.attempt(self.create_crash_handler)
         self.create_default_config()
         self.log_default_config()
         self.set_default_config_log_level()
         self.pre_load_command_line_config()
         self.load_command_line_config()
         self.set_command_line_config_log_level()
         self.post_load_command_line_config()
         self.log_command_line_config()
         self.find_ipython_dir()
         self.find_resources()
         self.find_config_file_name()
         self.find_config_file_paths()
         self.pre_load_file_config()
         self.load_file_config()
         self.set_file_config_log_level()
         self.post_load_file_config()
         self.log_file_config()
         self.merge_configs()
         self.log_master_config()
         self.pre_construct()
         self.construct()
         self.post_construct()
         self._initialized = True
 
     def start(self):
         self.initialize()
         self.start_app()
 
     #-------------------------------------------------------------------------
     # Various stages of Application creation
     #-------------------------------------------------------------------------
 
     def create_crash_handler(self):
         """Create a crash handler, typically setting sys.excepthook to it."""
         self.crash_handler = self._CrashHandler(self, self.name)
         sys.excepthook = self.crash_handler
 
     def create_default_config(self):
         """Create defaults that can't be set elsewhere.
 
         For the most part, we try to set default in the class attributes
         of Components.  But, defaults the top-level Application (which is
         not a HasTraitlets or Component) are not set in this way.  Instead
         we set them here.  The Global section is for variables like this that
         don't belong to a particular component.
         """
         c = Config()
         c.Global.ipython_dir = get_ipython_dir()
         c.Global.log_level = self.log_level
         self.default_config = c
 
     def log_default_config(self):
         self.log.debug('Default config loaded:')
         self.log.debug(repr(self.default_config))
 
     def set_default_config_log_level(self):
         try:
             self.log_level = self.default_config.Global.log_level
         except AttributeError:
             # Fallback to the default_log_level class attribute
             pass
 
     def create_command_line_config(self):
         """Create and return a command line config loader."""
         return ArgParseConfigLoader(self.argv, self.cl_arguments,
                                     description=self.description, 
                                     version=release.version,
                                     usage=self.usage,
                                     )
 
     def pre_load_command_line_config(self):
         """Do actions just before loading the command line config."""
         pass
 
     def load_command_line_config(self):
         """Load the command line config."""
         loader = self.create_command_line_config()
         self.command_line_config = loader.load_config()
         self.extra_args = loader.get_extra_args()
 
     def set_command_line_config_log_level(self):
         try:
             self.log_level = self.command_line_config.Global.log_level
         except AttributeError:
             pass
 
     def post_load_command_line_config(self):
         """Do actions just after loading the command line config."""
         pass
 
     def log_command_line_config(self):
         self.log.debug("Command line config loaded:")
         self.log.debug(repr(self.command_line_config))
 
     def find_ipython_dir(self):
         """Set the IPython directory.
 
         This sets ``self.ipython_dir``, but the actual value that is passed to
         the application is kept in either ``self.default_config`` or
         ``self.command_line_config``.  This also adds ``self.ipython_dir`` to
         ``sys.path`` so config files there can be referenced by other config
         files.
         """
 
         try:
             self.ipython_dir = self.command_line_config.Global.ipython_dir
         except AttributeError:
             self.ipython_dir = self.default_config.Global.ipython_dir
         sys.path.append(os.path.abspath(self.ipython_dir))
         if not os.path.isdir(self.ipython_dir):
             os.makedirs(self.ipython_dir, mode=0777)
         self.log.debug("IPYTHON_DIR set to: %s" % self.ipython_dir)
 
     def find_resources(self):
         """Find other resources that need to be in place.
 
         Things like cluster directories need to be in place to find the
         config file.  These happen right after the IPython directory has
         been set.
         """
         pass
 
     def find_config_file_name(self):
         """Find the config file name for this application.
 
         This must set ``self.config_file_name`` to the filename of the
         config file to use (just the filename). The search paths for the
         config file are set in :meth:`find_config_file_paths` and then passed
         to the config file loader where they are resolved to an absolute path.
 
         If a profile has been set at the command line, this will resolve it.
         """
 
         try:
             self.config_file_name = self.command_line_config.Global.config_file
         except AttributeError:
             pass
 
         try:
             self.profile_name = self.command_line_config.Global.profile
         except AttributeError:
             pass
         else:
             name_parts = self.config_file_name.split('.')
             name_parts.insert(1, u'_' + self.profile_name + u'.')
             self.config_file_name = ''.join(name_parts)
 
     def find_config_file_paths(self):
         """Set the search paths for resolving the config file.
 
         This must set ``self.config_file_paths`` to a sequence of search
         paths to pass to the config file loader.
         """
         # Include our own profiles directory last, so that users can still find
         # our shipped copies of builtin profiles even if they don't have them
         # in their local ipython directory.
         prof_dir = os.path.join(get_ipython_package_dir(), 'config', 'profile')
         self.config_file_paths = (os.getcwd(), self.ipython_dir, prof_dir)
 
     def pre_load_file_config(self):
         """Do actions before the config file is loaded."""
         pass
 
     def load_file_config(self):
         """Load the config file.
         
         This tries to load the config file from disk.  If successful, the
         ``CONFIG_FILE`` config variable is set to the resolved config file
         location.  If not successful, an empty config is used.
         """
         self.log.debug("Attempting to load config file: %s" %
                        self.config_file_name)
         loader = PyFileConfigLoader(self.config_file_name,
                                     path=self.config_file_paths)
         try:
             self.file_config = loader.load_config()
             self.file_config.Global.config_file = loader.full_filename
         except IOError:
             # Only warn if the default config file was NOT being used.
             if not self.config_file_name==self.default_config_file_name:
                 self.log.warn("Config file not found, skipping: %s" %
                                self.config_file_name, exc_info=True)
             self.file_config = Config()
         except:
             self.log.warn("Error loading config file: %s" %
                           self.config_file_name, exc_info=True)
             self.file_config = Config()
 
     def set_file_config_log_level(self):
         # We need to keeep self.log_level updated.  But we only use the value
         # of the file_config if a value was not specified at the command
         # line, because the command line overrides everything.
         if not hasattr(self.command_line_config.Global, 'log_level'):
             try:
                 self.log_level = self.file_config.Global.log_level
             except AttributeError:
                 pass # Use existing value
 
     def post_load_file_config(self):
         """Do actions after the config file is loaded."""
         pass
 
     def log_file_config(self):
         if hasattr(self.file_config.Global, 'config_file'):
             self.log.debug("Config file loaded: %s" %
                            self.file_config.Global.config_file)
             self.log.debug(repr(self.file_config))
 
     def merge_configs(self):
         """Merge the default, command line and file config objects."""
         config = Config()
         config._merge(self.default_config)
         config._merge(self.file_config)
         config._merge(self.command_line_config)
         self.master_config = config
 
     def log_master_config(self):
         self.log.debug("Master config created:")
         self.log.debug(repr(self.master_config))
 
     def pre_construct(self):
         """Do actions after the config has been built, but before construct."""
         pass
 
     def construct(self):
         """Construct the main components that make up this app."""
         self.log.debug("Constructing components for application")
 
     def post_construct(self):
         """Do actions after construct, but before starting the app."""
         pass
 
     def start_app(self):
         """Actually start the app."""
         self.log.debug("Starting application")
 
     #-------------------------------------------------------------------------
     # Utility methods
     #-------------------------------------------------------------------------
 
     def abort(self):
         """Abort the starting of the application."""
         if self._exiting:
             pass
         else:
             self.log.critical("Aborting application: %s" % self.name, exc_info=True)
             self._exiting = True
             sys.exit(1)
 
     def exit(self, exit_status=0):
         if self._exiting:
             pass
         else:
             self.log.debug("Exiting application: %s" % self.name)
             self._exiting = True
             sys.exit(exit_status)
 
     def attempt(self, func, action='abort'):
         try:
             func()
         except SystemExit:
             raise
         except:
             if action == 'abort':
                 self.log.critical("Aborting application: %s" % self.name,
                                   exc_info=True)
                 self.abort()
                 raise
             elif action == 'exit':
                 self.exit(0)
 

IPython/core/ipapp.py

@@ -1,674 +1,643 b''
 #!/usr/bin/env python
 # encoding: utf-8
 """
 The :class:`~IPython.core.application.Application` object for the command
 line :command:`ipython` program.
 
 Authors
 -------
 
 * Brian Granger
 * Fernando Perez
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2010  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 __future__ import absolute_import
 
 import logging
 import os
 import sys
 
 from IPython.core import crashhandler
-from IPython.core import release
 from IPython.core.application import Application
-from IPython.core.error import UsageError
 from IPython.core.iplib import InteractiveShell
-from IPython.core.pylabtools import pylab_activate
 from IPython.config.loader import (
-    NoConfigDefault, 
     Config,
-    PyFileConfigLoader
+    PyFileConfigLoader,
+#    NoConfigDefault,
 )
 from IPython.lib import inputhook
 from IPython.utils.genutils import filefind, get_ipython_dir
 from . import usage
 
 #-----------------------------------------------------------------------------
 # Globals, utilities and helpers
 #-----------------------------------------------------------------------------
 
 default_config_file_name = u'ipython_config.py'
 
 cl_args = (
     (('--autocall',), dict(
-        type=int, dest='InteractiveShell.autocall', default=NoConfigDefault,
+        type=int, dest='InteractiveShell.autocall',
         help=
         """Make IPython automatically call any callable object even if you
         didn't type explicit parentheses. For example, 'str 43' becomes
         'str(43)' automatically.  The value can be '0' to disable the feature,
         '1' for 'smart' autocall, where it is not applied if there are no more
         arguments on the line, and '2' for 'full' autocall, where all callable
         objects are automatically called (even if no arguments are present).
         The default is '1'.""",
         metavar='InteractiveShell.autocall')
     ),
     (('--autoindent',), dict(
         action='store_true', dest='InteractiveShell.autoindent',
-        default=NoConfigDefault, 
         help='Turn on autoindenting.')
     ),
     (('--no-autoindent',), dict(
         action='store_false', dest='InteractiveShell.autoindent',
-        default=NoConfigDefault, 
         help='Turn off autoindenting.')
     ),
     (('--automagic',), dict(
         action='store_true', dest='InteractiveShell.automagic',
-        default=NoConfigDefault, 
         help='Turn on the auto calling of magic commands.'
         'Type %%magic at  the  IPython  prompt  for  more information.')
      ),
     (('--no-automagic',), dict(
         action='store_false', dest='InteractiveShell.automagic',
-        default=NoConfigDefault, 
         help='Turn off the auto calling of magic commands.')
     ),
     (('--autoedit-syntax',), dict(
         action='store_true', dest='InteractiveShell.autoedit_syntax',
-        default=NoConfigDefault, 
         help='Turn on auto editing of files with syntax errors.')
     ),
     (('--no-autoedit-syntax',), dict(
         action='store_false', dest='InteractiveShell.autoedit_syntax',
-        default=NoConfigDefault, 
         help='Turn off auto editing of files with syntax errors.')
     ),
     (('--banner',), dict(
         action='store_true', dest='Global.display_banner',
-        default=NoConfigDefault, 
         help='Display a banner upon starting IPython.')
     ),
     (('--no-banner',), dict(
         action='store_false', dest='Global.display_banner',
-        default=NoConfigDefault, 
         help="Don't display a banner upon starting IPython.")
     ),
     (('--cache-size',), dict(
-        type=int, dest='InteractiveShell.cache_size', default=NoConfigDefault,
+        type=int, dest='InteractiveShell.cache_size',
         help=
         """Set the size of the output cache.  The default is 1000, you can
         change it permanently in your config file.  Setting it to 0 completely
         disables the caching system, and the minimum value accepted is 20 (if
         you provide a value less than 20, it is reset to 0 and a warning is
         issued).  This limit is defined because otherwise you'll spend more
         time re-flushing a too small cache than working.
         """,
         metavar='InteractiveShell.cache_size')
     ),
     (('--classic',), dict(
-        action='store_true', dest='Global.classic', default=NoConfigDefault,
+        action='store_true', dest='Global.classic',
         help="Gives IPython a similar feel to the classic Python prompt.")
     ),
     (('--colors',), dict(
-        type=str, dest='InteractiveShell.colors', default=NoConfigDefault,
+        type=str, dest='InteractiveShell.colors',
         help="Set the color scheme (NoColor, Linux, and LightBG).",
         metavar='InteractiveShell.colors')
     ),
     (('--color-info',), dict(
         action='store_true', dest='InteractiveShell.color_info',
-        default=NoConfigDefault, 
         help=
         """IPython can display information about objects via a set of func-
         tions, and optionally can use colors for this, syntax highlighting
         source code and various other elements.  However, because this
         information is passed through a pager (like 'less') and many pagers get
         confused with color codes, this option is off by default.  You can test
         it and turn it on permanently in your ipython_config.py file if it
         works for you.  Test it and turn it on permanently if it works with
         your system.  The magic function %%color_info allows you to toggle this
         inter- actively for testing."""
         )
     ),
     (('--no-color-info',), dict(
         action='store_false', dest='InteractiveShell.color_info',
-        default=NoConfigDefault, 
         help="Disable using colors for info related things.")
     ),
     (('--confirm-exit',), dict(
         action='store_true', dest='InteractiveShell.confirm_exit',
-        default=NoConfigDefault, 
         help=
         """Set to confirm when you try to exit IPython with an EOF (Control-D
         in Unix, Control-Z/Enter in Windows). By typing 'exit', 'quit' or
         '%%Exit', you can force a direct exit without any confirmation.
         """
         )
     ),
     (('--no-confirm-exit',), dict(
         action='store_false', dest='InteractiveShell.confirm_exit',
-        default=NoConfigDefault, 
         help="Don't prompt the user when exiting.")
     ),
     (('--deep-reload',), dict(
         action='store_true', dest='InteractiveShell.deep_reload',
-        default=NoConfigDefault, 
         help=
         """Enable deep (recursive) reloading by default. IPython can use the
         deep_reload module which reloads changes in modules recursively (it
         replaces the reload() function, so you don't need to change anything to
         use it). deep_reload() forces a full reload of modules whose code may
         have changed, which the default reload() function does not.  When
         deep_reload is off, IPython will use the normal reload(), but
         deep_reload will still be available as dreload(). This fea- ture is off
         by default [which means that you have both normal reload() and
         dreload()].""")
     ),
     (('--no-deep-reload',), dict(
         action='store_false', dest='InteractiveShell.deep_reload',
-        default=NoConfigDefault, 
         help="Disable deep (recursive) reloading by default.")
     ),
     (('--editor',), dict(
-        type=str, dest='InteractiveShell.editor', default=NoConfigDefault,
+        type=str, dest='InteractiveShell.editor',
         help="Set the editor used by IPython (default to $EDITOR/vi/notepad).",
         metavar='InteractiveShell.editor')
     ),
     (('--log','-l'), dict(
         action='store_true', dest='InteractiveShell.logstart',
-        default=NoConfigDefault, 
         help="Start logging to the default log file (./ipython_log.py).")
     ),
     (('--logfile','-lf'), dict(
-        type=unicode, dest='InteractiveShell.logfile', default=NoConfigDefault,
+        type=unicode, dest='InteractiveShell.logfile',
         help="Start logging to logfile with this name.",
         metavar='InteractiveShell.logfile')
     ),
     (('--log-append','-la'), dict(
         type=unicode, dest='InteractiveShell.logappend',
-        default=NoConfigDefault, 
         help="Start logging to the given file in append mode.",
         metavar='InteractiveShell.logfile')
     ),
     (('--pdb',), dict(
         action='store_true', dest='InteractiveShell.pdb',
-        default=NoConfigDefault, 
         help="Enable auto calling the pdb debugger after every exception.")
     ),
     (('--no-pdb',), dict(
         action='store_false', dest='InteractiveShell.pdb',
-        default=NoConfigDefault, 
         help="Disable auto calling the pdb debugger after every exception.")
     ),
     (('--pprint',), dict(
         action='store_true', dest='InteractiveShell.pprint',
-        default=NoConfigDefault, 
         help="Enable auto pretty printing of results.")
     ),
     (('--no-pprint',), dict(
         action='store_false', dest='InteractiveShell.pprint',
-        default=NoConfigDefault, 
         help="Disable auto auto pretty printing of results.")
     ),
     (('--prompt-in1','-pi1'), dict(
-        type=str, dest='InteractiveShell.prompt_in1', default=NoConfigDefault,
+        type=str, dest='InteractiveShell.prompt_in1',
         help=
         """Set the main input prompt ('In [\#]: ').  Note that if you are using
         numbered prompts, the number is represented with a '\#' in the string.
         Don't forget to quote strings with spaces embedded in them. Most
         bash-like escapes can be used to customize IPython's prompts, as well
         as a few additional ones which are IPython-spe- cific.  All valid
         prompt escapes are described in detail in the Customization section of
         the IPython manual.""",
         metavar='InteractiveShell.prompt_in1')
     ),
     (('--prompt-in2','-pi2'), dict(
-        type=str, dest='InteractiveShell.prompt_in2', default=NoConfigDefault,
+        type=str, dest='InteractiveShell.prompt_in2',
         help=
         """Set the secondary input prompt (' .\D.: ').  Similar to the previous
         option, but used for the continuation prompts. The special sequence
         '\D' is similar to '\#', but with all digits replaced by dots (so you
         can have your continuation prompt aligned with your input prompt).
         Default: ' .\D.: ' (note three spaces at the start for alignment with
         'In [\#]')""",
         metavar='InteractiveShell.prompt_in2')
     ),
     (('--prompt-out','-po'), dict(
-        type=str, dest='InteractiveShell.prompt_out', default=NoConfigDefault,
+        type=str, dest='InteractiveShell.prompt_out',
         help="Set the output prompt ('Out[\#]:')",
         metavar='InteractiveShell.prompt_out')
     ),
     (('--quick',), dict(
-        action='store_true', dest='Global.quick', default=NoConfigDefault,
+        action='store_true', dest='Global.quick',
         help="Enable quick startup with no config files.")
     ),
     (('--readline',), dict(
         action='store_true', dest='InteractiveShell.readline_use',
-        default=NoConfigDefault, 
         help="Enable readline for command line usage.")
     ),
     (('--no-readline',), dict(
         action='store_false', dest='InteractiveShell.readline_use',
-        default=NoConfigDefault, 
         help="Disable readline for command line usage.")
     ),
     (('--screen-length','-sl'), dict(
         type=int, dest='InteractiveShell.screen_length',
-        default=NoConfigDefault, 
         help=
         """Number of lines of your screen, used to control printing of very
         long strings.  Strings longer than this number of lines will be sent
         through a pager instead of directly printed.  The default value for
         this is 0, which means IPython will auto-detect your screen size every
         time it needs to print certain potentially long strings (this doesn't
         change the behavior of the 'print' keyword, it's only triggered
         internally). If for some reason this isn't working well (it needs
         curses support), specify it yourself. Otherwise don't change the
         default.""",
         metavar='InteractiveShell.screen_length')
     ),
     (('--separate-in','-si'), dict(
-        type=str, dest='InteractiveShell.separate_in', default=NoConfigDefault,
+        type=str, dest='InteractiveShell.separate_in',
         help="Separator before input prompts.  Default '\\n'.",
         metavar='InteractiveShell.separate_in')
     ),
     (('--separate-out','-so'), dict(
         type=str, dest='InteractiveShell.separate_out',
-        default=NoConfigDefault, 
         help="Separator before output prompts.  Default 0 (nothing).",
         metavar='InteractiveShell.separate_out')
     ),
     (('--separate-out2','-so2'), dict(
         type=str, dest='InteractiveShell.separate_out2',
-        default=NoConfigDefault, 
         help="Separator after output prompts.  Default 0 (nonight).",
         metavar='InteractiveShell.separate_out2')
     ),
     (('-no-sep',), dict(
-        action='store_true', dest='Global.nosep', default=NoConfigDefault,
+        action='store_true', dest='Global.nosep',
         help="Eliminate all spacing between prompts.")
     ),
     (('--term-title',), dict(
         action='store_true', dest='InteractiveShell.term_title',
-        default=NoConfigDefault, 
         help="Enable auto setting the terminal title.")
     ),
     (('--no-term-title',), dict(
         action='store_false', dest='InteractiveShell.term_title',
-        default=NoConfigDefault, 
         help="Disable auto setting the terminal title.")
     ),
     (('--xmode',), dict(
-        type=str, dest='InteractiveShell.xmode', default=NoConfigDefault,
+        type=str, dest='InteractiveShell.xmode',
         help=
         """Exception reporting mode ('Plain','Context','Verbose').  Plain:
         similar to python's normal traceback printing.  Context: prints 5 lines
         of context source code around each line in the traceback.  Verbose:
         similar to Context, but additionally prints the variables currently
         visible where the exception happened (shortening their strings if too
         long).  This can potentially be very slow, if you happen to have a huge
         data structure whose string representation is complex to compute.
         Your computer may appear to freeze for a while with cpu usage at 100%%.
         If this occurs, you can cancel the traceback with Ctrl-C (maybe hitting
         it more than once).
         """,
         metavar='InteractiveShell.xmode')
     ),
     (('--ext',), dict(
-        type=str, dest='Global.extra_extension', default=NoConfigDefault,
+        type=str, dest='Global.extra_extension',
         help="The dotted module name of an IPython extension to load.",
         metavar='Global.extra_extension')
     ),
     (('-c',), dict(
-        type=str, dest='Global.code_to_run', default=NoConfigDefault,
+        type=str, dest='Global.code_to_run',
         help="Execute the given command string.",
         metavar='Global.code_to_run')
     ),
     (('-i',), dict(
         action='store_true', dest='Global.force_interact',
-        default=NoConfigDefault, 
         help=
         "If running code from the command line, become interactive afterwards."
         )
     ),
 
     # Options to start with GUI control enabled from the beginning
     (('--gui',), dict(
-        type=str, dest='Global.gui', default=NoConfigDefault,
+        type=str, dest='Global.gui',
         help="Enable GUI event loop integration ('qt', 'wx', 'gtk').",
         metavar='gui-mode')
     ),
 
     (('--pylab','-pylab'), dict(
-        type=str, dest='Global.pylab', default=NoConfigDefault,
+        type=str, dest='Global.pylab',
         nargs='?', const='auto', metavar='gui-mode',
         help="Pre-load matplotlib and numpy for interactive use. "+
         "If no value is given, the gui backend is matplotlib's, else use "+
         "one of:  ['tk', 'qt', 'wx', 'gtk'].")
     ),
     
     # Legacy GUI options.  Leave them in for backwards compatibility, but the
     # 'thread' names are really a misnomer now.
     (('--wthread','-wthread'), dict(
-        action='store_true', dest='Global.wthread', default=NoConfigDefault,
+        action='store_true', dest='Global.wthread',
         help="Enable wxPython event loop integration "+
              "(DEPRECATED, use --gui wx)")
     ),
     (('--q4thread','--qthread','-q4thread','-qthread'), dict(
-        action='store_true', dest='Global.q4thread', default=NoConfigDefault,
+        action='store_true', dest='Global.q4thread',
         help="Enable Qt4 event loop integration. Qt3 is no longer supported. "+
              "(DEPRECATED, use --gui qt)")
     ),
     (('--gthread','-gthread'), dict(
-        action='store_true', dest='Global.gthread', default=NoConfigDefault,
+        action='store_true', dest='Global.gthread',
         help="Enable GTK event loop integration. "+
              "(DEPRECATED, use --gui gtk)")
     ),
 )
 
 #-----------------------------------------------------------------------------
 # Main classes and functions
 #-----------------------------------------------------------------------------
 
 class IPythonApp(Application):
     name = u'ipython'
     #: argparse formats better the 'usage' than the 'description' field
     description = None
     #: usage message printed by argparse. If None, auto-generate
     usage = usage.cl_usage
 
     config_file_name = default_config_file_name
 
     cl_arguments = Application.cl_arguments + cl_args
 
     # Private and configuration attributes
     _CrashHandler = crashhandler.IPythonCrashHandler
     
     def __init__(self, argv=None, **shell_params):
         """Create a new IPythonApp.
 
         Parameters
         ----------
         argv : optional, list
           If given, used as the command-line argv environment to read arguments
           from.
 
         shell_params : optional, dict
           All other keywords are passed to the :class:`iplib.InteractiveShell`
           constructor. 
         """
         super(IPythonApp, self).__init__(argv)
         self.shell_params = shell_params
 
     def create_default_config(self):
         super(IPythonApp, self).create_default_config()
         # Eliminate multiple lookups
         Global = self.default_config.Global
 
         # Set all default values
         Global.display_banner = True
         
         # If the -c flag is given or a file is given to run at the cmd line
         # like "ipython foo.py", normally we exit without starting the main
         # loop.  The force_interact config variable allows a user to override
         # this and interact.  It is also set by the -i cmd line flag, just
         # like Python.
         Global.force_interact = False
 
         # By default always interact by starting the IPython mainloop.
         Global.interact = True
 
         # No GUI integration by default
         Global.gui = False
         # Pylab off by default
         Global.pylab = False
 
         # Deprecated versions of gui support that used threading, we support
         # them just for bacwards compatibility as an alternate spelling for
         # '--gui X'
         Global.qthread = False
         Global.q4thread = False
         Global.wthread = False
         Global.gthread = False
 
     def load_file_config(self):
         if hasattr(self.command_line_config.Global, 'quick'):
             if self.command_line_config.Global.quick:
                 self.file_config = Config()
                 return
         super(IPythonApp, self).load_file_config()
 
     def post_load_file_config(self):
         if hasattr(self.command_line_config.Global, 'extra_extension'):
             if not hasattr(self.file_config.Global, 'extensions'):
                 self.file_config.Global.extensions = []
             self.file_config.Global.extensions.append(
                 self.command_line_config.Global.extra_extension)
             del self.command_line_config.Global.extra_extension
 
     def pre_construct(self):
         config = self.master_config
 
         if hasattr(config.Global, 'classic'):
             if config.Global.classic:
                 config.InteractiveShell.cache_size = 0
                 config.InteractiveShell.pprint = 0
                 config.InteractiveShell.prompt_in1 = '>>> '
                 config.InteractiveShell.prompt_in2 = '... '
                 config.InteractiveShell.prompt_out = ''
                 config.InteractiveShell.separate_in = \
                     config.InteractiveShell.separate_out = \
                     config.InteractiveShell.separate_out2 = ''
                 config.InteractiveShell.colors = 'NoColor'
                 config.InteractiveShell.xmode = 'Plain'
 
         if hasattr(config.Global, 'nosep'):
             if config.Global.nosep:
                 config.InteractiveShell.separate_in = \
                 config.InteractiveShell.separate_out = \
                 config.InteractiveShell.separate_out2 = ''
 
         # if there is code of files to run from the cmd line, don't interact
         # unless the -i flag (Global.force_interact) is true.
         code_to_run = config.Global.get('code_to_run','')
         file_to_run = False
         if len(self.extra_args)>=1:
             if self.extra_args[0]:
                 file_to_run = True
         if file_to_run or code_to_run:
             if not config.Global.force_interact:
                 config.Global.interact = False
 
     def construct(self):
         # I am a little hesitant to put these into InteractiveShell itself.
         # But that might be the place for them
         sys.path.insert(0, '')
 
         # Create an InteractiveShell instance
         self.shell = InteractiveShell(None, self.master_config,
                                       **self.shell_params )
 
     def post_construct(self):
         """Do actions after construct, but before starting the app."""
         config = self.master_config
         
         # shell.display_banner should always be False for the terminal 
         # based app, because we call shell.show_banner() by hand below
         # so the banner shows *before* all extension loading stuff.
         self.shell.display_banner = False
 
         if config.Global.display_banner and \
             config.Global.interact:
             self.shell.show_banner()
 
         # Make sure there is a space below the banner.
         if self.log_level <= logging.INFO: print
 
         # Now a variety of things that happen after the banner is printed.
         self._enable_gui_pylab()
         self._load_extensions()
         self._run_exec_lines()
         self._run_exec_files()
         self._run_cmd_line_code()
         self._configure_xmode()
 
     def _enable_gui_pylab(self):
         """Enable GUI event loop integration, taking pylab into account."""
         Global = self.master_config.Global
 
         # Select which gui to use
         if Global.gui:
             gui = Global.gui
         # The following are deprecated, but there's likely to be a lot of use
         # of this form out there, so we might as well support it for now.  But
         # the --gui option above takes precedence.
         elif Global.wthread:
             gui = inputhook.GUI_WX
         elif Global.qthread:
             gui = inputhook.GUI_QT
         elif Global.gthread:
             gui = inputhook.GUI_GTK
         else:
             gui = None
 
         # Using --pylab will also require gui activation, though which toolkit
         # to use may be chosen automatically based on mpl configuration.
         if Global.pylab:
             activate = self.shell.enable_pylab
             if Global.pylab == 'auto':
                 gui = None
             else:
                 gui = Global.pylab
         else:
             # Enable only GUI integration, no pylab
             activate = inputhook.enable_gui
 
         if gui or Global.pylab:
             try:
                 self.log.info("Enabling GUI event loop integration, "
                               "toolkit=%s, pylab=%s" % (gui, Global.pylab) )
                 activate(gui)
             except:
                 self.log.warn("Error in enabling GUI event loop integration:")
                 self.shell.showtraceback()
 
     def _load_extensions(self):
         """Load all IPython extensions in Global.extensions.
 
         This uses the :meth:`InteractiveShell.load_extensions` to load all
         the extensions listed in ``self.master_config.Global.extensions``.
         """
         try:
             if hasattr(self.master_config.Global, 'extensions'):
                 self.log.debug("Loading IPython extensions...")
                 extensions = self.master_config.Global.extensions
                 for ext in extensions:
                     try:
                         self.log.info("Loading IPython extension: %s" % ext)                        
                         self.shell.load_extension(ext)
                     except:
                         self.log.warn("Error in loading extension: %s" % ext)
                         self.shell.showtraceback()
         except:
             self.log.warn("Unknown error in loading extensions:")
             self.shell.showtraceback()
 
     def _run_exec_lines(self):
         """Run lines of code in Global.exec_lines in the user's namespace."""
         try:
             if hasattr(self.master_config.Global, 'exec_lines'):
                 self.log.debug("Running code from Global.exec_lines...")
                 exec_lines = self.master_config.Global.exec_lines
                 for line in exec_lines:
                     try:
                         self.log.info("Running code in user namespace: %s" % line)
                         self.shell.runlines(line)
                     except:
                         self.log.warn("Error in executing line in user namespace: %s" % line)
                         self.shell.showtraceback()
         except:
             self.log.warn("Unknown error in handling Global.exec_lines:")
             self.shell.showtraceback()
 
     def _exec_file(self, fname):
         full_filename = filefind(fname, [u'.', self.ipython_dir])
         if os.path.isfile(full_filename):
             if full_filename.endswith(u'.py'):
                 self.log.info("Running file in user namespace: %s" % full_filename)
                 self.shell.safe_execfile(full_filename, self.shell.user_ns)
             elif full_filename.endswith('.ipy'):
                 self.log.info("Running file in user namespace: %s" % full_filename)
                 self.shell.safe_execfile_ipy(full_filename)
             else:
                 self.log.warn("File does not have a .py or .ipy extension: <%s>" % full_filename)
 
     def _run_exec_files(self):
         try:
             if hasattr(self.master_config.Global, 'exec_files'):
                 self.log.debug("Running files in Global.exec_files...")
                 exec_files = self.master_config.Global.exec_files
                 for fname in exec_files:
                     self._exec_file(fname)
         except:
             self.log.warn("Unknown error in handling Global.exec_files:")
             self.shell.showtraceback()
 
     def _run_cmd_line_code(self):
         if hasattr(self.master_config.Global, 'code_to_run'):
             line = self.master_config.Global.code_to_run
             try:
                 self.log.info("Running code given at command line (-c): %s" % line)
                 self.shell.runlines(line)
             except:
                 self.log.warn("Error in executing line in user namespace: %s" % line)
                 self.shell.showtraceback()
             return
         # Like Python itself, ignore the second if the first of these is present
         try:
             fname = self.extra_args[0]
         except:
             pass
         else:
             try:
                 self._exec_file(fname)
             except:
                 self.log.warn("Error in executing file in user namespace: %s" % fname)
                 self.shell.showtraceback()
 
     def _configure_xmode(self):
         # XXX - shouldn't this be read from the config?  I'm still a little
         # lost with all the details of handling the new config guys...
         self.shell.InteractiveTB.set_mode(mode=self.shell.xmode)
         
     def start_app(self):
         if self.master_config.Global.interact:
             self.log.debug("Starting IPython's mainloop...")
             self.shell.mainloop()
         else:
             self.log.debug("IPython not interactive, start_app is no-op...")
 
 
 def load_default_config(ipython_dir=None):
     """Load the default config file from the default ipython_dir.
 
     This is useful for embedded shells.
     """
     if ipython_dir is None:
         ipython_dir = get_ipython_dir()
     cl = PyFileConfigLoader(default_config_file_name, ipython_dir)
     config = cl.load_config()
     return config
 
 
 def launch_new_instance():
     """Create and run a full blown IPython instance"""
     app = IPythonApp()
     app.start()