Changed how config files are loaded.

Previously, we were loading a config file by exec'ing the file in 
an empty Config instance.  That was a bit dangerous, so now there
is a get_config function that should be called to get the Config
instance.  Then attributes can simply be set on it.  

The config files have been updated to reflect this change.

IPython/config/default/ipython_config.py

@@ -1,146 +1,148 b''
+# Get the config being loaded so we can set attributes on it
+c = get_config()
+
 #-----------------------------------------------------------------------------
 # Global options
 #-----------------------------------------------------------------------------
 
-# Global.display_banner = True
+# c.Global.display_banner = True
 
-# Global.classic = False
+# c.Global.classic = False
 
-# Global.nosep = True
+# c.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
+c.Global.log_level = 20
 
 # 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 = [
+# c.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 = [
+# c.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 = [
+# c.Global.exec_files = [
 #     'mycode.py',
 #     'fancy.ipy'
 # ]
 
 #-----------------------------------------------------------------------------
 # InteractiveShell options
 #-----------------------------------------------------------------------------
 
+# c.InteractiveShell.autocall = 1
 
-# InteractiveShell.autocall = 1
-
-# InteractiveShell.autoedit_syntax = False
+# c.InteractiveShell.autoedit_syntax = False
 
-# InteractiveShell.autoindent = True
+# c.InteractiveShell.autoindent = True
 
-# InteractiveShell.automagic = False
+# c.InteractiveShell.automagic = False
 
-# InteractiveShell.banner1 = 'This if for overriding the default IPython banner'
+# c.InteractiveShell.banner1 = 'This if for overriding the default IPython banner'
  
-# InteractiveShell.banner2 = "This is for extra banner text"
+# c.InteractiveShell.banner2 = "This is for extra banner text"
 
-# InteractiveShell.cache_size = 1000
+# c.InteractiveShell.cache_size = 1000
 
-# InteractiveShell.colors = 'LightBG'
+# c.InteractiveShell.colors = 'LightBG'
 
-# InteractiveShell.color_info = True
+# c.InteractiveShell.color_info = True
 
-# InteractiveShell.confirm_exit = True
+# c.InteractiveShell.confirm_exit = True
 
-# InteractiveShell.deep_reload = False
+# c.InteractiveShell.deep_reload = False
 
-# InteractiveShell.editor = 'nano'
+# c.InteractiveShell.editor = 'nano'
 
-# InteractiveShell.logstart = True
+# c.InteractiveShell.logstart = True
 
-# InteractiveShell.logfile = 'ipython_log.py'
+# c.InteractiveShell.logfile = 'ipython_log.py'
 
-# InteractiveShell.logplay = 'mylog.py'
+# c.InteractiveShell.logplay = 'mylog.py'
 
-# InteractiveShell.object_info_string_level = 0
+# c.InteractiveShell.object_info_string_level = 0
 
-# InteractiveShell.pager = 'less'
+# c.InteractiveShell.pager = 'less'
 
-# InteractiveShell.pdb = False
+# c.InteractiveShell.pdb = False
 
-# InteractiveShell.pprint = True
+# c.InteractiveShell.pprint = True
 
-# InteractiveShell.prompt_in1 = 'In [\#]: '
-# InteractiveShell.prompt_in2 = '   .\D.: '
-# InteractiveShell.prompt_out = 'Out[\#]: '
-# InteractiveShell.prompts_pad_left = True
+# c.InteractiveShell.prompt_in1 = 'In [\#]: '
+# c.InteractiveShell.prompt_in2 = '   .\D.: '
+# c.InteractiveShell.prompt_out = 'Out[\#]: '
+# c.InteractiveShell.prompts_pad_left = True
 
-# InteractiveShell.quiet = False
+# c.InteractiveShell.quiet = False
 
 # Readline 
-# InteractiveShell.readline_use = True
+# c.InteractiveShell.readline_use = True
 
-# InteractiveShell.readline_parse_and_bind = [
+# c.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
+# c.InteractiveShell.readline_remove_delims = '-/~'
+# c.InteractiveShell.readline_merge_completions = True
+# c.InteractiveShell.readline_omit_names = 0
 
-# InteractiveShell.screen_length = 0
+# c.InteractiveShell.screen_length = 0
 
-# InteractiveShell.separate_in = '\n'
-# InteractiveShell.separate_out = ''
-# InteractiveShell.separate_out2 = ''
+# c.InteractiveShell.separate_in = '\n'
+# c.InteractiveShell.separate_out = ''
+# c.InteractiveShell.separate_out2 = ''
 
-# InteractiveShell.system_header = "IPython system call: "
+# c.InteractiveShell.system_header = "IPython system call: "
 
-# InteractiveShell.system_verbose = True
+# c.InteractiveShell.system_verbose = True
 
-# InteractiveShell.term_title = False
+# c.InteractiveShell.term_title = False
 
-# InteractiveShell.wildcards_case_sensitive = True
+# c.InteractiveShell.wildcards_case_sensitive = True
 
-# InteractiveShell.xmode = 'Context'
+# c.InteractiveShell.xmode = 'Context'
 
 #-----------------------------------------------------------------------------
 # PrefilterManager options
 #-----------------------------------------------------------------------------
 
-# PrefilterManager.multi_line_specials = True
+# c.PrefilterManager.multi_line_specials = True
 
 #-----------------------------------------------------------------------------
 # AliasManager options
 #-----------------------------------------------------------------------------
 
 # Do this to enable all defaults
-# AliasManager.default_aliases = []
+# c.AliasManager.default_aliases = []
 
-# AliasManager.user_aliases = [
-    # ('foo', 'echo Hi')
+# c.AliasManager.user_aliases = [
+#     ('foo', 'echo Hi')
 # ]
  No newline at end of file

IPython/config/loader.py

@@ -1,328 +1,329 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):
         """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__']
+        # 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):
     
     # 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,17 +1,19 b''
+c = get_config()
+
 # 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')
 
 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)
+if hasattr(c.Global, 'exec_lines'):
+    c.Global.exec_lines.append(lines)
 else:
-    Global.exec_lines = [lines]
+    c.Global.exec_lines = [lines]
 

IPython/config/profile/ipython_config_numeric.py

@@ -1,18 +1,20 b''
+c = get_config()
+
 # 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')
 
 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)
+if hasattr(c.Global, 'exec_lines'):
+    c.Global.exec_lines.append(lines)
 else:
-    Global.exec_lines = [lines]
  No newline at end of file
+    c.Global.exec_lines = [lines]
  No newline at end of file

IPython/config/profile/ipython_config_pylab.py

@@ -1,20 +1,22 b''
+c = get_config()
+
 # 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')
 
 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)
+if hasattr(c.Global, 'exec_lines'):
+    c.Global.exec_lines.append(lines)
 else:
-    Global.exec_lines = [lines]
  No newline at end of file
+    c.Global.exec_lines = [lines]
  No newline at end of file

IPython/config/profile/ipython_config_pysh.py

@@ -1,27 +1,29 b''
+c = get_config()
+
 # 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_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 = '<\#> '
+c.InteractiveShell.prompt_in1 = '\C_LightGreen\u@\h\C_LightBlue[\C_LightCyan\Y1\C_LightBlue]\C_Green|\#> '
+c.InteractiveShell.prompt_in2 = '\C_Green|\C_LightGreen\D\C_Green> '
+c.InteractiveShell.prompt_out = '<\#> '
 
-InteractiveShell.prompts_pad_left = True
+c.InteractiveShell.prompts_pad_left = True
 
-InteractiveShell.separate_in = ''
-InteractiveShell.separate_out = ''
-InteractiveShell.separate_out2 = ''
+c.InteractiveShell.separate_in = ''
+c.InteractiveShell.separate_out = ''
+c.InteractiveShell.separate_out2 = ''
 
-PrefilterManager.multi_line_specials = True
+c.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)
+if hasattr(c.Global, 'exec_lines'):
+    c.Global.exec_lines.append(lines)
 else:
-    Global.exec_lines = [lines]
  No newline at end of file
+    c.Global.exec_lines = [lines]
  No newline at end of file

IPython/config/profile/ipython_config_sympy.py

@@ -1,19 +1,21 b''
+c = get_config()
+
 # 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')
 
 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)
+if hasattr(c.Global, 'exec_lines'):
+    c.Global.exec_lines.append(lines)
 else:
-    Global.exec_lines = [lines]
+    c.Global.exec_lines = [lines]