Config system is finished!

* New load_subconfig(fname) function is available the namespace that
  config files are exec'd in.  This can be used to load subconfigs.
  The implementation is a bit crazy, but Python is amazing and it
  works!  See examples of its usage in IPython/config/profile.
* Fully working example config files and profiles in 
  IPython/config/default and IPython/config/profiles.  Copy these to
  you .ipython dir and start playing around!

IPython/config/default/ipython_config.py

@@ -1,115 +1,146 b''
 #-----------------------------------------------------------------------------
 # Global options
 #-----------------------------------------------------------------------------
 
-Global.classic = False
-Global.nosep = False
+# Global.display_banner = True
+
+# Global.classic = False
+
+# Global.nosep = True
+
+# Set this to determine the detail of what is logged at startup.
+# The default is 30 and possible values are 0,10,20,30,40,50.
+# Global.log_level = 30
+
+# This should be a list of importable Python modules that have an
+# load_in_ipython(ip) method.  This method gets called when the extension
+# is loaded.  You can put your extensions anywhere they can be imported
+# but we add the extensions subdir of the ipython directory to sys.path
+# during extension loading, so you can put them there as well.
+# Global.extensions = [
+#     'myextension'
+# ]
+
+# These lines are run in IPython in the user's namespace after extensions 
+# are loaded.  They can contain full IPython syntax with magics etc.
+# Global.exec_lines = [
+#     'import numpy',
+#     'a = 10; b = 20',
+#     '1/0'
+# ]
+
+# These files are run in IPython in the user's namespace.  Files with a .py
+# extension need to be pure Python.  Files with a .ipy extension can have
+# custom IPython syntax (like magics, etc.).  
+# These files need to be in the cwd, the ipythondir or be absolute paths.
+# Global.exec_files = [
+#     'mycode.py',
+#     'fancy.ipy'
+# ]
 
 #-----------------------------------------------------------------------------
 # InteractiveShell options
 #-----------------------------------------------------------------------------
 
 
-InteractiveShell.autocall = 1
+# InteractiveShell.autocall = 1
 
-InteractiveShell.autoedit_syntax = False
+# InteractiveShell.autoedit_syntax = False
 
-InteractiveShell.autoindent = True
+# InteractiveShell.autoindent = True
 
-InteractiveShell.automagic = False
+# InteractiveShell.automagic = False
 
-InteractiveShell.banner1 = 'This if for overriding the default IPython banner'
+# InteractiveShell.banner1 = 'This if for overriding the default IPython banner'
  
-InteractiveShell.banner2 = "This is for extra banner text"
+# InteractiveShell.banner2 = "This is for extra banner text"
 
-InteractiveShell.cache_size = 1000
+# InteractiveShell.cache_size = 1000
 
-InteractiveShell.colors = 'LightBG'
+# InteractiveShell.colors = 'LightBG'
 
-InteractiveShell.color_info = True
+# InteractiveShell.color_info = True
 
-InteractiveShell.confirm_exit = True
+# InteractiveShell.confirm_exit = True
 
-InteractiveShell.deep_reload = False
+# InteractiveShell.deep_reload = False
 
-InteractiveShell.display_banner = True
+# InteractiveShell.editor = 'nano'
 
-InteractiveShell.editor = 'nano'
+# InteractiveShell.logstart = True
 
-InteractiveShell.logstart = True
+# InteractiveShell.logfile = 'ipython_log.py'
 
-InteractiveShell.logfile = 'ipython_log.py'
+# InteractiveShell.logplay = 'mylog.py'
 
-InteractiveShell.logplay = 'mylog.py'
+# InteractiveShell.object_info_string_level = 0
 
-InteractiveShell.object_info_string_level = 0
+# InteractiveShell.pager = 'less'
 
-InteractiveShell.pager = 'less'
+# InteractiveShell.pdb = False
 
-InteractiveShell.pdb = False
+# InteractiveShell.pprint = True
 
-InteractiveShell.pprint = True
+# InteractiveShell.prompt_in1 = 'In [\#]: '
+# InteractiveShell.prompt_in2 = '   .\D.: '
+# InteractiveShell.prompt_out = 'Out[\#]: '
+# InteractiveShell.prompts_pad_left = True
 
-InteractiveShell.prompt_in1 = 'In [\#]: '
-InteractiveShell.prompt_in2 = '   .\D.: '
-InteractiveShell.prompt_out = 'Out[\#]: '
-InteractiveShell.prompts_pad_left = True
-
-InteractiveShell.quiet = False
+# InteractiveShell.quiet = False
 
 # Readline 
-InteractiveShell.readline_use = False
+# InteractiveShell.readline_use = True
 
-InteractiveShell.readline_parse_and_bind = [
-    'tab: complete',
-    '"\C-l": possible-completions',
-    'set show-all-if-ambiguous on',
-    '"\C-o": tab-insert',
-    '"\M-i": "    "',
-    '"\M-o": "\d\d\d\d"',
-    '"\M-I": "\d\d\d\d"',
-    '"\C-r": reverse-search-history',
-    '"\C-s": forward-search-history',
-    '"\C-p": history-search-backward',
-    '"\C-n": history-search-forward',
-    '"\e[A": history-search-backward',
-    '"\e[B": history-search-forward',
-    '"\C-k": kill-line',
-    '"\C-u": unix-line-discard',
-]
-InteractiveShell.readline_remove_delims = '-/~'
-InteractiveShell.readline_merge_completions = True
-InteractiveShell.readline_omit_names = 0
+# InteractiveShell.readline_parse_and_bind = [
+#     'tab: complete',
+#     '"\C-l": possible-completions',
+#     'set show-all-if-ambiguous on',
+#     '"\C-o": tab-insert',
+#     '"\M-i": "    "',
+#     '"\M-o": "\d\d\d\d"',
+#     '"\M-I": "\d\d\d\d"',
+#     '"\C-r": reverse-search-history',
+#     '"\C-s": forward-search-history',
+#     '"\C-p": history-search-backward',
+#     '"\C-n": history-search-forward',
+#     '"\e[A": history-search-backward',
+#     '"\e[B": history-search-forward',
+#     '"\C-k": kill-line',
+#     '"\C-u": unix-line-discard',
+# ]
+# InteractiveShell.readline_remove_delims = '-/~'
+# InteractiveShell.readline_merge_completions = True
+# InteractiveShell.readline_omit_names = 0
 
-InteractiveShell.screen_length = 0
+# InteractiveShell.screen_length = 0
 
-InteractiveShell.separate_in = '\n'
-InteractiveShell.separate_out = ''
-InteractiveShell.separate_out2 = ''
+# InteractiveShell.separate_in = '\n'
+# InteractiveShell.separate_out = ''
+# InteractiveShell.separate_out2 = ''
 
-InteractiveShell.system_header = "IPython system call: "
+# InteractiveShell.system_header = "IPython system call: "
 
-InteractiveShell.system_verbose = True
+# InteractiveShell.system_verbose = True
 
-InteractiveShell.term_title = False
+# InteractiveShell.term_title = False
 
-InteractiveShell.wildcards_case_sensitive = True
+# InteractiveShell.wildcards_case_sensitive = True
 
-InteractiveShell.xmode = 'Context'
+# InteractiveShell.xmode = 'Context'
 
 #-----------------------------------------------------------------------------
 # PrefilterManager options
 #-----------------------------------------------------------------------------
 
-PrefilterManager.multi_line_specials = True
+# PrefilterManager.multi_line_specials = True
 
 #-----------------------------------------------------------------------------
 # AliasManager options
 #-----------------------------------------------------------------------------
 
 # Do this to enable all defaults
 # AliasManager.default_aliases = []
 
-AliasManger.user_aliases = [
-    ('foo', 'echo Hi')
-]
  No newline at end of file
+# AliasManger.user_aliases = [
+    # ('foo', 'echo Hi')
+# ]
  No newline at end of file

IPython/config/loader.py

@@ -1,311 +1,328 b''
 #!/usr/bin/env python
 # encoding: utf-8
 """A simple configuration system.
 
 Authors:
 
 * Brian Granger
 """
 
 #-----------------------------------------------------------------------------
 #  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
 
 
 #-----------------------------------------------------------------------------
 # 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):
-        execfile(self.full_filename, self.config)
+        """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)
+            sub_config = loader.load_config()
+            self.config._merge(sub_config)
+
+        self.config.load_subconfig = load_subconfig
+        try:
+            execfile(self.full_filename, self.config)
+        finally:
+            del self.config.load_subconfig
+            del self.config['__builtins__']
 
     def _convert_to_config(self):
         if self.data is None:
             ConfigLoaderError('self.data does not exist')
-        del self.config['__builtins__']
 
 
 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):
     
     # arguments = [(('-f','--file'),dict(type=str,dest='file'))]
     arguments = ()
 
     def __init__(self, *args, **kw):
         """Create a config loader for use with argparse.
 
         The args and kwargs arguments here are passed onto the constructor
         of :class:`argparse.ArgumentParser`.
         """
         super(CommandLineConfigLoader, self).__init__()
         self.args = args
         self.kw = kw
 
     def load_config(self, args=None):
         """Parse command line arguments and return as a Struct."""
         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 = argparse.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:
             if not argument[1].has_key('default'):
                 argument[1]['default'] = NoConfigDefault
             self.parser.add_argument(*argument[0],**argument[1])
 
     def _parse_args(self, args=None):
         """self.parser->self.parsed_data"""
         if args is None:
             self.parsed_data, self.extra_args = self.parser.parse_known_args()
         else:
             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/config/profile/ipython_config_math.py

@@ -1,8 +1,17 b''
-from ipython_config import *
+# This can be used at any point in a config file to load a sub config
+# and merge it into the current one.
+load_subconfig('ipython_config.py')
 
-Global.exec_lines.extend([
-    'import cmath',
-    'from math import *',
-    'print "*** math functions available globally, cmath as a module"'
-])
+lines = """
+import cmath
+from math import *
+"""
+
+# You have to make sure that attributes that are containers already
+# exist before using them.  Simple assigning a new list will override
+# all previous values.
+if hasattr(Global, 'exec_lines'):
+    Global.exec_lines.append(lines)
+else:
+    Global.exec_lines = [lines]
 

IPython/config/profile/ipython_config_numeric.py

@@ -1,8 +1,18 b''
-from ipython_config import *
+# This can be used at any point in a config file to load a sub config
+# and merge it into the current one.
+load_subconfig('ipython_config.py')
 
-Global.exec_lines.extend([
-    'import numpy',
-    'import scipy',
-    'import numpy as np',
-    'import scipy as sp',
-])
  No newline at end of file
+lines = """
+import numpy
+import scipy
+import numpy as np
+import scipy as sp
+"""
+
+# You have to make sure that attributes that are containers already
+# exist before using them.  Simple assigning a new list will override
+# all previous values.
+if hasattr(Global, 'exec_lines'):
+    Global.exec_lines.append(lines)
+else:
+    Global.exec_lines = [lines]
  No newline at end of file

IPython/config/profile/ipython_config_pylab.py

@@ -1,8 +1,20 b''
-from ipython_config_numeric import *
+# This can be used at any point in a config file to load a sub config
+# and merge it into the current one.
+load_subconfig('ipython_config.py')
 
-Global.exec_lines.extend([
-    'import matplotlib',
-    'from matplotlib import pyplot as plt',
-    'from matplotlib.pyplot import *'
-])
+lines = """
+import matplotlib
+%gui -a wx
+matplotlib.use('wxagg')
+matplotlib.interactive(True)
+from matplotlib import pyplot as plt
+from matplotlib.pyplot import *
+"""
 
+# You have to make sure that attributes that are containers already
+# exist before using them.  Simple assigning a new list will override
+# all previous values.
+if hasattr(Global, 'exec_lines'):
+    Global.exec_lines.append(lines)
+else:
+    Global.exec_lines = [lines]
  No newline at end of file

IPython/config/profile/ipython_config_pysh.py

@@ -1,13 +1,27 b''
-from ipython_config import *
+# This can be used at any point in a config file to load a sub config
+# and merge it into the current one.
+load_subconfig('ipython_config.py')
 
-InteractiveShell.prompt_in2 = '\C_LightGreen\u@\h\C_LightBlue[\C_LightCyan\Y1\C_LightBlue]\C_Green|\#> '
+InteractiveShell.prompt_in1 = '\C_LightGreen\u@\h\C_LightBlue[\C_LightCyan\Y1\C_LightBlue]\C_Green|\#> '
 InteractiveShell.prompt_in2 = '\C_Green|\C_LightGreen\D\C_Green> '
 InteractiveShell.prompt_out = '<\#> '
 
 InteractiveShell.prompts_pad_left = True
 
 InteractiveShell.separate_in = ''
 InteractiveShell.separate_out = ''
 InteractiveShell.separate_out2 = ''
 
-PrefilterManager.multi_line_specials = True
  No newline at end of file
+PrefilterManager.multi_line_specials = True
+
+lines = """
+%rehashx
+"""
+
+# You have to make sure that attributes that are containers already
+# exist before using them.  Simple assigning a new list will override
+# all previous values.
+if hasattr(Global, 'exec_lines'):
+    Global.exec_lines.append(lines)
+else:
+    Global.exec_lines = [lines]
  No newline at end of file

IPython/config/profile/ipython_config_sympy.py

@@ -1,9 +1,19 b''
-from ipython_config import *
+# This can be used at any point in a config file to load a sub config
+# and merge it into the current one.
+load_subconfig('ipython_config.py')
 
-Global.exec_lines.extend([
-    "from __future__ import division"
-    "from sympy import *"
-    "x, y, z = symbols('xyz')"
-    "k, m, n = symbols('kmn', integer=True)"
-    "f, g, h = map(Function, 'fgh')"
-])
+lines = """
+from __future__ import division
+from sympy import *
+x, y, z = symbols('xyz')
+k, m, n = symbols('kmn', integer=True)
+f, g, h = map(Function, 'fgh')
+"""
+
+# You have to make sure that attributes that are containers already
+# exist before using them.  Simple assigning a new list will override
+# all previous values.
+if hasattr(Global, 'exec_lines'):
+    Global.exec_lines.append(lines)
+else:
+    Global.exec_lines = [lines]