Merging the config-refactor branch.

This branch did start with the config system refactor, but moved on
from there.  Here are some highlights.

* New config system.
* Traitlets
* Componenets
* Applications
* The main ipython program has been refactored to use these new
  abstractions.

IPython/config/default/ipython_config.py

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

IPython/config/default/kernel_config.py

@@ -0,0 +1,62 b''
+from os.path import join
+pjoin = join
+
+from IPython.utils.genutils import get_ipython_dir, get_security_dir
+security_dir = get_security_dir()
+
+
+ENGINE_LOGFILE = ''
+
+ENGINE_FURL_FILE = 'ipcontroller-engine.furl'
+
+MPI_CONFIG_MPI4PY = """from mpi4py import MPI as mpi
+mpi.size = mpi.COMM_WORLD.Get_size()
+mpi.rank = mpi.COMM_WORLD.Get_rank()
+"""
+
+MPI_CONFIG_PYTRILINOS = """from PyTrilinos import Epetra
+class SimpleStruct:
+pass
+mpi = SimpleStruct()
+mpi.rank = 0
+mpi.size = 0
+"""
+
+MPI_DEFAULT = ''
+
+CONTROLLER_LOGFILE = ''
+CONTROLLER_IMPORT_STATEMENT = ''
+CONTROLLER_REUSE_FURLS = False
+
+ENGINE_TUB_IP = ''
+ENGINE_TUB_PORT = 0
+ENGINE_TUB_LOCATION = ''
+ENGINE_TUB_SECURE = True
+ENGINE_TUB_CERT_FILE = 'ipcontroller-engine.pem'
+ENGINE_FC_INTERFACE = 'IPython.kernel.enginefc.IFCControllerBase'
+ENGINE_FURL_FILE = 'ipcontroller-engine.furl'
+
+CONTROLLER_INTERFACES = dict(
+    TASK = dict(
+        CONTROLLER_INTERFACE = 'IPython.kernel.task.ITaskController',
+        FC_INTERFACE = 'IPython.kernel.taskfc.IFCTaskController',
+        FURL_FILE = pjoin(security_dir, 'ipcontroller-tc.furl')
+    ),
+    MULTIENGINE = dict(
+        CONTROLLER_INTERFACE = 'IPython.kernel.multiengine.IMultiEngine',
+        FC_INTERFACE = 'IPython.kernel.multienginefc.IFCSynchronousMultiEngine',
+        FURL_FILE = pjoin(security_dir, 'ipcontroller-mec.furl')
+    )
+)
+
+CLIENT_TUB_IP = ''
+CLIENT_TUB_PORT = 0
+CLIENT_TUB_LOCATION = ''
+CLIENT_TUB_SECURE = True
+CLIENT_TUB_CERT_FILE = 'ipcontroller-client.pem'
+
+CLIENT_INTERFACES = dict(
+    TASK = dict(FURL_FILE = 'ipcontroller-tc.furl'),
+    MULTIENGINE = dict(FURLFILE='ipcontroller-mec.furl')
+)
+

IPython/config/loader.py

@@ -0,0 +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)
+
+        # 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

@@ -0,0 +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(c.Global, 'exec_lines'):
+    c.Global.exec_lines.append(lines)
+else:
+    c.Global.exec_lines = [lines]
+

IPython/config/profile/ipython_config_numeric.py

@@ -0,0 +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(c.Global, 'exec_lines'):
+    c.Global.exec_lines.append(lines)
+else:
+    c.Global.exec_lines = [lines]
  No newline at end of file

IPython/config/profile/ipython_config_pylab.py

@@ -0,0 +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(c.Global, 'exec_lines'):
+    c.Global.exec_lines.append(lines)
+else:
+    c.Global.exec_lines = [lines]
  No newline at end of file

IPython/config/profile/ipython_config_pysh.py

@@ -0,0 +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')
+
+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 = '<\#> '
+
+c.InteractiveShell.prompts_pad_left = True
+
+c.InteractiveShell.separate_in = ''
+c.InteractiveShell.separate_out = ''
+c.InteractiveShell.separate_out2 = ''
+
+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(c.Global, 'exec_lines'):
+    c.Global.exec_lines.append(lines)
+else:
+    c.Global.exec_lines = [lines]
  No newline at end of file

IPython/config/profile/ipython_config_sympy.py

@@ -0,0 +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(c.Global, 'exec_lines'):
+    c.Global.exec_lines.append(lines)
+else:
+    c.Global.exec_lines = [lines]

IPython/config/tests/test_loader.py

@@ -0,0 +1,163 b''
+#!/usr/bin/env python
+# encoding: utf-8
+"""
+Tests for IPython.config.loader
+
+Authors:
+
+* Brian Granger
+* Fernando Perez (design help)
+"""
+
+#-----------------------------------------------------------------------------
+#  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 os
+from tempfile import mkstemp
+from unittest import TestCase
+
+from IPython.config.loader import (
+    Config,
+    PyFileConfigLoader, 
+    ArgParseConfigLoader,
+    ConfigError
+)
+
+#-----------------------------------------------------------------------------
+# Actual tests
+#-----------------------------------------------------------------------------
+
+
+pyfile = """
+a = 10
+b = 20
+Foo.Bar.value = 10
+Foo.Bam.value = range(10)
+D.C.value = 'hi there'
+"""
+
+class TestPyFileCL(TestCase):
+
+    def test_basic(self):
+        fd, fname = mkstemp()
+        f = os.fdopen(fd, 'w')
+        f.write(pyfile)
+        f.close()
+        # Unlink the file
+        cl = PyFileConfigLoader(fname)
+        config = cl.load_config()
+        self.assertEquals(config.a, 10)
+        self.assertEquals(config.b, 20)
+        self.assertEquals(config.Foo.Bar.value, 10)
+        self.assertEquals(config.Foo.Bam.value, range(10))
+        self.assertEquals(config.D.C.value, 'hi there')
+
+
+class TestArgParseCL(TestCase):
+
+    def test_basic(self):
+
+        class MyLoader(ArgParseConfigLoader):
+            arguments = (
+                (('-f','--foo'), dict(dest='Global.foo', type=str)),
+                (('-b',), dict(dest='MyClass.bar', type=int)),
+                (('-n',), dict(dest='n', action='store_true')),
+                (('Global.bam',), dict(type=str))
+            )
+
+        cl = MyLoader()
+        config = cl.load_config('-f hi -b 10 -n wow'.split())
+        self.assertEquals(config.Global.foo, 'hi')
+        self.assertEquals(config.MyClass.bar, 10)
+        self.assertEquals(config.n, True)
+        self.assertEquals(config.Global.bam, 'wow')
+
+    def test_add_arguments(self):
+
+        class MyLoader(ArgParseConfigLoader):
+            def _add_arguments(self):
+                subparsers = self.parser.add_subparsers(dest='subparser_name')
+                subparser1 = subparsers.add_parser('1')
+                subparser1.add_argument('-x',dest='Global.x')
+                subparser2 = subparsers.add_parser('2')
+                subparser2.add_argument('y')
+
+        cl = MyLoader()
+        config = cl.load_config('2 frobble'.split())
+        self.assertEquals(config.subparser_name, '2')
+        self.assertEquals(config.y, 'frobble')
+        config = cl.load_config('1 -x frobble'.split())
+        self.assertEquals(config.subparser_name, '1')
+        self.assertEquals(config.Global.x, 'frobble')
+
+class TestConfig(TestCase):
+
+    def test_setget(self):
+        c = Config()
+        c.a = 10
+        self.assertEquals(c.a, 10)
+        self.assertEquals(c.has_key('b'), False)
+
+    def test_auto_section(self):
+        c = Config()
+        self.assertEquals(c.has_key('A'), True)
+        self.assertEquals(c._has_section('A'), False)
+        A = c.A
+        A.foo = 'hi there'
+        self.assertEquals(c._has_section('A'), True)
+        self.assertEquals(c.A.foo, 'hi there')
+        del c.A
+        self.assertEquals(len(c.A.keys()),0)
+
+    def test_merge_doesnt_exist(self):
+        c1 = Config()
+        c2 = Config()
+        c2.bar = 10
+        c2.Foo.bar = 10
+        c1._merge(c2)
+        self.assertEquals(c1.Foo.bar, 10)
+        self.assertEquals(c1.bar, 10)
+        c2.Bar.bar = 10
+        c1._merge(c2)
+        self.assertEquals(c1.Bar.bar, 10)
+
+    def test_merge_exists(self):
+        c1 = Config()
+        c2 = Config()
+        c1.Foo.bar = 10
+        c1.Foo.bam = 30
+        c2.Foo.bar = 20
+        c2.Foo.wow = 40
+        c1._merge(c2)
+        self.assertEquals(c1.Foo.bam, 30)
+        self.assertEquals(c1.Foo.bar, 20)
+        self.assertEquals(c1.Foo.wow, 40)
+        c2.Foo.Bam.bam = 10
+        c1._merge(c2)
+        self.assertEquals(c1.Foo.Bam.bam, 10)
+
+    def test_deepcopy(self):
+        c1 = Config()
+        c1.Foo.bar = 10
+        c1.Foo.bam = 30
+        c1.a = 'asdf'
+        c1.b = range(10)
+        import copy
+        c2 = copy.deepcopy(c1)
+        self.assertEquals(c1, c2)
+        self.assert_(c1 is not c2)
+        self.assert_(c1.Foo is not c2.Foo)
+
+    def test_builtin(self):
+        c1 = Config()
+        exec 'foo = True' in c1
+        self.assertEquals(c1.foo, True)
+        self.assertRaises(ConfigError, setattr, c1, 'ValueError', 10)

IPython/core/alias.py

@@ -0,0 +1,262 b''
+#!/usr/bin/env python
+# encoding: utf-8
+"""
+IPython's alias component
+
+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 keyword
+import os
+import re
+import sys
+
+from IPython.core.component import Component
+from IPython.core.splitinput import split_user_input
+
+from IPython.utils.traitlets import CBool, List, Instance
+from IPython.utils.genutils import error
+from IPython.utils.autoattr import auto_attr
+
+#-----------------------------------------------------------------------------
+# Utilities
+#-----------------------------------------------------------------------------
+
+# This is used as the pattern for calls to split_user_input.
+shell_line_split = re.compile(r'^(\s*)(\S*\s*)(.*$)')
+
+def default_aliases():
+    # Make some aliases automatically
+    # Prepare list of shell aliases to auto-define
+    if os.name == 'posix':
+        default_aliases = ('mkdir mkdir', 'rmdir rmdir',
+                      'mv mv -i','rm rm -i','cp cp -i',
+                      'cat cat','less less','clear clear',
+                      # a better ls
+                      'ls ls -F',
+                      # long ls
+                      'll ls -lF')
+        # Extra ls aliases with color, which need special treatment on BSD
+        # variants
+        ls_extra = ( # color ls
+                     'lc ls -F -o --color',
+                     # ls normal files only
+                     'lf ls -F -o --color %l | grep ^-',
+                     # ls symbolic links
+                     'lk ls -F -o --color %l | grep ^l',
+                     # directories or links to directories,
+                     'ldir ls -F -o --color %l | grep /$',
+                     # things which are executable
+                     'lx ls -F -o --color %l | grep ^-..x',
+                     )
+        # The BSDs don't ship GNU ls, so they don't understand the
+        # --color switch out of the box
+        if 'bsd' in sys.platform:
+            ls_extra = ( # ls normal files only
+                         'lf ls -lF | grep ^-',
+                         # ls symbolic links
+                         'lk ls -lF | grep ^l',
+                         # directories or links to directories,
+                         'ldir ls -lF | grep /$',
+                         # things which are executable
+                         'lx ls -lF | grep ^-..x',
+                         )
+        default_aliases = default_aliases + ls_extra
+    elif os.name in ['nt','dos']:
+        default_aliases = ('ls dir /on',
+                      'ddir dir /ad /on', 'ldir dir /ad /on',
+                      'mkdir mkdir','rmdir rmdir','echo echo',
+                      'ren ren','cls cls','copy copy')
+    else:
+        default_aliases = ()
+    return [s.split(None,1) for s in default_aliases]
+
+
+class AliasError(Exception):
+    pass
+
+
+class InvalidAliasError(AliasError):
+    pass
+
+
+#-----------------------------------------------------------------------------
+# Main AliasManager class
+#-----------------------------------------------------------------------------
+
+
+class AliasManager(Component):
+
+    default_aliases = List(default_aliases(), config=True)
+    user_aliases = List(default_value=[], config=True)
+
+    def __init__(self, parent, config=None):
+        super(AliasManager, self).__init__(parent, config=config)
+        self.alias_table = {}
+        self.exclude_aliases()
+        self.init_aliases()
+
+    @auto_attr
+    def shell(self):
+        return Component.get_instances(
+            root=self.root,
+            klass='IPython.core.iplib.InteractiveShell')[0]
+
+    def __contains__(self, name):
+        if name in self.alias_table:
+            return True
+        else:
+            return False
+
+    @property
+    def aliases(self):
+        return [(item[0], item[1][1]) for item in self.alias_table.iteritems()]
+
+    def exclude_aliases(self):
+        # set of things NOT to alias (keywords, builtins and some magics)
+        no_alias = set(['cd','popd','pushd','dhist','alias','unalias'])
+        no_alias.update(set(keyword.kwlist))
+        no_alias.update(set(__builtin__.__dict__.keys()))
+        self.no_alias = no_alias
+
+    def init_aliases(self):
+        # Load default aliases
+        for name, cmd in self.default_aliases:
+            self.soft_define_alias(name, cmd)
+
+        # Load user aliases
+        for name, cmd in self.user_aliases:
+            self.soft_define_alias(name, cmd)
+
+    def clear_aliases(self):
+        self.alias_table.clear()
+
+    def soft_define_alias(self, name, cmd):
+        """Define an alias, but don't raise on an AliasError."""
+        try:
+            self.define_alias(name, cmd)
+        except AliasError, e:
+            error("Invalid alias: %s" % e)
+
+    def define_alias(self, name, cmd):
+        """Define a new alias after validating it.
+
+        This will raise an :exc:`AliasError` if there are validation
+        problems.
+        """
+        nargs = self.validate_alias(name, cmd)
+        self.alias_table[name] = (nargs, cmd)
+
+    def undefine_alias(self, name):
+        if self.alias_table.has_key(name):
+            del self.alias_table[name]
+
+    def validate_alias(self, name, cmd):
+        """Validate an alias and return the its number of arguments."""
+        if name in self.no_alias:
+            raise InvalidAliasError("The name %s can't be aliased "
+                                    "because it is a keyword or builtin." % name)
+        if not (isinstance(cmd, basestring)):
+            raise InvalidAliasError("An alias command must be a string, "
+                                    "got: %r" % name)
+        nargs = cmd.count('%s')
+        if nargs>0 and cmd.find('%l')>=0:
+            raise InvalidAliasError('The %s and %l specifiers are mutually '
+                                    'exclusive in alias definitions.')
+        return nargs
+
+    def call_alias(self, alias, rest=''):
+        """Call an alias given its name and the rest of the line."""
+        cmd = self.transform_alias(alias, rest)
+        try:
+            self.shell.system(cmd)
+        except:
+            self.shell.showtraceback()
+
+    def transform_alias(self, alias,rest=''):
+        """Transform alias to system command string."""
+        nargs, cmd = self.alias_table[alias]
+
+        if ' ' in cmd and os.path.isfile(cmd):
+            cmd = '"%s"' % cmd
+
+        # Expand the %l special to be the user's input line
+        if cmd.find('%l') >= 0:
+            cmd = cmd.replace('%l', rest)
+            rest = ''
+        if nargs==0:
+            # Simple, argument-less aliases
+            cmd = '%s %s' % (cmd, rest)
+        else:
+            # Handle aliases with positional arguments
+            args = rest.split(None, nargs)
+            if len(args) < nargs:
+                raise AliasError('Alias <%s> requires %s arguments, %s given.' %
+                      (alias, nargs, len(args)))
+            cmd = '%s %s' % (cmd % tuple(args[:nargs]),' '.join(args[nargs:]))
+        return cmd
+
+    def expand_alias(self, line):
+        """ Expand an alias in the command line 
+        
+        Returns the provided command line, possibly with the first word 
+        (command) translated according to alias expansion rules.
+        
+        [ipython]|16> _ip.expand_aliases("np myfile.txt")
+                 <16> 'q:/opt/np/notepad++.exe myfile.txt'
+        """
+        
+        pre,fn,rest = split_user_input(line)
+        res = pre + self.expand_aliases(fn, rest)
+        return res
+
+    def expand_aliases(self, fn, rest):
+        """Expand multiple levels of aliases:
+        
+        if:
+        
+        alias foo bar /tmp
+        alias baz foo
+        
+        then:
+        
+        baz huhhahhei -> bar /tmp huhhahhei
+        
+        """
+        line = fn + " " + rest
+        
+        done = set()
+        while 1:
+            pre,fn,rest = split_user_input(line, shell_line_split)
+            if fn in self.alias_table:
+                if fn in done:
+                    warn("Cyclic alias definition, repeated '%s'" % fn)
+                    return ""
+                done.add(fn)
+
+                l2 = self.transform_alias(fn, rest)
+                if l2 == line:
+                    break
+                # ls -> ls -F should not recurse forever
+                if l2.split(None,1)[0] == line.split(None,1)[0]:
+                    line = l2
+                    break
+                line=l2
+            else:
+                break
+                
+        return line

IPython/core/application.py

@@ -0,0 +1,300 b''
+#!/usr/bin/env python
+# encoding: utf-8
+"""
+An application for IPython
+
+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
+import traceback
+from copy import deepcopy
+
+from IPython.utils.genutils import get_ipython_dir, filefind
+from IPython.config.loader import (
+    PyFileConfigLoader,
+    ArgParseConfigLoader,
+    Config,
+    NoConfigDefault
+)
+
+#-----------------------------------------------------------------------------
+# Classes and functions
+#-----------------------------------------------------------------------------
+
+
+class IPythonArgParseConfigLoader(ArgParseConfigLoader):
+    """Default command line options for IPython based applications."""
+
+    def _add_other_arguments(self):
+        self.parser.add_argument('-ipythondir',dest='Global.ipythondir',type=str,
+            help='Set to override default location of Global.ipythondir.',
+            default=NoConfigDefault,
+            metavar='Global.ipythondir')
+        self.parser.add_argument('-p','-profile',dest='Global.profile',type=str,
+            help='The string name of the ipython profile to be used.',
+            default=NoConfigDefault,
+            metavar='Global.profile')
+        self.parser.add_argument('-log_level',dest="Global.log_level",type=int,
+            help='Set the log level (0,10,20,30,40,50).  Default is 30.',
+            default=NoConfigDefault)
+        self.parser.add_argument('-config_file',dest='Global.config_file',type=str,
+            help='Set the config file name to override default.',
+            default=NoConfigDefault,
+            metavar='Global.config_file')
+
+
+class ApplicationError(Exception):
+    pass
+
+
+class Application(object):
+    """Load a config, construct an app and run it.
+    """
+
+    config_file_name = 'ipython_config.py'
+    name = 'ipython'
+
+    def __init__(self):
+        self.init_logger()
+        self.default_config_file_name = self.config_file_name
+
+    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(logging.WARN)
+        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 start(self):
+        """Start the application."""
+        self.attempt(self.create_default_config)
+        self.attempt(self.pre_load_command_line_config)
+        self.attempt(self.load_command_line_config, action='abort')
+        self.attempt(self.post_load_command_line_config)
+        self.attempt(self.find_ipythondir)
+        self.attempt(self.find_config_file_name)
+        self.attempt(self.find_config_file_paths)
+        self.attempt(self.pre_load_file_config)
+        self.attempt(self.load_file_config)
+        self.attempt(self.post_load_file_config)
+        self.attempt(self.merge_configs)
+        self.attempt(self.pre_construct)
+        self.attempt(self.construct)
+        self.attempt(self.post_construct)
+        self.attempt(self.start_app)
+
+    #-------------------------------------------------------------------------
+    # Various stages of Application creation
+    #-------------------------------------------------------------------------
+
+    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.
+        """
+        self.default_config = Config()
+        self.default_config.Global.ipythondir = get_ipython_dir()
+        self.log.debug('Default config loaded:')
+        self.log.debug(repr(self.default_config))
+
+    def create_command_line_config(self):
+        """Create and return a command line config loader."""
+        return IPythonArgParseConfigLoader(description=self.name)
+
+    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.
+
+        This method also sets ``self.debug``.
+        """
+
+        loader = self.create_command_line_config()
+        self.command_line_config = loader.load_config()
+        self.extra_args = loader.get_extra_args()
+
+        try:
+            self.log_level = self.command_line_config.Global.log_level
+        except AttributeError:
+            pass # Use existing value which is set in Application.init_logger.
+        self.log.debug("Command line config loaded:")
+        self.log.debug(repr(self.command_line_config))
+
+    def post_load_command_line_config(self):
+        """Do actions just after loading the command line config."""
+        pass
+
+    def find_ipythondir(self):
+        """Set the IPython directory.
+
+        This sets ``self.ipythondir``, but the actual value that is passed
+        to the application is kept in either ``self.default_config`` or
+        ``self.command_line_config``.  This also added ``self.ipythondir`` to
+        ``sys.path`` so config files there can be references by other config
+        files.
+        """
+
+        try:
+            self.ipythondir = self.command_line_config.Global.ipythondir
+        except AttributeError:
+            self.ipythondir = self.default_config.Global.ipythondir
+        sys.path.append(os.path.abspath(self.ipythondir))
+        if not os.path.isdir(self.ipythondir):
+            os.makedirs(self.ipythondir, mode = 0777)
+        self.log.debug("IPYTHONDIR set to: %s" % self.ipythondir)
+
+    def find_config_file_name(self):
+        """Find the config file name for this application.
+
+        If a profile has been set at the command line, this will resolve
+        it.  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.
+        """
+
+        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
+            name_parts = self.config_file_name.split('.')
+            name_parts.insert(1, '_' + self.profile_name + '.')
+            self.config_file_name = ''.join(name_parts)
+        except AttributeError:
+            pass
+
+    def find_config_file_paths(self):
+        """Set the search paths for resolving the config file."""
+        self.config_file_paths = (os.getcwd(), self.ipythondir)
+
+    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()
+        else:
+            self.log.debug("Config file loaded: <%s>" % loader.full_filename)
+            self.log.debug(repr(self.file_config))
+        # 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.
+        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 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
+        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."""
+        self.log.critical("Aborting application: %s" % self.name, exc_info=True)
+        sys.exit(1)
+
+    def exit(self):
+        self.log.critical("Aborting application: %s" % self.name)
+        sys.exit(1)
+
+    def attempt(self, func, action='abort'):
+        try:
+            func()
+        except SystemExit:
+            self.exit()
+        except:
+            if action == 'abort':
+                self.abort()
+            elif action == 'exit':
+                self.exit()
+      
  No newline at end of file

IPython/core/autocall.py

@@ -0,0 +1,45 b''
+#!/usr/bin/env python
+# encoding: utf-8
+"""
+Autocall capabilities for IPython.core.
+
+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
+#-----------------------------------------------------------------------------
+
+
+#-----------------------------------------------------------------------------
+# Code
+#-----------------------------------------------------------------------------
+
+class IPyAutocall(object):
+    """ Instances of this class are always autocalled
+    
+    This happens regardless of 'autocall' variable state. Use this to
+    develop macro-like mechanisms.
+    """
+    
+    def set_ip(self,ip):
+        """ Will be used to set _ip point to current ipython instance b/f call
+        
+        Override this method if you don't want this to happen.
+        
+        """
+        self._ip = ip
+

IPython/core/builtin_trap.py

@@ -0,0 +1,116 b''
+#!/usr/bin/env python
+# encoding: utf-8
+"""
+A context manager for managing things injected into :mod:`__builtin__`.
+
+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__
+
+from IPython.core.component import Component
+from IPython.core.quitter import Quitter
+
+from IPython.utils.autoattr import auto_attr
+
+#-----------------------------------------------------------------------------
+# Classes and functions
+#-----------------------------------------------------------------------------
+
+
+class BuiltinUndefined(object): pass
+BuiltinUndefined = BuiltinUndefined()
+
+
+class BuiltinTrap(Component):
+
+    def __init__(self, parent):
+        super(BuiltinTrap, self).__init__(parent, None, None)
+        self._orig_builtins = {}
+        # We define this to track if a single BuiltinTrap is nested.
+        # Only turn off the trap when the outermost call to __exit__ is made.
+        self._nested_level = 0
+
+    @auto_attr
+    def shell(self):
+        return Component.get_instances(
+            root=self.root,
+            klass='IPython.core.iplib.InteractiveShell')[0]
+
+    def __enter__(self):
+        if self._nested_level == 0:
+            self.set()
+        self._nested_level += 1
+        # I return self, so callers can use add_builtin in a with clause.
+        return self
+
+    def __exit__(self, type, value, traceback):
+        if self._nested_level == 1:
+            self.unset()
+        self._nested_level -= 1
+        return True
+
+    def add_builtin(self, key, value):
+        """Add a builtin and save the original."""
+        orig = __builtin__.__dict__.get(key, BuiltinUndefined)
+        self._orig_builtins[key] = orig
+        __builtin__.__dict__[key] = value
+
+    def remove_builtin(self, key):
+        """Remove an added builtin and re-set the original."""
+        try:
+            orig = self._orig_builtins.pop(key)
+        except KeyError:
+            pass
+        else:
+            if orig is BuiltinUndefined:
+                del __builtin__.__dict__[key]
+            else:
+                __builtin__.__dict__[key] = orig
+
+    def set(self):
+        """Store ipython references in the __builtin__ namespace."""
+        self.add_builtin('exit', Quitter(self.shell, 'exit'))
+        self.add_builtin('quit', Quitter(self.shell, 'quit'))
+
+        # Recursive reload function
+        try:
+            from IPython.lib import deepreload
+            if self.shell.deep_reload:
+                self.add_builtin('reload', deepreload.reload)
+            else:
+                self.add_builtin('dreload', deepreload.reload)
+            del deepreload
+        except ImportError:
+            pass
+
+        # Keep in the builtins a flag for when IPython is active.  We set it
+        # with setdefault so that multiple nested IPythons don't clobber one
+        # another.  Each will increase its value by one upon being activated,
+        # which also gives us a way to determine the nesting level.
+        __builtin__.__dict__.setdefault('__IPYTHON__active',0)
+
+    def unset(self):
+        """Remove any builtins which might have been added by add_builtins, or
+        restore overwritten ones to their previous values."""
+        for key in self._orig_builtins.keys():
+            self.remove_builtin(key)
+        self._orig_builtins.clear()
+        self._builtins_added = False
+        try:
+            del __builtin__.__dict__['__IPYTHON__active']
+        except KeyError:
+            pass

IPython/core/component.py

@@ -0,0 +1,325 b''
+#!/usr/bin/env python
+# encoding: utf-8
+"""
+A lightweight component system for IPython.
+
+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
+#-----------------------------------------------------------------------------
+
+from copy import deepcopy
+import datetime
+from weakref import WeakValueDictionary
+
+from IPython.utils.importstring import import_item
+from IPython.config.loader import Config
+from IPython.utils.traitlets import (
+    HasTraitlets, TraitletError, MetaHasTraitlets, Instance, This
+)
+
+
+#-----------------------------------------------------------------------------
+# Helper classes for Components
+#-----------------------------------------------------------------------------
+
+
+class ComponentError(Exception):
+    pass
+
+class MetaComponentTracker(type):
+    """A metaclass that tracks instances of Components and its subclasses."""
+
+    def __init__(cls, name, bases, d):
+        super(MetaComponentTracker, cls).__init__(name, bases, d)
+        cls.__instance_refs = WeakValueDictionary()
+        cls.__numcreated = 0
+
+    def __call__(cls, *args, **kw):
+        """Called when a class is called (instantiated)!!!
+        
+        When a Component or subclass is instantiated, this is called and
+        the instance is saved in a WeakValueDictionary for tracking.
+        """
+        instance = cls.__new__(cls, *args, **kw)
+
+        # Register the instance before __init__ is called so get_instances 
+        # works inside __init__ methods!
+        indices = cls.register_instance(instance)
+
+        # This is in a try/except because of the __init__ method fails, the
+        # instance is discarded and shouldn't be tracked.
+        try:
+            if isinstance(instance, cls):
+                cls.__init__(instance, *args, **kw)
+        except:
+            # Unregister the instance because __init__ failed!
+            cls.unregister_instances(indices)
+            raise
+        else:
+            return instance
+
+    def register_instance(cls, instance):
+        """Register instance with cls and its subclasses."""
+        # indices is a list of the keys used to register the instance
+        # with.  This list is needed if the instance needs to be unregistered.
+        indices = []
+        for c in cls.__mro__:
+            if issubclass(cls, c) and issubclass(c, Component):
+                c.__numcreated += 1
+                indices.append(c.__numcreated)
+                c.__instance_refs[c.__numcreated] = instance
+            else:
+                break
+        return indices
+
+    def unregister_instances(cls, indices):
+        """Unregister instance with cls and its subclasses."""
+        for c, index in zip(cls.__mro__, indices):
+            try:
+                del c.__instance_refs[index]
+            except KeyError:
+                pass
+
+    def clear_instances(cls):
+        """Clear all instances tracked by cls."""
+        cls.__instance_refs.clear()
+        cls.__numcreated = 0
+
+    def get_instances(cls, name=None, root=None, klass=None):
+        """Get all instances of cls and its subclasses.
+
+        Parameters
+        ----------
+        name : str
+            Limit to components with this name.
+        root : Component or subclass
+            Limit to components having this root.
+        klass : class or str
+            Limits to instances of the class or its subclasses.  If a str
+            is given ut must be in the form 'foo.bar.MyClass'.  The str
+            form of this argument is useful for forward declarations.
+        """
+        if klass is not None:
+            if isinstance(klass, basestring):
+                klass = import_item(klass)
+            # Limit search to instances of klass for performance
+            if issubclass(klass, Component):
+                return klass.get_instances(name=name, root=root)
+        instances = cls.__instance_refs.values()
+        if name is not None:
+            instances = [i for i in instances if i.name == name]
+        if klass is not None:
+            instances = [i for i in instances if isinstance(i, klass)]
+        if root is not None:
+            instances = [i for i in instances if i.root == root]
+        return instances
+
+    def get_instances_by_condition(cls, call, name=None, root=None,
+                                   klass=None):
+        """Get all instances of cls, i such that call(i)==True.
+
+        This also takes the ``name`` and ``root`` and ``classname`` 
+        arguments of :meth:`get_instance`
+        """
+        return [i for i in cls.get_instances(name, root, klass) if call(i)]
+
+
+def masquerade_as(instance, cls):
+    """Let instance masquerade as an instance of cls.
+
+    Sometimes, such as in testing code, it is useful to let a class
+    masquerade as another.  Python, being duck typed, allows this by 
+    default.  But, instances of components are tracked by their class type.
+
+    After calling this, ``cls.get_instances()`` will return ``instance``. This
+    does not, however, cause ``isinstance(instance, cls)`` to return ``True``.
+
+    Parameters
+    ----------
+    instance : an instance of a Component or Component subclass
+        The instance that will pretend to be a cls.
+    cls : subclass of Component
+        The Component subclass that instance will pretend to be.
+    """
+    cls.register_instance(instance)
+
+
+class ComponentNameGenerator(object):
+    """A Singleton to generate unique component names."""
+
+    def __init__(self, prefix):
+        self.prefix = prefix
+        self.i = 0
+
+    def __call__(self):
+        count = self.i
+        self.i += 1
+        return "%s%s" % (self.prefix, count)
+
+
+ComponentNameGenerator = ComponentNameGenerator('ipython.component')
+
+
+class MetaComponent(MetaHasTraitlets, MetaComponentTracker):
+    pass
+
+
+#-----------------------------------------------------------------------------
+# Component implementation
+#-----------------------------------------------------------------------------
+
+
+class Component(HasTraitlets):
+
+    __metaclass__ = MetaComponent
+
+    # Traitlets are fun!
+    config = Instance(Config,(),{})
+    parent = This()
+    root = This()
+    created = None
+
+    def __init__(self, parent, name=None, config=None):
+        """Create a component given a parent and possibly and name and config.
+
+        Parameters
+        ----------
+        parent : Component subclass
+            The parent in the component graph.  The parent is used
+            to get the root of the component graph.
+        name : str
+            The unique name of the component.  If empty, then a unique
+            one will be autogenerated.
+        config : Config
+            If this is empty, self.config = parent.config, otherwise
+            self.config = config and root.config is ignored.  This argument
+            should only be used to *override* the automatic inheritance of 
+            parent.config.  If a caller wants to modify parent.config 
+            (not override), the caller should make a copy and change 
+            attributes and then pass the copy to this argument.
+        
+        Notes
+        -----
+        Subclasses of Component must call the :meth:`__init__` method of
+        :class:`Component` *before* doing anything else and using 
+        :func:`super`::
+        
+            class MyComponent(Component):
+                def __init__(self, parent, name=None, config=None):
+                    super(MyComponent, self).__init__(parent, name, config)
+                    # Then any other code you need to finish initialization.
+
+        This ensures that the :attr:`parent`, :attr:`name` and :attr:`config`
+        attributes are handled properly.
+        """
+        super(Component, self).__init__()
+        self._children = []
+        if name is None:
+            self.name = ComponentNameGenerator()
+        else:
+            self.name = name
+        self.root = self # This is the default, it is set when parent is set
+        self.parent = parent
+        if config is not None:
+            self.config = config
+            # We used to deepcopy, but for now we are trying to just save
+            # by reference.  This *could* have side effects as all components
+            # will share config.
+            # self.config = deepcopy(config)
+        else:
+            if self.parent is not None:
+                self.config = self.parent.config
+                # We used to deepcopy, but for now we are trying to just save
+                # by reference.  This *could* have side effects as all components
+                # will share config.
+                # self.config = deepcopy(self.parent.config)
+
+        self.created = datetime.datetime.now()
+
+    #-------------------------------------------------------------------------
+    # Static traitlet notifiations
+    #-------------------------------------------------------------------------
+
+    def _parent_changed(self, name, old, new):
+        if old is not None:
+            old._remove_child(self)
+        if new is not None:
+            new._add_child(self)
+
+        if new is None:
+            self.root = self
+        else:
+            self.root = new.root
+
+    def _root_changed(self, name, old, new):
+        if self.parent is None:
+            if not (new is self):
+                raise ComponentError("Root not self, but parent is None.")
+        else:
+            if not self.parent.root is new:
+                raise ComponentError("Error in setting the root attribute: "
+                                     "root != parent.root")
+
+    def _config_changed(self, name, old, new):
+        """Update all the class traits having ``config=True`` as metadata.
+
+        For any class traitlet with a ``config`` metadata attribute that is
+        ``True``, we update the traitlet with the value of the corresponding
+        config entry.
+        """
+        # Get all traitlets with a config metadata entry that is True
+        traitlets = self.traitlets(config=True)
+
+        # We auto-load config section for this class as well as any parent
+        # classes that are Component subclasses.  This starts with Component
+        # and works down the mro loading the config for each section.
+        section_names = [cls.__name__ for cls in \
+            reversed(self.__class__.__mro__) if 
+            issubclass(cls, Component) and issubclass(self.__class__, cls)]
+
+        for sname in section_names:
+            # Don't do a blind getattr as that would cause the config to 
+            # dynamically create the section with name self.__class__.__name__.
+            if new._has_section(sname):
+                my_config = new[sname]
+                for k, v in traitlets.items():
+                    try:
+                        config_value = my_config[k]
+                    except KeyError:
+                        pass
+                    else:
+                        # print "Setting %s.%s from %s.%s=%r" % \
+                        #     (self.__class__.__name__,k,sname,k,config_value)
+                        setattr(self, k, config_value)
+
+    @property
+    def children(self):
+        """A list of all my child components."""
+        return self._children
+
+    def _remove_child(self, child):
+        """A private method for removing children components."""
+        if child in self._children:
+            index = self._children.index(child)
+            del self._children[index]
+
+    def _add_child(self, child):
+        """A private method for adding children components."""
+        if child not in self._children:
+            self._children.append(child)
+
+    def __repr__(self):
+        return "<%s('%s')>" % (self.__class__.__name__, self.name)

IPython/core/display_trap.py

@@ -0,0 +1,76 b''
+#!/usr/bin/env python
+# encoding: utf-8
+"""
+A context manager for handling sys.displayhook.
+
+Authors:
+
+* Robert Kern
+* 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 sys
+
+from IPython.core.component import Component
+
+from IPython.utils.autoattr import auto_attr
+
+#-----------------------------------------------------------------------------
+# Classes and functions
+#-----------------------------------------------------------------------------
+
+
+class DisplayTrap(Component):
+    """Object to manage sys.displayhook.
+
+    This came from IPython.core.kernel.display_hook, but is simplified
+    (no callbacks or formatters) until more of the core is refactored.
+    """
+
+    def __init__(self, parent, hook):
+        super(DisplayTrap, self).__init__(parent, None, None)
+        self.hook = hook
+        self.old_hook = None
+        # We define this to track if a single BuiltinTrap is nested.
+        # Only turn off the trap when the outermost call to __exit__ is made.
+        self._nested_level = 0
+
+    @auto_attr
+    def shell(self):
+        return Component.get_instances(
+            root=self.root,
+            klass='IPython.core.iplib.InteractiveShell')[0]
+
+    def __enter__(self):
+        if self._nested_level == 0:
+            self.set()
+        self._nested_level += 1
+        return self
+
+    def __exit__(self, type, value, traceback):
+        if self._nested_level == 1:
+            self.unset()
+        self._nested_level -= 1
+        return True
+
+    def set(self):
+        """Set the hook."""
+        if sys.displayhook is not self.hook:
+            self.old_hook = sys.displayhook
+            sys.displayhook = self.hook
+
+    def unset(self):
+        """Unset the hook."""
+        sys.displayhook = self.old_hook
+

IPython/core/embed.py

@@ -0,0 +1,280 b''
+#!/usr/bin/env python
+# encoding: utf-8
+"""
+An embedded IPython shell.
+
+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
+#-----------------------------------------------------------------------------
+
+from __future__ import with_statement
+
+import sys
+from contextlib import nested
+
+from IPython.core import ultratb
+from IPython.core.iplib import InteractiveShell
+from IPython.core.ipapp import load_default_config
+
+from IPython.utils.traitlets import Bool, Str, CBool
+from IPython.utils.genutils import ask_yes_no
+
+
+#-----------------------------------------------------------------------------
+# Classes and functions
+#-----------------------------------------------------------------------------
+
+# This is an additional magic that is exposed in embedded shells.
+def kill_embedded(self,parameter_s=''):
+    """%kill_embedded : deactivate for good the current embedded IPython.
+
+    This function (after asking for confirmation) sets an internal flag so that
+    an embedded IPython will never activate again.  This is useful to
+    permanently disable a shell that is being called inside a loop: once you've
+    figured out what you needed from it, you may then kill it and the program
+    will then continue to run without the interactive shell interfering again.
+    """
+    
+    kill = ask_yes_no("Are you sure you want to kill this embedded instance "
+                     "(y/n)? [y/N] ",'n')
+    if kill:
+        self.embedded_active = False
+        print "This embedded IPython will not reactivate anymore once you exit."
+
+
+class InteractiveShellEmbed(InteractiveShell):
+
+    dummy_mode = Bool(False)
+    exit_msg = Str('')
+    embedded = CBool(True)
+    embedded_active = CBool(True)
+    # Like the base class display_banner is not configurable, but here it
+    # is True by default.
+    display_banner = CBool(True)
+
+    def __init__(self, parent=None, config=None, ipythondir=None, usage=None,
+                 user_ns=None, user_global_ns=None,
+                 banner1=None, banner2=None, display_banner=None,
+                 custom_exceptions=((),None), exit_msg=''):
+
+        self.save_sys_ipcompleter()
+
+        super(InteractiveShellEmbed,self).__init__(
+            parent=parent, config=config, ipythondir=ipythondir, usage=usage, 
+            user_ns=user_ns, user_global_ns=user_global_ns,
+            banner1=banner1, banner2=banner2, display_banner=display_banner,
+            custom_exceptions=custom_exceptions)
+
+        self.exit_msg = exit_msg
+        self.define_magic("kill_embedded", kill_embedded)
+
+        # don't use the ipython crash handler so that user exceptions aren't
+        # trapped
+        sys.excepthook = ultratb.FormattedTB(color_scheme=self.colors,
+                                             mode=self.xmode,
+                                             call_pdb=self.pdb)
+
+        self.restore_sys_ipcompleter()
+
+    def init_sys_modules(self):
+        pass
+
+    def save_sys_ipcompleter(self):
+        """Save readline completer status."""
+        try:
+            #print 'Save completer',sys.ipcompleter  # dbg
+            self.sys_ipcompleter_orig = sys.ipcompleter
+        except:
+            pass # not nested with IPython        
+
+    def restore_sys_ipcompleter(self):
+        """Restores the readline completer which was in place.
+
+        This allows embedded IPython within IPython not to disrupt the
+        parent's completion.
+        """
+        try:
+            self.readline.set_completer(self.sys_ipcompleter_orig)
+            sys.ipcompleter = self.sys_ipcompleter_orig
+        except:
+            pass
+
+    def __call__(self, header='', local_ns=None, global_ns=None, dummy=None,
+                 stack_depth=1):
+        """Activate the interactive interpreter.
+
+        __call__(self,header='',local_ns=None,global_ns,dummy=None) -> Start
+        the interpreter shell with the given local and global namespaces, and
+        optionally print a header string at startup.
+
+        The shell can be globally activated/deactivated using the
+        set/get_dummy_mode methods. This allows you to turn off a shell used
+        for debugging globally.
+
+        However, *each* time you call the shell you can override the current
+        state of dummy_mode with the optional keyword parameter 'dummy'. For
+        example, if you set dummy mode on with IPShell.set_dummy_mode(1), you
+        can still have a specific call work by making it as IPShell(dummy=0).
+
+        The optional keyword parameter dummy controls whether the call
+        actually does anything.
+        """
+
+        # If the user has turned it off, go away
+        if not self.embedded_active:
+            return
+
+        # Normal exits from interactive mode set this flag, so the shell can't
+        # re-enter (it checks this variable at the start of interactive mode).
+        self.exit_now = False
+
+        # Allow the dummy parameter to override the global __dummy_mode
+        if dummy or (dummy != 0 and self.dummy_mode):
+            return
+
+        if self.has_readline:
+            self.set_completer()
+
+        # self.banner is auto computed
+        if header:
+            self.old_banner2 = self.banner2
+            self.banner2 = self.banner2 + '\n' + header + '\n'
+
+        # Call the embedding code with a stack depth of 1 so it can skip over
+        # our call and get the original caller's namespaces.
+        self.mainloop(local_ns, global_ns, stack_depth=stack_depth)
+
+        self.banner2 = self.old_banner2
+
+        if self.exit_msg is not None:
+            print self.exit_msg
+
+        self.restore_sys_ipcompleter()
+
+    def mainloop(self, local_ns=None, global_ns=None, stack_depth=0,
+                 display_banner=None):
+        """Embeds IPython into a running python program.
+
+        Input:
+
+          - header: An optional header message can be specified.
+
+          - local_ns, global_ns: working namespaces. If given as None, the
+          IPython-initialized one is updated with __main__.__dict__, so that
+          program variables become visible but user-specific configuration
+          remains possible.
+
+          - stack_depth: specifies how many levels in the stack to go to
+          looking for namespaces (when local_ns and global_ns are None).  This
+          allows an intermediate caller to make sure that this function gets
+          the namespace from the intended level in the stack.  By default (0)
+          it will get its locals and globals from the immediate caller.
+
+        Warning: it's possible to use this in a program which is being run by
+        IPython itself (via %run), but some funny things will happen (a few
+        globals get overwritten). In the future this will be cleaned up, as
+        there is no fundamental reason why it can't work perfectly."""
+
+        # Get locals and globals from caller
+        if local_ns is None or global_ns is None:
+            call_frame = sys._getframe(stack_depth).f_back
+
+            if local_ns is None:
+                local_ns = call_frame.f_locals
+            if global_ns is None:
+                global_ns = call_frame.f_globals
+
+        # Update namespaces and fire up interpreter
+
+        # The global one is easy, we can just throw it in
+        self.user_global_ns = global_ns
+
+        # but the user/local one is tricky: ipython needs it to store internal
+        # data, but we also need the locals.  We'll copy locals in the user
+        # one, but will track what got copied so we can delete them at exit.
+        # This is so that a later embedded call doesn't see locals from a
+        # previous call (which most likely existed in a separate scope).
+        local_varnames = local_ns.keys()
+        self.user_ns.update(local_ns)
+        #self.user_ns['local_ns'] = local_ns  # dbg
+
+        # Patch for global embedding to make sure that things don't overwrite
+        # user globals accidentally. Thanks to Richard <[e-mail]>
+        # FIXME. Test this a bit more carefully (the if.. is new)
+        if local_ns is None and global_ns is None:
+            self.user_global_ns.update(__main__.__dict__)
+
+        # make sure the tab-completer has the correct frame information, so it
+        # actually completes using the frame's locals/globals
+        self.set_completer_frame()
+
+        with nested(self.builtin_trap, self.display_trap):
+            self.interact(display_banner=display_banner)
+        
+            # now, purge out the user namespace from anything we might have added
+            # from the caller's local namespace
+            delvar = self.user_ns.pop
+            for var in local_varnames:
+                delvar(var,None)
+
+    def set_completer_frame(self, frame=None):
+        if frame:
+            self.Completer.namespace = frame.f_locals
+            self.Completer.global_namespace = frame.f_globals
+        else:
+            self.Completer.namespace = self.user_ns
+            self.Completer.global_namespace = self.user_global_ns
+
+
+_embedded_shell = None
+
+
+def embed(header='', config=None, usage=None, banner1=None, banner2=None,
+          display_banner=True, exit_msg=''):
+    """Call this to embed IPython at the current point in your program.
+
+    The first invocation of this will create an :class:`InteractiveShellEmbed`
+    instance and then call it.  Consecutive calls just call the already
+    created instance.
+
+    Here is a simple example::
+
+        from IPython import embed
+        a = 10
+        b = 20
+        embed('First time')
+        c = 30
+        d = 40
+        embed
+
+    Full customization can be done by passing a :class:`Struct` in as the 
+    config argument.
+    """
+    if config is None:
+        config = load_default_config()
+        config.InteractiveShellEmbed = config.InteractiveShell
+    global _embedded_shell
+    if _embedded_shell is None:
+        _embedded_shell = InteractiveShellEmbed(
+            config=config, usage=usage, 
+            banner1=banner1, banner2=banner2, 
+            display_banner=display_banner, exit_msg=exit_msg
+        )
+    _embedded_shell(header=header, stack_depth=2)
+

IPython/core/error.py

@@ -0,0 +1,52 b''
+#!/usr/bin/env python
+# encoding: utf-8
+"""
+Global exception classes for IPython.core.
+
+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
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Exception classes
+#-----------------------------------------------------------------------------
+
+class IPythonCoreError(Exception):
+    pass
+
+
+class TryNext(IPythonCoreError):
+    """Try next hook exception.
+     
+    Raise this in your hook function to indicate that the next hook handler
+    should be used to handle the operation.  If you pass arguments to the
+    constructor those arguments will be used by the next hook instead of the
+    original ones.
+    """
+
+    def __init__(self, *args, **kwargs):
+        self.args = args
+        self.kwargs = kwargs
+
+class UsageError(IPythonCoreError):
+    """Error in magic function arguments, etc.
+    
+    Something that probably won't warrant a full traceback, but should
+    nevertheless interrupt a macro / batch file.   
+    """
  No newline at end of file

IPython/core/ipapp.py

@@ -0,0 +1,546 b''
+#!/usr/bin/env python
+# encoding: utf-8
+"""
+The main IPython application object
+
+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
+import warnings
+
+from IPython.core.application import Application, IPythonArgParseConfigLoader
+from IPython.core import release
+from IPython.core.iplib import InteractiveShell
+from IPython.config.loader import (
+    NoConfigDefault, 
+    Config,
+    ConfigError,
+    PyFileConfigLoader
+)
+
+from IPython.lib import inputhook
+
+from IPython.utils.ipstruct import Struct
+from IPython.utils.genutils import filefind, get_ipython_dir
+
+#-----------------------------------------------------------------------------
+# Utilities and helpers
+#-----------------------------------------------------------------------------
+
+
+ipython_desc = """
+A Python shell with automatic history (input and output), dynamic object
+introspection, easier configuration, command completion, access to the system
+shell and more.
+"""
+
+def pylab_warning():
+    msg = """
+
+IPython's -pylab mode has been disabled until matplotlib supports this version
+of IPython.  This version of IPython has greatly improved GUI integration that 
+matplotlib will soon be able to take advantage of.  This will eventually
+result in greater stability and a richer API for matplotlib under IPython.
+However during this transition, you will either need to use an older version
+of IPython, or do the following to use matplotlib interactively::
+
+    import matplotlib
+    matplotlib.interactive(True)
+    matplotlib.use('wxagg')  # adjust for your backend
+    %gui -a wx               # adjust for your GUI
+    from matplotlib import pyplot as plt
+
+See the %gui magic for information on the new interface.
+"""
+    warnings.warn(msg, category=DeprecationWarning, stacklevel=1)
+
+
+#-----------------------------------------------------------------------------
+# Main classes and functions
+#-----------------------------------------------------------------------------
+
+cl_args = (
+    (('-autocall',), dict(
+        type=int, dest='InteractiveShell.autocall', default=NoConfigDefault,
+        help='Set the autocall value (0,1,2).',
+        metavar='InteractiveShell.autocall')
+    ),
+    (('-autoindent',), dict(
+        action='store_true', dest='InteractiveShell.autoindent', default=NoConfigDefault,
+        help='Turn on autoindenting.')
+    ),
+    (('-noautoindent',), 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.')
+    ),
+    (('-noautomagic',), 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.')
+    ),
+    (('-noautoedit_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.')
+    ),
+    (('-nobanner',), 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,
+        help="Set the size of the output cache.",
+        metavar='InteractiveShell.cache_size')
+    ),
+    (('-classic',), dict(
+        action='store_true', dest='Global.classic', default=NoConfigDefault,
+        help="Gives IPython a similar feel to the classic Python prompt.")
+    ),
+    (('-colors',), dict(
+        type=str, dest='InteractiveShell.colors', default=NoConfigDefault,
+        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="Enable using colors for info related things.")
+    ),
+    (('-nocolor_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="Prompt the user when existing.")
+    ),
+    (('-noconfirm_exit',), dict(
+        action='store_false', dest='InteractiveShell.confirm_exit', default=NoConfigDefault,
+        help="Don't prompt the user when existing.")
+    ),
+    (('-deep_reload',), dict(
+        action='store_true', dest='InteractiveShell.deep_reload', default=NoConfigDefault,
+        help="Enable deep (recursive) reloading by default.")
+    ),
+    (('-nodeep_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,
+        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 file (./ipython_log.py).")
+    ),
+    (('-logfile','-lf'), dict(
+        type=str, dest='InteractiveShell.logfile', default=NoConfigDefault,
+        help="Start logging to logfile.",
+        metavar='InteractiveShell.logfile')
+    ),
+    (('-logappend','-la'), dict(
+        type=str, dest='InteractiveShell.logappend', default=NoConfigDefault,
+        help="Start logging to logappend 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.")
+    ),
+    (('-nopdb',), 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.")
+    ),
+    (('-nopprint',), 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,
+        help="Set the main input prompt ('In [\#]: ')",
+        metavar='InteractiveShell.prompt_in1')
+    ),
+    (('-prompt_in2','-pi2'), dict(
+        type=str, dest='InteractiveShell.prompt_in2', default=NoConfigDefault,
+        help="Set the secondary input prompt (' .\D.: ')",
+        metavar='InteractiveShell.prompt_in2')
+    ),
+    (('-prompt_out','-po'), dict(
+        type=str, dest='InteractiveShell.prompt_out', default=NoConfigDefault,
+        help="Set the output prompt ('Out[\#]:')",
+        metavar='InteractiveShell.prompt_out')
+    ),
+    (('-quick',), dict(
+        action='store_true', dest='Global.quick', default=NoConfigDefault,
+        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.")
+    ),
+    (('-noreadline',), 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 on screen, used to control printing of long strings.',
+        metavar='InteractiveShell.screen_length')
+    ),
+    (('-separate_in','-si'), dict(
+        type=str, dest='InteractiveShell.separate_in', default=NoConfigDefault,
+        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')
+    ),
+    (('-nosep',), dict(
+        action='store_true', dest='Global.nosep', default=NoConfigDefault,
+        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.")
+    ),
+    (('-noterm_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,
+        help="Exception mode ('Plain','Context','Verbose')",
+        metavar='InteractiveShell.xmode')
+    ),
+    (('-ext',), dict(
+        type=str, dest='Global.extra_extension', default=NoConfigDefault,
+        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,
+        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.")
+    ),
+    (('-wthread',), dict(
+        action='store_true', dest='Global.wthread', default=NoConfigDefault,
+        help="Enable wxPython event loop integration.")
+    ),
+    (('-q4thread','-qthread'), dict(
+        action='store_true', dest='Global.q4thread', default=NoConfigDefault,
+        help="Enable Qt4 event loop integration. Qt3 is no longer supported.")
+    ),
+    (('-gthread',), dict(
+        action='store_true', dest='Global.gthread', default=NoConfigDefault,
+        help="Enable GTK event loop integration.")
+    ),
+    # # These are only here to get the proper deprecation warnings
+    (('-pylab',), dict(
+        action='store_true', dest='Global.pylab', default=NoConfigDefault,
+        help="Disabled.  Pylab has been disabled until matplotlib supports this version of IPython.")
+    )
+)
+
+
+class IPythonAppCLConfigLoader(IPythonArgParseConfigLoader):
+
+    arguments = cl_args
+
+
+_default_config_file_name = 'ipython_config.py'
+
+class IPythonApp(Application):
+    name = 'ipython'
+    config_file_name = _default_config_file_name
+
+    def create_default_config(self):
+        super(IPythonApp, self).create_default_config()
+        self.default_config.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.
+        self.default_config.Global.force_interact = False
+
+        # By default always interact by starting the IPython mainloop.
+        self.default_config.Global.interact = True
+
+        # Let the parent class set the default, but each time log_level
+        # changes from config, we need to update self.log_level as that is
+        # what updates the actual log level in self.log.
+        self.default_config.Global.log_level = self.log_level
+
+        # No GUI integration by default
+        self.default_config.Global.wthread = False
+        self.default_config.Global.q4thread = False
+        self.default_config.Global.gthread = False
+
+    def create_command_line_config(self):
+        """Create and return a command line config loader."""
+        return IPythonAppCLConfigLoader(
+            description=ipython_desc,
+            version=release.version)
+
+    def post_load_command_line_config(self):
+        """Do actions after loading cl config."""
+        clc = self.command_line_config
+
+        # Display the deprecation warnings about threaded shells
+        if hasattr(clc.Global, 'pylab'):
+            pylab_warning()
+            del clc.Global['pylab']
+
+    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(
+            parent=None,
+            config=self.master_config
+        )
+
+    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()
+        self._load_extensions()
+        self._run_exec_lines()
+        self._run_exec_files()
+        self._run_cmd_line_code()
+
+    def _enable_gui(self):
+        """Enable GUI event loop integration."""
+        config = self.master_config
+        try:
+            # Enable GUI integration
+            if config.Global.wthread:
+                self.log.info("Enabling wx GUI event loop integration")
+                inputhook.enable_wx(app=True)
+            elif config.Global.q4thread:
+                self.log.info("Enabling Qt4 GUI event loop integration")
+                inputhook.enable_qt4(app=True)
+            elif config.Global.gthread:
+                self.log.info("Enabling GTK GUI event loop integration")
+                inputhook.enable_gtk(app=True)
+        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, ['.', self.ipythondir])
+        if os.path.isfile(full_filename):
+            if full_filename.endswith('.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 start_app(self):
+        if self.master_config.Global.interact:
+            self.log.debug("Starting IPython's mainloop...")
+            self.shell.mainloop()
+
+
+def load_default_config(ipythondir=None):
+    """Load the default config file from the default ipythondir.
+
+    This is useful for embedded shells.
+    """
+    if ipythondir is None:
+        ipythondir = get_ipython_dir()
+    cl = PyFileConfigLoader(_default_config_file_name, ipythondir)
+    config = cl.load_config()
+    return config
+
+
+def launch_new_instance():
+    """Create a run a full blown IPython instance"""
+    app = IPythonApp()
+    app.start()
+

IPython/core/oldusersetup.py

@@ -0,0 +1,219 b''
+# -*- coding: utf-8 -*-
+"""
+Main IPython Component
+"""
+
+#-----------------------------------------------------------------------------
+#  Copyright (C) 2001 Janko Hauser <[e-mail]>
+#  Copyright (C) 2001-2007 Fernando Perez. <[e-mail]>
+#  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 glob
+import os
+import shutil
+import sys
+
+from IPython.utils.genutils import *
+
+def user_setup(ipythondir,rc_suffix,mode='install',interactive=True):
+    """Install or upgrade the user configuration directory.
+
+    Can be called when running for the first time or to upgrade the user's
+    .ipython/ directory.
+
+    Parameters
+    ----------
+      ipythondir : path
+        The directory to be used for installation/upgrade.  In 'install' mode,
+        if this path already exists, the function exits immediately.
+
+      rc_suffix : str
+        Extension for the config files.  On *nix platforms it is typically the
+        empty string, while Windows normally uses '.ini'.
+
+      mode : str, optional
+        Valid modes are 'install' and 'upgrade'.
+
+      interactive : bool, optional
+        If False, do not wait for user input on any errors.  Normally after
+        printing its status information, this function waits for the user to
+        hit Return before proceeding.  This is because the default use case is
+        when first installing the IPython configuration, so we want the user to
+        acknowledge the initial message, which contains some useful
+        information.
+        """
+
+    # For automatic use, deactivate all i/o
+    if interactive:
+        def wait():
+            try:
+                raw_input("Please press <RETURN> to start IPython.")
+            except EOFError:
+                print >> Term.cout
+            print '*'*70
+
+        def printf(s):
+            print s
+    else:
+        wait = lambda : None
+        printf = lambda s : None
+
+    # Install mode should be re-entrant: if the install dir already exists,
+    # bail out cleanly.
+    # XXX.  This is too hasty to return.  We need to check to make sure that
+    # all the expected config files and directories are actually there. We
+    # currently have a failure mode if someone deletes a needed config file
+    # but still has the ipythondir.
+    if mode == 'install' and os.path.isdir(ipythondir):
+        return
+
+    cwd = os.getcwd()  # remember where we started
+    glb = glob.glob
+
+    printf('*'*70)
+    if mode == 'install':
+        printf(
+"""Welcome to IPython. I will try to create a personal configuration directory
+where you can customize many aspects of IPython's functionality in:\n""")
+    else:
+        printf('I am going to upgrade your configuration in:')
+
+    printf(ipythondir)
+
+    rcdirend = os.path.join('IPython','config','userconfig')
+    cfg = lambda d: os.path.join(d,rcdirend)
+    try:
+        rcdir = filter(os.path.isdir,map(cfg,sys.path))[0]
+        printf("Initializing from configuration: %s" % rcdir)
+    except IndexError:
+        warning = """
+Installation error. IPython's directory was not found.
+
+Check the following:
+
+The ipython/IPython directory should be in a directory belonging to your
+PYTHONPATH environment variable (that is, it should be in a directory
+belonging to sys.path). You can copy it explicitly there or just link to it.
+
+IPython will create a minimal default configuration for you.
+
+"""
+        warn(warning)
+        wait()
+
+        if sys.platform =='win32':
+            inif = 'ipythonrc.ini'
+        else:
+            inif = 'ipythonrc'
+        minimal_setup = {'ipy_user_conf.py' : 'import ipy_defaults',
+                         inif : '# intentionally left blank' }
+        os.makedirs(ipythondir, mode = 0777)
+        for f, cont in minimal_setup.items():
+            # In 2.5, this can be more cleanly done using 'with'
+            fobj = file(ipythondir + '/' + f,'w')
+            fobj.write(cont)
+            fobj.close()
+
+        return
+
+    if mode == 'install':
+        try:
+            shutil.copytree(rcdir,ipythondir)
+            os.chdir(ipythondir)
+            rc_files = glb("ipythonrc*")
+            for rc_file in rc_files:
+                os.rename(rc_file,rc_file+rc_suffix)
+        except:
+            warning = """
+
+There was a problem with the installation:
+%s
+Try to correct it or contact the developers if you think it's a bug.
+IPython will proceed with builtin defaults.""" % sys.exc_info()[1]
+            warn(warning)
+            wait()
+            return
+
+    elif mode == 'upgrade':
+        try:
+            os.chdir(ipythondir)
+        except:
+            printf("""
+Can not upgrade: changing to directory %s failed. Details:
+%s
+""" % (ipythondir,sys.exc_info()[1]) )
+            wait()
+            return
+        else:
+            sources = glb(os.path.join(rcdir,'[A-Za-z]*'))
+            for new_full_path in sources:
+                new_filename = os.path.basename(new_full_path)
+                if new_filename.startswith('ipythonrc'):
+                    new_filename = new_filename + rc_suffix
+                # The config directory should only contain files, skip any
+                # directories which may be there (like CVS)
+                if os.path.isdir(new_full_path):
+                    continue
+                if os.path.exists(new_filename):
+                    old_file = new_filename+'.old'
+                    if os.path.exists(old_file):
+                        os.remove(old_file)
+                    os.rename(new_filename,old_file)
+                shutil.copy(new_full_path,new_filename)
+    else:
+        raise ValueError('unrecognized mode for install: %r' % mode)
+
+    # Fix line-endings to those native to each platform in the config
+    # directory.
+    try:
+        os.chdir(ipythondir)
+    except:
+        printf("""
+Problem: changing to directory %s failed.
+Details:
+%s
+
+Some configuration files may have incorrect line endings.  This should not
+cause any problems during execution.  """ % (ipythondir,sys.exc_info()[1]) )
+        wait()
+    else:
+        for fname in glb('ipythonrc*'):
+            try:
+                native_line_ends(fname,backup=0)
+            except IOError:
+                pass
+
+    if mode == 'install':
+        printf("""
+Successful installation!
+
+Please read the sections 'Initial Configuration' and 'Quick Tips' in the
+IPython manual (there are both HTML and PDF versions supplied with the
+distribution) to make sure that your system environment is properly configured
+to take advantage of IPython's features.
+
+Important note: the configuration system has changed! The old system is
+still in place, but its setting may be partly overridden by the settings in 
+"~/.ipython/ipy_user_conf.py" config file. Please take a look at the file 
+if some of the new settings bother you. 
+
+""")
+    else:
+        printf("""
+Successful upgrade!
+
+All files in your directory:
+%(ipythondir)s
+which would have been overwritten by the upgrade were backed up with a .old
+extension.  If you had made particular customizations in those files you may
+want to merge them back into the new files.""" % locals() )
+    wait()
+    os.chdir(cwd)
  No newline at end of file

IPython/core/page.py

@@ -0,0 +1,308 b''
+#!/usr/bin/env python
+# encoding: utf-8
+"""
+Paging capabilities for IPython.core
+
+Authors:
+
+* Brian Granger
+* Fernando Perez
+
+Notes
+-----
+
+For now this uses ipapi, so it can't be in IPython.utils.  If we can get
+rid of that dependency, we could move it there.
+-----
+"""
+
+#-----------------------------------------------------------------------------
+#  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 os
+import re
+import sys
+
+from IPython.core import ipapi
+from IPython.core.error import TryNext
+from IPython.utils.genutils import (
+    chop, Term, USE_CURSES
+)
+
+if os.name == "nt":
+    from IPython.utils.winconsole import get_console_size
+
+
+#-----------------------------------------------------------------------------
+# Classes and functions
+#-----------------------------------------------------------------------------
+
+esc_re = re.compile(r"(\x1b[^m]+m)")
+
+def page_dumb(strng,start=0,screen_lines=25):
+    """Very dumb 'pager' in Python, for when nothing else works.
+
+    Only moves forward, same interface as page(), except for pager_cmd and
+    mode."""
+
+    out_ln  = strng.splitlines()[start:]
+    screens = chop(out_ln,screen_lines-1)
+    if len(screens) == 1:
+        print >>Term.cout, os.linesep.join(screens[0])
+    else:
+        last_escape = ""
+        for scr in screens[0:-1]:
+            hunk = os.linesep.join(scr)
+            print >>Term.cout, last_escape + hunk
+            if not page_more():
+                return
+            esc_list = esc_re.findall(hunk)
+            if len(esc_list) > 0:
+                last_escape = esc_list[-1]
+        print >>Term.cout, last_escape + os.linesep.join(screens[-1])
+
+#----------------------------------------------------------------------------
+def page(strng,start=0,screen_lines=0,pager_cmd = None):
+    """Print a string, piping through a pager after a certain length.
+
+    The screen_lines parameter specifies the number of *usable* lines of your
+    terminal screen (total lines minus lines you need to reserve to show other
+    information).
+
+    If you set screen_lines to a number <=0, page() will try to auto-determine
+    your screen size and will only use up to (screen_size+screen_lines) for
+    printing, paging after that. That is, if you want auto-detection but need
+    to reserve the bottom 3 lines of the screen, use screen_lines = -3, and for
+    auto-detection without any lines reserved simply use screen_lines = 0.
+
+    If a string won't fit in the allowed lines, it is sent through the
+    specified pager command. If none given, look for PAGER in the environment,
+    and ultimately default to less.
+
+    If no system pager works, the string is sent through a 'dumb pager'
+    written in python, very simplistic.
+    """
+
+    # Some routines may auto-compute start offsets incorrectly and pass a
+    # negative value.  Offset to 0 for robustness.
+    start = max(0,start)
+
+    # first, try the hook
+    ip = ipapi.get()
+    if ip:
+        try:
+            ip.hooks.show_in_pager(strng)
+            return
+        except TryNext:
+            pass
+
+    # Ugly kludge, but calling curses.initscr() flat out crashes in emacs
+    TERM = os.environ.get('TERM','dumb')
+    if TERM in ['dumb','emacs'] and os.name != 'nt':
+        print strng
+        return
+    # chop off the topmost part of the string we don't want to see
+    str_lines = strng.split(os.linesep)[start:]
+    str_toprint = os.linesep.join(str_lines)
+    num_newlines = len(str_lines)
+    len_str = len(str_toprint)
+
+    # Dumb heuristics to guesstimate number of on-screen lines the string
+    # takes.  Very basic, but good enough for docstrings in reasonable
+    # terminals. If someone later feels like refining it, it's not hard.
+    numlines = max(num_newlines,int(len_str/80)+1)
+
+    if os.name == "nt":
+        screen_lines_def = get_console_size(defaulty=25)[1]
+    else:
+        screen_lines_def = 25 # default value if we can't auto-determine
+
+    # auto-determine screen size
+    if screen_lines <= 0:
+        if TERM=='xterm' or TERM=='xterm-color':
+            use_curses = USE_CURSES
+        else:
+            # curses causes problems on many terminals other than xterm.
+            use_curses = False
+        if use_curses:
+            import termios
+            import curses
+            # There is a bug in curses, where *sometimes* it fails to properly
+            # initialize, and then after the endwin() call is made, the
+            # terminal is left in an unusable state.  Rather than trying to
+            # check everytime for this (by requesting and comparing termios
+            # flags each time), we just save the initial terminal state and
+            # unconditionally reset it every time.  It's cheaper than making
+            # the checks.
+            term_flags = termios.tcgetattr(sys.stdout)
+            scr = curses.initscr()
+            screen_lines_real,screen_cols = scr.getmaxyx()
+            curses.endwin()
+            # Restore terminal state in case endwin() didn't.
+            termios.tcsetattr(sys.stdout,termios.TCSANOW,term_flags)
+            # Now we have what we needed: the screen size in rows/columns
+            screen_lines += screen_lines_real
+            #print '***Screen size:',screen_lines_real,'lines x',\
+            #screen_cols,'columns.' # dbg
+        else:
+            screen_lines += screen_lines_def
+
+    #print 'numlines',numlines,'screenlines',screen_lines  # dbg
+    if numlines <= screen_lines :
+        #print '*** normal print'  # dbg
+        print >>Term.cout, str_toprint
+    else:
+        # Try to open pager and default to internal one if that fails.
+        # All failure modes are tagged as 'retval=1', to match the return
+        # value of a failed system command.  If any intermediate attempt
+        # sets retval to 1, at the end we resort to our own page_dumb() pager.
+        pager_cmd = get_pager_cmd(pager_cmd)
+        pager_cmd += ' ' + get_pager_start(pager_cmd,start)
+        if os.name == 'nt':
+            if pager_cmd.startswith('type'):
+                # The default WinXP 'type' command is failing on complex strings.
+                retval = 1
+            else:
+                tmpname = tempfile.mktemp('.txt')
+                tmpfile = file(tmpname,'wt')
+                tmpfile.write(strng)
+                tmpfile.close()
+                cmd = "%s < %s" % (pager_cmd,tmpname)
+                if os.system(cmd):
+                  retval = 1
+                else:
+                  retval = None
+                os.remove(tmpname)
+        else:
+            try:
+                retval = None
+                # if I use popen4, things hang. No idea why.
+                #pager,shell_out = os.popen4(pager_cmd)
+                pager = os.popen(pager_cmd,'w')
+                pager.write(strng)
+                pager.close()
+                retval = pager.close()  # success returns None
+            except IOError,msg:  # broken pipe when user quits
+                if msg.args == (32,'Broken pipe'):
+                    retval = None
+                else:
+                    retval = 1
+            except OSError:
+                # Other strange problems, sometimes seen in Win2k/cygwin
+                retval = 1
+        if retval is not None:
+            page_dumb(strng,screen_lines=screen_lines)
+
+#----------------------------------------------------------------------------
+def page_file(fname,start = 0, pager_cmd = None):
+    """Page a file, using an optional pager command and starting line.
+    """
+
+    pager_cmd = get_pager_cmd(pager_cmd)
+    pager_cmd += ' ' + get_pager_start(pager_cmd,start)
+
+    try:
+        if os.environ['TERM'] in ['emacs','dumb']:
+            raise EnvironmentError
+        xsys(pager_cmd + ' ' + fname)
+    except:
+        try:
+            if start > 0:
+                start -= 1
+            page(open(fname).read(),start)
+        except:
+            print 'Unable to show file',`fname`
+
+#----------------------------------------------------------------------------
+def get_pager_cmd(pager_cmd = None):
+    """Return a pager command.
+
+    Makes some attempts at finding an OS-correct one."""
+
+    if os.name == 'posix':
+        default_pager_cmd = 'less -r'  # -r for color control sequences
+    elif os.name in ['nt','dos']:
+        default_pager_cmd = 'type'
+
+    if pager_cmd is None:
+        try:
+            pager_cmd = os.environ['PAGER']
+        except:
+            pager_cmd = default_pager_cmd
+    return pager_cmd
+
+#-----------------------------------------------------------------------------
+def get_pager_start(pager,start):
+    """Return the string for paging files with an offset.
+
+    This is the '+N' argument which less and more (under Unix) accept.
+    """
+
+    if pager in ['less','more']:
+        if start:
+            start_string = '+' + str(start)
+        else:
+            start_string = ''
+    else:
+        start_string = ''
+    return start_string
+
+#----------------------------------------------------------------------------
+# (X)emacs on W32 doesn't like to be bypassed with msvcrt.getch()
+if os.name == 'nt' and os.environ.get('TERM','dumb') != 'emacs':
+    import msvcrt
+    def page_more():
+        """ Smart pausing between pages
+
+        @return:    True if need print more lines, False if quit
+        """
+        Term.cout.write('---Return to continue, q to quit--- ')
+        ans = msvcrt.getch()
+        if ans in ("q", "Q"):
+            result = False
+        else:
+            result = True
+        Term.cout.write("\b"*37 + " "*37 + "\b"*37)
+        return result
+else:
+    def page_more():
+        ans = raw_input('---Return to continue, q to quit--- ')
+        if ans.lower().startswith('q'):
+            return False
+        else:
+            return True
+
+#----------------------------------------------------------------------------
+def snip_print(str,width = 75,print_full = 0,header = ''):
+    """Print a string snipping the midsection to fit in width.
+
+    print_full: mode control:
+      - 0: only snip long strings
+      - 1: send to page() directly.
+      - 2: snip long strings and ask for full length viewing with page()
+    Return 1 if snipping was necessary, 0 otherwise."""
+
+    if print_full == 1:
+        page(header+str)
+        return 0
+
+    print header,
+    if len(str) < width:
+        print str
+        snip = 0
+    else:
+        whalf = int((width -5)/2)
+        print str[:whalf] + ' <...> ' + str[-whalf:]
+        snip = 1
+    if snip and print_full == 2:
+        if raw_input(header+' Snipped. View (y/n)? [N]').lower() == 'y':
+            page(str)
+    return snip
  No newline at end of file

IPython/core/quitter.py

@@ -0,0 +1,38 b''
+#!/usr/bin/env python
+# encoding: utf-8
+"""
+A simple class for quitting IPython.
+
+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
+#-----------------------------------------------------------------------------
+
+
+class Quitter(object):
+    """Simple class to handle exit, similar to Python 2.5's.
+
+    It handles exiting in an ipython-safe manner, which the one in Python 2.5
+    doesn't do (obviously, since it doesn't know about ipython)."""
+    
+    def __init__(self, shell, name):
+        self.shell = shell
+        self.name = name
+        
+    def __repr__(self):
+        return 'Type %s() to exit.' % self.name
+    __str__ = __repr__
+
+    def __call__(self):
+        self.shell.exit()
  No newline at end of file

IPython/core/splitinput.py

@@ -0,0 +1,83 b''
+#!/usr/bin/env python
+# encoding: utf-8
+"""
+Simple utility for splitting user input.
+
+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 re
+
+#-----------------------------------------------------------------------------
+# Main function
+#-----------------------------------------------------------------------------
+
+
+# RegExp for splitting line contents into pre-char//first word-method//rest.
+# For clarity, each group in on one line.
+
+# WARNING: update the regexp if the escapes in iplib are changed, as they
+# are hardwired in.
+
+# Although it's not solely driven by the regex, note that:
+# ,;/% only trigger if they are the first character on the line
+# ! and !! trigger if they are first char(s) *or* follow an indent 
+# ? triggers as first or last char.
+
+# The three parts of the regex are:
+#  1) pre:     pre_char *or* initial whitespace 
+#  2) ifun:    first word/method (mix of \w and '.')
+#  3) the_rest: rest of line (separated from ifun by space if non-empty)
+line_split = re.compile(r'^([,;/%?]|!!?|\s*)'
+                        r'\s*([\w\.]+)'
+                        r'(\s+.*$|$)')
+
+# r'[\w\.]+'
+# r'\s*=\s*%.*'
+
+def split_user_input(line, pattern=None):
+    """Split user input into pre-char/whitespace, function part and rest.
+
+    This is currently handles lines with '=' in them in a very inconsistent
+    manner.
+    """
+
+    if pattern is None:
+        pattern = line_split
+    match = pattern.match(line)
+    if not match:
+        # print "match failed for line '%s'" % line
+        try:
+            ifun, the_rest = line.split(None,1)
+        except ValueError:
+            # print "split failed for line '%s'" % line
+            ifun, the_rest = line,''
+        pre = re.match('^(\s*)(.*)',line).groups()[0]
+    else:
+        pre,ifun,the_rest = match.groups()
+
+    # ifun has to be a valid python identifier, so it better be only pure
+    # ascii, no unicode:
+    try:
+        ifun = ifun.encode('ascii')
+    except UnicodeEncodeError:
+        the_rest = ifun + u' ' + the_rest
+        ifun = u''
+
+    #print 'line:<%s>' % line # dbg
+    #print 'pre <%s> ifun <%s> rest <%s>' % (pre,ifun.strip(),the_rest) # dbg
+    return pre, ifun.strip(), the_rest.lstrip()

IPython/Shell.py

@@ -19,11 +19,24 b' the new code in IPython.core.shell.'
 from warnings import warn
 
 msg = """
-This module (IPython.Shell) has been moved to a new location
-(IPython.core.shell) and is being refactored.  Please update your code
-to use the new IPython.core.shell module"""
+This module (IPython.Shell) is deprecated.  The classes that were in this
+module have been replaced by:
+
+IPShell->IPython.core.iplib.InteractiveShell
+IPShellEmbed->IPython.core.embed.InteractiveShellEmbed
+
+Please migrate your code to use these classes instead.
+"""
 
 warn(msg, category=DeprecationWarning, stacklevel=1)
 
-from IPython.core.shell import start, IPShell, IPShellEmbed
+from IPython.core.iplib import InteractiveShell as IPShell
+from IPython.core.embed import InteractiveShellEmbed as IPShellEmbed
+
+def start(user_ns=None, embedded=False):
+    """Return an instance of :class:`InteractiveShell`."""
+    if embedded:
+        return InteractiveShellEmbed(user_ns=user_ns)
+    else:
+        return InteractiveShell(user_ns=user_ns)
 

IPython/__init__.py

@@ -1,67 +1,47 b''
- # -*- coding: utf-8 -*-
+#!/usr/bin/env python
+# encoding: utf-8
 """
-IPython -- An enhanced Interactive Python
+IPython.
 
-One of Python's nicest features is its interactive interpreter. This allows
-very fast testing of ideas without the overhead of creating test files as is
-typical in most programming languages. However, the interpreter supplied with
-the standard Python distribution is fairly primitive (and IDLE isn't really
-much better).
-
-IPython tries to:
-
-  i - provide an efficient environment for interactive work in Python
-  programming. It tries to address what we see as shortcomings of the standard
-  Python prompt, and adds many features to make interactive work much more
-  efficient.
-
-  ii - offer a flexible framework so that it can be used as the base
-  environment for other projects and problems where Python can be the
-  underlying language. Specifically scientific environments like Mathematica,
-  IDL and Mathcad inspired its design, but similar ideas can be useful in many
-  fields. Python is a fabulous language for implementing this kind of system
-  (due to its dynamic and introspective features), and with suitable libraries
-  entire systems could be built leveraging Python's power.
-
-  iii - serve as an embeddable, ready to go interpreter for your own programs.
-
-IPython requires Python 2.4 or newer.
+IPython is a set of tools for interactive and exploratory computing in Python.
 """
 
-#*****************************************************************************
-#       Copyright (C) 2008-2009 The IPython Development Team
-#       Copyright (C) 2001-2007 Fernando Perez. <[e-mail]>
+#-----------------------------------------------------------------------------
+#  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
+#-----------------------------------------------------------------------------
 
-# Enforce proper version requirements
+import os
 import sys
+from IPython.core import release
+
+#-----------------------------------------------------------------------------
+# Setup everything
+#-----------------------------------------------------------------------------
+
 
 if sys.version[0:3] < '2.4':
     raise ImportError('Python Version 2.4 or above is required for IPython.')
 
+
 # Make it easy to import extensions - they are always directly on pythonpath.
 # Therefore, non-IPython modules can be added to extensions directory
-import os
 sys.path.append(os.path.join(os.path.dirname(__file__), "extensions"))
 
-# Define what gets imported with a 'from IPython import *'
-__all__ = ['IPython.core.ipapi','utils.generics','utils.ipstruct',
-    'core.release','core.shell']
-
-# Load __all__ in IPython namespace so that a simple 'import IPython' gives
-# access to them via IPython.<name>
-glob,loc = globals(),locals()
-for name in __all__:
-    #print 'Importing: ',name # dbg
-    __import__(name,glob,loc,[])
+#-----------------------------------------------------------------------------
+# Setup the top level names
+#-----------------------------------------------------------------------------
 
-from IPython.core import shell
-Shell = shell
-from IPython.core import ipapi
-from IPython.core import iplib
+# In some cases, these are causing circular imports.
+from IPython.core.iplib import InteractiveShell
+from IPython.core.embed import embed
+from IPython.core.error import TryNext
 
 from IPython.lib import (
     enable_wx, disable_wx,
@@ -75,13 +55,10 b' from IPython.lib import ('
 )
 
 # Release data
-from IPython.core import release # do it explicitly so pydoc can see it - pydoc bug
-__author__   = '%s <%s>\n%s <%s>\n%s <%s>' % \
-               ( release.authors['Fernando'] + release.authors['Janko'] + \
-                 release.authors['Nathan'] )
+__author__ = ''
+for author, email in release.authors.values():
+    __author__ += author + ' <' + email + '>\n'
 __license__  = release.license
 __version__  = release.version
 __revision__ = release.revision
 
-# Namespace cleanup
-del name,glob,loc

IPython/config/tests/test_imports.py

@@ -1,10 +1,5 b''
 #!/usr/bin/env python
 # encoding: utf-8
 
-def test_import_configloader():
-    from IPython.config import configloader
-
-def test_import_userconfig():
-    from IPython.config import userconfig
 
 

IPython/core/completer.py

@@ -65,17 +65,20 b' used, and this module (and the readline module) are silently inactive.'
 import __builtin__
 import __main__
 import glob
+import itertools
 import keyword
 import os
 import re
 import shlex
 import sys
-import IPython.utils.rlineimpl as readline    
-import itertools
+import types
+
+from IPython.core.error import TryNext
+from IPython.core.prefilter import ESC_MAGIC
+
+import IPython.utils.rlineimpl as readline
 from IPython.utils.ipstruct import Struct
-from IPython.core import ipapi
 from IPython.utils import generics
-import types
 
 # Python 2.4 offers sets as a builtin
 try:
@@ -195,7 +198,7 b' class Completer:'
         
         try:
             words = generics.complete_object(obj, words)
-        except ipapi.TryNext:
+        except TryNext:
             pass
         # Build match list to return
         n = len(attr)
@@ -233,7 +236,7 b' class IPCompleter(Completer):'
 
         Completer.__init__(self,namespace,global_namespace)
         self.magic_prefix = shell.name+'.magic_'
-        self.magic_escape = shell.ESC_MAGIC
+        self.magic_escape = ESC_MAGIC
         self.readline = readline
         delims = self.readline.get_completer_delims()
         delims = delims.replace(self.magic_escape,'')
@@ -241,7 +244,7 b' class IPCompleter(Completer):'
         self.get_line_buffer = self.readline.get_line_buffer
         self.get_endidx = self.readline.get_endidx
         self.omit__names = omit__names
-        self.merge_completions = shell.rc.readline_merge_completions        
+        self.merge_completions = shell.readline_merge_completions        
         if alias_table is None:
             alias_table = {}
         self.alias_table = alias_table
@@ -553,7 +556,7 b' class IPCompleter(Completer):'
                     return withcase
                 # if none, then case insensitive ones are ok too
                 return [r for r in res if r.lower().startswith(text.lower())]
-            except ipapi.TryNext:
+            except TryNext:
                 pass
             
         return None

IPython/core/crashhandler.py

@@ -124,7 +124,7 b' $self.bug_tracker'
         #color_scheme = 'Linux'   # dbg
         
         try:
-            rptdir = self.IP.rc.ipythondir
+            rptdir = self.IP.config.IPYTHONDIR
         except:
             rptdir = os.getcwd()
         if not os.path.isdir(rptdir):
@@ -171,7 +171,7 b' $self.bug_tracker'
         rpt_add('Platform info  : os.name -> %s, sys.platform -> %s' %
                      (os.name,sys.platform) )
         rpt_add(sec_sep+'Current user configuration structure:\n\n')
-        rpt_add(pformat(self.IP.rc.dict()))
+        rpt_add(pformat(self.IP.dict()))
         rpt_add(sec_sep+'Crash traceback:\n\n' + traceback)
         try:
             rpt_add(sec_sep+"History of session input:")
@@ -215,7 +215,7 b' class IPythonCrashHandler(CrashHandler):'
         rpt_add('Platform info  : os.name -> %s, sys.platform -> %s' %
                      (os.name,sys.platform) )
         rpt_add(sec_sep+'Current user configuration structure:\n\n')
-        rpt_add(pformat(self.IP.rc.dict()))
+        # rpt_add(pformat(self.IP.dict()))
         rpt_add(sec_sep+'Crash traceback:\n\n' + traceback)
         try:
             rpt_add(sec_sep+"History of session input:")

IPython/core/debugger.py

@@ -110,7 +110,7 b' class Tracer(object):'
             __IPYTHON__
         except NameError:
             # Outside of ipython, we set our own exception hook manually
-            __IPYTHON__ = ipapi.get(True,False)
+            __IPYTHON__ = ipapi.get()
             BdbQuit_excepthook.excepthook_ori = sys.excepthook
             sys.excepthook = BdbQuit_excepthook
             def_colors = 'NoColor'
@@ -123,7 +123,7 b' class Tracer(object):'
         else:
             # In ipython, we use its custom exception handler mechanism
             ip = ipapi.get()
-            def_colors = ip.options.colors
+            def_colors = ip.colors
             ip.set_custom_exc((bdb.BdbQuit,),BdbQuit_IPython_excepthook)
 
         if colors is None:

IPython/core/excolors.py

@@ -34,9 +34,9 b' def exception_colors():'
     >>> ec.active_scheme_name
     'NoColor'
     >>> ec.active_colors.keys()
-    ['em', 'caret', '__allownew', 'name', 'val', 'vName', 'Normal', 'normalEm',
-    'filename', 'linenoEm', 'excName', 'lineno', 'valEm', 'filenameEm',
-    'nameEm', 'line', 'topline']
+    ['em', 'filenameEm', 'excName', 'valEm', 'nameEm', 'line', 'topline', 
+    'name', 'caret', 'val', 'vName', 'Normal', 'filename', 'linenoEm', 
+    'lineno', 'normalEm']
     """
     
     ex_colors = ColorSchemeTable()

IPython/core/history.py

@@ -47,9 +47,7 b" def magic_history(self, parameter_s = ''):"
        confirmation first if it already exists.
     """
 
-    ip = self.api
-    shell = self.shell
-    if not shell.outputcache.do_full_cache:
+    if not self.outputcache.do_full_cache:
         print 'This feature is only available if numbered prompts are in use.'
         return
     opts,args = self.parse_options(parameter_s,'gntsrf:',mode='list')
@@ -71,11 +69,11 b" def magic_history(self, parameter_s = ''):"
         close_at_end = True
 
     if 't' in opts:
-        input_hist = shell.input_hist
+        input_hist = self.input_hist
     elif 'r' in opts:
-        input_hist = shell.input_hist_raw
+        input_hist = self.input_hist_raw
     else:
-        input_hist = shell.input_hist
+        input_hist = self.input_hist
             
     default_length = 40
     pattern = None
@@ -105,7 +103,7 b" def magic_history(self, parameter_s = ''):"
     
     found = False
     if pattern is not None:
-        sh = ip.IP.shadowhist.all()
+        sh = self.shadowhist.all()
         for idx, s in sh:
             if fnmatch.fnmatch(s, pattern):
                 print "0%d: %s" %(idx, s)
@@ -168,9 +166,8 b' def rep_f(self, arg):'
     """
     
     opts,args = self.parse_options(arg,'',mode='list')
-    ip = self.api    
     if not args:
-        ip.set_next_input(str(ip.user_ns["_"]))
+        self.set_next_input(str(self.user_ns["_"]))
         return
 
     if len(args) == 1 and not '-' in args[0]:
@@ -179,33 +176,33 b' def rep_f(self, arg):'
             # get from shadow hist
             num = int(arg[1:])
             line = self.shadowhist.get(num)
-            ip.set_next_input(str(line))
+            self.set_next_input(str(line))
             return
         try:
             num = int(args[0])
-            ip.set_next_input(str(ip.IP.input_hist_raw[num]).rstrip())
+            self.set_next_input(str(self.input_hist_raw[num]).rstrip())
             return
         except ValueError:
             pass
         
-        for h in reversed(self.shell.input_hist_raw):
+        for h in reversed(self.input_hist_raw):
             if 'rep' in h:
                 continue
             if fnmatch.fnmatch(h,'*' + arg + '*'):
-                ip.set_next_input(str(h).rstrip())
+                self.set_next_input(str(h).rstrip())
                 return
         
     try:
         lines = self.extract_input_slices(args, True)
         print "lines",lines
-        ip.runlines(lines)
+        self.runlines(lines)
     except ValueError:
         print "Not found in recent history:", args
         
 
 _sentinel = object()
 
-class ShadowHist:
+class ShadowHist(object):
     def __init__(self,db):
         # cmd => idx mapping
         self.curidx = 0
@@ -228,7 +225,7 b' class ShadowHist:'
             #print "new",newidx # dbg
             self.db.hset('shadowhist',ent, newidx)
         except:
-            ipapi.get().IP.showtraceback()
+            ipapi.get().showtraceback()
             print "WARNING: disabling shadow history"
             self.disabled = True
     
@@ -250,8 +247,8 b' class ShadowHist:'
 def init_ipython(ip):
     import ipy_completers
 
-    ip.expose_magic("rep",rep_f)        
-    ip.expose_magic("hist",magic_hist)            
-    ip.expose_magic("history",magic_history)
+    ip.define_magic("rep",rep_f)        
+    ip.define_magic("hist",magic_hist)            
+    ip.define_magic("history",magic_history)
 
     ipy_completers.quick_completer('%hist' ,'-g -t -r -n')

IPython/core/hooks.py

@@ -26,7 +26,7 b' def calljed(self,filename, linenum):'
     "My editor hook calls the jed editor directly."
     print "Calling my own editor, jed ..."
     if os.system('jed +%d %s' % (linenum,filename)) != 0:
-        raise ipapi.TryNext()
+        raise TryNext()
 
 ip.set_hook('editor', calljed)
 
@@ -41,22 +41,21 b' somewhere in your configuration files or ipython command line.'
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
-from IPython.core import ipapi
-
 import os, bisect
 import sys
 from IPython.utils.genutils import Term, shell
 from pprint import PrettyPrinter
 
+from IPython.core.error import TryNext
+
 # List here all the default hooks.  For now it's just the editor functions
 # but over time we'll move here all the public API for user-accessible things.
-# vds: >>
+
 __all__ = ['editor', 'fix_error_editor', 'synchronize_with_editor', 'result_display',
            'input_prefilter', 'shutdown_hook', 'late_startup_hook',
            'generate_prompt', 'generate_output_prompt','shell_hook',
            'show_in_pager','pre_prompt_hook', 'pre_runcode_hook',
            'clipboard_get']
-# vds: <<
 
 pformat = PrettyPrinter().pformat
 
@@ -69,7 +68,7 b' def editor(self,filename, linenum=None):'
 
     # IPython configures a default editor at startup by reading $EDITOR from
     # the environment, and falling back on vi (unix) or notepad (win32).
-    editor = self.rc.editor
+    editor = self.editor
     
     # marker for at which line to open the file (for existing objects)
     if linenum is None or editor=='notepad':
@@ -83,7 +82,7 b' def editor(self,filename, linenum=None):'
         
     # Call the actual editor
     if os.system('%s %s %s' % (editor,linemark,filename)) != 0:
-        raise ipapi.TryNext()
+        raise TryNext()
 
 import tempfile
 def fix_error_editor(self,filename,linenum,column,msg):
@@ -99,20 +98,20 b' def fix_error_editor(self,filename,linenum,column,msg):'
         t.write('%s:%d:%d:%s\n' % (filename,linenum,column,msg))
         t.flush()
         return t
-    if os.path.basename(self.rc.editor) != 'vim':
+    if os.path.basename(self.editor) != 'vim':
         self.hooks.editor(filename,linenum)
         return
     t = vim_quickfix_file()
     try:
         if os.system('vim --cmd "set errorformat=%f:%l:%c:%m" -q ' + t.name):
-            raise ipapi.TryNext()
+            raise TryNext()
     finally:
         t.close()
 
-# vds: >>
+
 def synchronize_with_editor(self, filename, linenum, column):
         pass
-# vds: <<
+
 
 class CommandChainDispatcher:
     """ Dispatch calls to a chain of commands until some func can handle it
@@ -140,12 +139,12 b' class CommandChainDispatcher:'
             try:
                 ret = cmd(*args, **kw)
                 return ret
-            except ipapi.TryNext, exc:
+            except TryNext, exc:
                 if exc.args or exc.kwargs:
                     args = exc.args
                     kw = exc.kwargs
         # if no function will accept it, raise TryNext up to the caller
-        raise ipapi.TryNext
+        raise TryNext
                 
     def __str__(self):
         return str(self.chain)
@@ -160,14 +159,15 b' class CommandChainDispatcher:'
         Handy if the objects are not callable.
         """
         return iter(self.chain)
-    
+
+
 def result_display(self,arg):
     """ Default display hook.
     
     Called for displaying the result to the user.
     """
     
-    if self.rc.pprint:
+    if self.pprint:
         out = pformat(arg)
         if '\n' in out:
             # So that multi-line strings line up with the left column of
@@ -183,6 +183,7 b' def result_display(self,arg):'
     # the default display hook doesn't manipulate the value to put in history
     return None 
 
+
 def input_prefilter(self,line):     
     """ Default input prefilter
     
@@ -197,6 +198,7 b' def input_prefilter(self,line):'
     #print "attempt to rewrite",line #dbg
     return line
 
+
 def shutdown_hook(self):
     """ default shutdown hook
     
@@ -206,32 +208,36 b' def shutdown_hook(self):'
     #print "default shutdown hook ok" # dbg
     return
 
+
 def late_startup_hook(self):
     """ Executed after ipython has been constructed and configured 
     
     """
     #print "default startup hook ok" # dbg
 
+
 def generate_prompt(self, is_continuation):
     """ calculate and return a string with the prompt to display """
-    ip = self.api
     if is_continuation:
-        return str(ip.IP.outputcache.prompt2)
-    return str(ip.IP.outputcache.prompt1)
+        return str(self.outputcache.prompt2)
+    return str(self.outputcache.prompt1)
+
 
 def generate_output_prompt(self):
-    ip = self.api
-    return str(ip.IP.outputcache.prompt_out)
+    return str(self.outputcache.prompt_out)
+
 
 def shell_hook(self,cmd):
     """ Run system/shell command a'la os.system() """
 
-    shell(cmd, header=self.rc.system_header, verbose=self.rc.system_verbose)
+    shell(cmd, header=self.system_header, verbose=self.system_verbose)
+
 
 def show_in_pager(self,s):
     """ Run a string through pager """
     # raising TryNext here will use the default paging functionality
-    raise ipapi.TryNext
+    raise TryNext
+
 
 def pre_prompt_hook(self):
     """ Run before displaying the next prompt
@@ -242,10 +248,12 b' def pre_prompt_hook(self):'
     
     return None
 
+
 def pre_runcode_hook(self):
     """ Executed before running the (prefiltered) code in IPython """
     return None
 
+
 def clipboard_get(self):
     """ Get text from the clipboard.
     """

IPython/core/ipapi.py

@@ -1,685 +1,35 b''
-"""IPython customization API
-
-Your one-stop module for configuring & extending ipython
-
-The API will probably break when ipython 1.0 is released, but so 
-will the other configuration method (rc files).
-
-All names prefixed by underscores are for internal use, not part 
-of the public api.
-
-Below is an example that you can just put to a module and import from ipython. 
-
-A good practice is to install the config script below as e.g. 
-
-~/.ipython/my_private_conf.py
-
-And do 
-
-import_mod my_private_conf 
-
-in ~/.ipython/ipythonrc
-
-That way the module is imported at startup and you can have all your
-personal configuration (as opposed to boilerplate ipythonrc-PROFILENAME 
-stuff) in there. 
-
-from IPython.core import ipapi
-ip = ipapi.get()
-
-def ankka_f(self, arg):
-    print 'Ankka',self,'says uppercase:',arg.upper()
-
-ip.expose_magic('ankka',ankka_f)
-
-ip.magic('alias sayhi echo "Testing, hi ok"')
-ip.magic('alias helloworld echo "Hello world"')
-ip.system('pwd')
-
-ip.ex('import re')
-ip.ex('''
-def funcci(a,b):
-    print a+b
-print funcci(3,4)
-''')
-ip.ex('funcci(348,9)')
-
-def jed_editor(self,filename, linenum=None):
-    print 'Calling my own editor, jed ... via hook!'
-    import os
-    if linenum is None: linenum = 0
-    os.system('jed +%d %s' % (linenum, filename))
-    print 'exiting jed'
-
-ip.set_hook('editor',jed_editor)
-
-o = ip.options
-o.autocall = 2  # FULL autocall mode
-
-print 'done!'
+#!/usr/bin/env python
+# encoding: utf-8
+"""
+This module is *completely* deprecated and should no longer be used for
+any purpose.  Currently, we have a few parts of the core that have
+not been componentized and thus, still rely on this module.  When everything
+has been made into a component, this module will be sent to deathrow.
 """
 
 #-----------------------------------------------------------------------------
-# Modules and globals
-
-# stdlib imports
-import __builtin__
-import sys
-
-# contains the most recently instantiated IPApi
-_RECENT_IP = None
-
+#  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.
 #-----------------------------------------------------------------------------
-# Code begins
-
-class TryNext(Exception):
-    """Try next hook exception.
-     
-    Raise this in your hook function to indicate that the next hook handler
-    should be used to handle the operation.  If you pass arguments to the
-    constructor those arguments will be used by the next hook instead of the
-    original ones.
-    """
-
-    def __init__(self, *args, **kwargs):
-        self.args = args
-        self.kwargs = kwargs
-
-
-class UsageError(Exception):
-    """ Error in magic function arguments, etc.
-    
-    Something that probably won't warrant a full traceback, but should
-    nevertheless interrupt a macro / batch file.   
-    """
-
-
-class IPyAutocall:
-    """ Instances of this class are always autocalled
-    
-    This happens regardless of 'autocall' variable state. Use this to
-    develop macro-like mechanisms.
-    """
-    
-    def set_ip(self,ip):
-        """ Will be used to set _ip point to current ipython instance b/f call
-        
-        Override this method if you don't want this to happen.
-        
-        """
-        self._ip = ip
-    
-
-class IPythonNotRunning:
-    """Dummy do-nothing class.
-
-    Instances of this class return a dummy attribute on all accesses, which
-    can be called and warns.  This makes it easier to write scripts which use
-    the ipapi.get() object for informational purposes to operate both with and
-    without ipython.  Obviously code which uses the ipython object for
-    computations will not work, but this allows a wider range of code to
-    transparently work whether ipython is being used or not."""
-
-    def __init__(self,warn=True):
-        if warn:
-            self.dummy = self._dummy_warn
-        else:
-            self.dummy = self._dummy_silent
-    
-    def __str__(self):
-        return "<IPythonNotRunning>"
-
-    __repr__ = __str__
-
-    def __getattr__(self,name):
-        return self.dummy
-
-    def _dummy_warn(self,*args,**kw):
-        """Dummy function, which doesn't do anything but warn."""
-
-        print ("IPython is not running, this is a dummy no-op function")
-
-    def _dummy_silent(self,*args,**kw):
-        """Dummy function, which doesn't do anything and emits no warnings."""
-        pass
-
-
-def get(allow_dummy=False,dummy_warn=True):
-    """Get an IPApi object.
-
-    If allow_dummy is true, returns an instance of IPythonNotRunning 
-    instead of None if not running under IPython.
-
-    If dummy_warn is false, the dummy instance will be completely silent.
-
-    Running this should be the first thing you do when writing extensions that
-    can be imported as normal modules. You can then direct all the
-    configuration operations against the returned object.
-    """
-    global _RECENT_IP
-    if allow_dummy and not _RECENT_IP:
-        _RECENT_IP = IPythonNotRunning(dummy_warn)
-    return _RECENT_IP
-
-
-class IPApi(object):
-    """ The actual API class for configuring IPython 
-    
-    You should do all of the IPython configuration by getting an IPApi object
-    with IPython.ipapi.get() and using the attributes and methods of the
-    returned object."""
-    
-    def __init__(self,ip):
-        
-        global _RECENT_IP
-
-        # All attributes exposed here are considered to be the public API of
-        # IPython.  As needs dictate, some of these may be wrapped as
-        # properties.
-
-        self.magic = ip.ipmagic
-        
-        self.system = ip.system
-        
-        self.set_hook = ip.set_hook
-        
-        self.set_custom_exc = ip.set_custom_exc
-
-        self.user_ns = ip.user_ns
-
-        self.set_crash_handler = ip.set_crash_handler
-
-        # Session-specific data store, which can be used to store
-        # data that should persist through the ipython session.
-        self.meta =  ip.meta
-    
-        # The ipython instance provided
-        self.IP = ip
-
-        self.extensions = {}
-
-        self.dbg = DebugTools(self)
-        
-        _RECENT_IP = self
-
-    # Use a property for some things which are added to the instance very
-    # late.  I don't have time right now to disentangle the initialization
-    # order issues, so a property lets us delay item extraction while
-    # providing a normal attribute API.
-    def get_db(self):
-        """A handle to persistent dict-like database (a PickleShareDB object)"""
-        return self.IP.db
-
-    db = property(get_db,None,None,get_db.__doc__)
-
-    def get_options(self):
-        """All configurable variables."""
-        
-        # catch typos by disabling new attribute creation. If new attr creation
-        # is in fact wanted (e.g. when exposing new options), do
-        # allow_new_attr(True) for the received rc struct.
-        
-        self.IP.rc.allow_new_attr(False)
-        return self.IP.rc
-
-    options = property(get_options,None,None,get_options.__doc__)
-    
-    def expose_magic(self,magicname, func):
-        """Expose own function as magic function for ipython 
-    
-        def foo_impl(self,parameter_s=''):
-            'My very own magic!. (Use docstrings, IPython reads them).'
-            print 'Magic function. Passed parameter is between < >:'
-            print '<%s>' % parameter_s
-            print 'The self object is:',self
-    
-        ipapi.expose_magic('foo',foo_impl)
-        """
-        
-        import new
-        im = new.instancemethod(func,self.IP, self.IP.__class__)
-        old = getattr(self.IP, "magic_" + magicname, None)
-        if old:
-            self.dbg.debug_stack("Magic redefinition '%s', old %s" %
-                                 (magicname,old) )
-            
-        setattr(self.IP, "magic_" + magicname, im)
-    
-    def ex(self,cmd):
-        """ Execute a normal python statement in user namespace """
-        exec cmd in self.user_ns
-    
-    def ev(self,expr):
-        """ Evaluate python expression expr in user namespace 
-        
-        Returns the result of evaluation"""
-        return eval(expr,self.user_ns)
-    
-    def runlines(self,lines):
-        """ Run the specified lines in interpreter, honoring ipython directives.
-        
-        This allows %magic and !shell escape notations.
-        
-        Takes either all lines in one string or list of lines.
-        """
-
-        def cleanup_ipy_script(script):
-            """ Make a script safe for _ip.runlines() 
-            
-            - Removes empty lines Suffixes all indented blocks that end with
-            - unindented lines with empty lines
-            """
-            
-            res = []
-            lines = script.splitlines()
 
-            level = 0
-            for l in lines:
-                lstripped = l.lstrip()
-                stripped = l.strip()                
-                if not stripped:
-                    continue
-                newlevel = len(l) - len(lstripped)
-                def is_secondary_block_start(s):
-                    if not s.endswith(':'):
-                        return False
-                    if (s.startswith('elif') or 
-                        s.startswith('else') or 
-                        s.startswith('except') or
-                        s.startswith('finally')):
-                        return True
-                        
-                if level > 0 and newlevel == 0 and \
-                       not is_secondary_block_start(stripped): 
-                    # add empty line
-                    res.append('')
-                    
-                res.append(l)
-                level = newlevel
-            return '\n'.join(res) + '\n'
-        
-        if isinstance(lines,basestring):
-            script = lines            
-        else:
-            script = '\n'.join(lines)
-        clean=cleanup_ipy_script(script)
-        # print "_ip.runlines() script:\n",clean # dbg
-        self.IP.runlines(clean)
-        
-    def to_user_ns(self,vars, interactive = True):
-        """Inject a group of variables into the IPython user namespace.
-
-        Inputs:
-
-         - vars: string with variable names separated by whitespace, or a
-         dict with name/value pairs.
-
-         - interactive: if True (default), the var will be listed with
-        %whos et. al.
-         
-        This utility routine is meant to ease interactive debugging work,
-        where you want to easily propagate some internal variable in your code
-        up to the interactive namespace for further exploration.
-
-        When you run code via %run, globals in your script become visible at
-        the interactive prompt, but this doesn't happen for locals inside your
-        own functions and methods.  Yet when debugging, it is common to want
-        to explore some internal variables further at the interactive propmt.
-
-        Examples:
-
-        To use this, you first must obtain a handle on the ipython object as
-        indicated above, via:
-
-        from IPython.core import ipapi
-        ip = ipapi.get()
-
-        Once this is done, inside a routine foo() where you want to expose
-        variables x and y, you do the following:
-
-        def foo():
-            ...
-            x = your_computation()
-            y = something_else()
-            
-            # This pushes x and y to the interactive prompt immediately, even
-            # if this routine crashes on the next line after:
-            ip.to_user_ns('x y')
-            ...
-            
-            # To expose *ALL* the local variables from the function, use:
-            ip.to_user_ns(locals())
-
-            ...
-            # return           
-        
-
-        If you need to rename variables, the dict input makes it easy.  For
-        example, this call exposes variables 'foo' as 'x' and 'bar' as 'y'
-        in IPython user namespace:
-
-        ip.to_user_ns(dict(x=foo,y=bar))    
-        """
-
-        # print 'vars given:',vars # dbg
-        
-        # We need a dict of name/value pairs to do namespace updates.
-        if isinstance(vars,dict):
-            # If a dict was given, no need to change anything.
-            vdict = vars
-        elif isinstance(vars,basestring):
-            # If a string with names was given, get the caller's frame to
-            # evaluate the given names in
-            cf = sys._getframe(1)
-            vdict = {}
-            for name in vars.split():
-                try:
-                    vdict[name] = eval(name,cf.f_globals,cf.f_locals)
-                except:
-                    print ('could not get var. %s from %s' %
-                    (name,cf.f_code.co_name))
-        else:
-            raise ValueError('vars must be a string or a dict')
-            
-        # Propagate variables to user namespace
-        self.user_ns.update(vdict)
-
-        # And configure interactive visibility
-        config_ns = self.IP.user_config_ns
-        if interactive:
-            for name,val in vdict.iteritems():
-                config_ns.pop(name,None)
-        else:
-            for name,val in vdict.iteritems():
-                config_ns[name] = val                    
-
-    def expand_alias(self,line):
-        """ Expand an alias in the command line 
-        
-        Returns the provided command line, possibly with the first word 
-        (command) translated according to alias expansion rules.
-        
-        [ipython]|16> _ip.expand_aliases("np myfile.txt")
-                 <16> 'q:/opt/np/notepad++.exe myfile.txt'
-        """
-        
-        pre,fn,rest = self.IP.split_user_input(line)
-        res = pre + self.IP.expand_aliases(fn,rest)
-        return res
-
-    def itpl(self, s, depth = 1):
-        """ Expand Itpl format string s.
-        
-        Only callable from command line (i.e. prefilter results);
-        If you use in your scripts, you need to use a bigger depth!
-        """
-        return self.IP.var_expand(s, depth)
-        
-    def defalias(self, name, cmd):
-        """ Define a new alias
-        
-        _ip.defalias('bb','bldmake bldfiles')
-        
-        Creates a new alias named 'bb' in ipython user namespace
-        """
-
-        self.dbg.check_hotname(name)
-        
-        if name in self.IP.alias_table:
-            self.dbg.debug_stack("Alias redefinition: '%s' => '%s' (old '%s')"
-                                 % (name, cmd, self.IP.alias_table[name]))
-
-        if callable(cmd):
-            self.IP.alias_table[name] = cmd
-            from IPython.core import shadowns
-            setattr(shadowns, name,cmd)
-            return
-            
-        if isinstance(cmd,basestring):
-            nargs = cmd.count('%s')
-            if nargs>0 and cmd.find('%l')>=0:
-                raise Exception('The %s and %l specifiers are mutually '
-                                'exclusive in alias definitions.')
-                  
-            self.IP.alias_table[name] = (nargs,cmd)
-            return
-        
-        # just put it in - it's probably (0,'foo')
-        self.IP.alias_table[name] = cmd
-    
-    def defmacro(self, *args):
-        """ Define a new macro
-    
-        2 forms of calling:
-        
-        mac = _ip.defmacro('print "hello"\nprint "world"')
-        
-        (doesn't put the created macro on user namespace)
-        
-        _ip.defmacro('build', 'bldmake bldfiles\nabld build winscw udeb')
-        
-        (creates a macro named 'build' in user namespace)
-        """
-        
-        from IPython.core import macro
-        
-        if len(args) == 1:
-            return macro.Macro(args[0])
-        elif len(args) == 2:
-            self.user_ns[args[0]] = macro.Macro(args[1])
-        else:
-            return Exception("_ip.defmacro must be called with 1 or 2 arguments")
-        
-    def set_next_input(self, s):
-        """ Sets the 'default' input string for the next command line.
-        
-        Requires readline.
-        
-        Example:
-        
-        [D:\ipython]|1> _ip.set_next_input("Hello Word")
-        [D:\ipython]|2> Hello Word_  # cursor is here        
-        """
-
-        self.IP.rl_next_input = s
-
-    def load(self, mod):
-        """ Load an extension.
-        
-        Some modules should (or must) be 'load()':ed, rather than just imported.
-        
-        Loading will do:
-        
-        - run init_ipython(ip)
-        - run ipython_firstrun(ip)
-        """
-        
-        if mod in self.extensions:
-            # just to make sure we don't init it twice
-            # note that if you 'load' a module that has already been
-            # imported, init_ipython gets run anyway
-            
-            return self.extensions[mod]
-        __import__(mod)
-        m = sys.modules[mod]
-        if hasattr(m,'init_ipython'):
-            m.init_ipython(self)
-            
-        if hasattr(m,'ipython_firstrun'):
-            already_loaded = self.db.get('firstrun_done', set())
-            if mod not in already_loaded:
-                m.ipython_firstrun(self)
-                already_loaded.add(mod)
-                self.db['firstrun_done'] = already_loaded
-            
-        self.extensions[mod] = m
-        return m
-
-
-class DebugTools:
-    """ Used for debugging mishaps in api usage
-    
-    So far, tracing redefinitions is supported.
-    """
-    
-    def __init__(self, ip):
-        self.ip = ip
-        self.debugmode = False
-        self.hotnames = set()
-        
-    def hotname(self, name_to_catch):
-        self.hotnames.add(name_to_catch)
-        
-    def debug_stack(self, msg = None):
-        if not self.debugmode:
-            return
-        
-        import traceback
-        if msg is not None:
-            print '====== %s  ========' % msg
-        traceback.print_stack()
-
-    def check_hotname(self,name):
-        if name in self.hotnames:
-            self.debug_stack( "HotName '%s' caught" % name)
-
-
-def launch_new_instance(user_ns = None,shellclass = None):
-    """ Make and start a new ipython instance.
-    
-    This can be called even without having an already initialized 
-    ipython session running.
-    
-    This is also used as the egg entry point for the 'ipython' script.
-    
-    """
-    ses = make_session(user_ns,shellclass)
-    ses.mainloop()
-
-
-def make_user_ns(user_ns = None):
-    """Return a valid user interactive namespace.
-
-    This builds a dict with the minimal information needed to operate as a
-    valid IPython user namespace, which you can pass to the various embedding
-    classes in ipython.
-
-    This API is currently deprecated. Use ipapi.make_user_namespaces() instead
-    to make both the local and global namespace objects simultaneously.
-
-    :Parameters:
-        user_ns : dict-like, optional
-            The current user namespace. The items in this namespace should be
-            included in the output. If None, an appropriate blank namespace
-            should be created.
-
-    :Returns:
-        A dictionary-like object to be used as the local namespace of the
-        interpreter.
-    """
-
-    raise NotImplementedError
-
-
-def make_user_global_ns(ns = None):
-    """Return a valid user global namespace.
-
-    Similar to make_user_ns(), but global namespaces are really only needed in
-    embedded applications, where there is a distinction between the user's
-    interactive namespace and the global one where ipython is running.
-
-    This API is currently deprecated. Use ipapi.make_user_namespaces() instead
-    to make both the local and global namespace objects simultaneously.
-
-    :Parameters:
-        ns : dict, optional
-            The current user global namespace. The items in this namespace
-            should be included in the output. If None, an appropriate blank
-            namespace should be created.
-
-    :Returns:
-        A true dict to be used as the global namespace of the interpreter.
-    """
-
-    raise NotImplementedError
-
-# Record the true objects in order to be able to test if the user has overridden
-# these API functions.
-_make_user_ns = make_user_ns
-_make_user_global_ns = make_user_global_ns
-
-
-def make_user_namespaces(user_ns = None,user_global_ns = None):
-    """Return a valid local and global user interactive namespaces.
-
-    This builds a dict with the minimal information needed to operate as a
-    valid IPython user namespace, which you can pass to the various embedding
-    classes in ipython.  The default implementation returns the same dict for
-    both the locals and the globals to allow functions to refer to variables in
-    the namespace.  Customized implementations can return different dicts.  The
-    locals dictionary can actually be anything following the basic mapping
-    protocol of a dict, but the globals dict must be a true dict, not even
-    a subclass.  It is recommended that any custom object for the locals
-    namespace synchronize with the globals dict somehow.
-
-    Raises TypeError if the provided globals namespace is not a true dict.
-
-    :Parameters:
-        user_ns : dict-like, optional
-            The current user namespace. The items in this namespace should be
-            included in the output. If None, an appropriate blank namespace
-            should be created.
-        user_global_ns : dict, optional
-            The current user global namespace. The items in this namespace
-            should be included in the output. If None, an appropriate blank
-            namespace should be created.
-
-    :Returns:
-        A tuple pair of dictionary-like object to be used as the local namespace
-        of the interpreter and a dict to be used as the global namespace.
-    """
-
-    if user_ns is None:
-        if make_user_ns is not _make_user_ns:
-            # Old API overridden.
-            # FIXME: Issue DeprecationWarning, or just let the old API live on?
-            user_ns = make_user_ns(user_ns)
-        else:
-            # Set __name__ to __main__ to better match the behavior of the
-            # normal interpreter.
-            user_ns = {'__name__'     :'__main__',
-                       '__builtins__' : __builtin__,
-                       }
-    else:
-        user_ns.setdefault('__name__','__main__')
-        user_ns.setdefault('__builtins__',__builtin__)
-
-    if user_global_ns is None:
-        if make_user_global_ns is not _make_user_global_ns:
-            # Old API overridden.
-            user_global_ns = make_user_global_ns(user_global_ns)
-        else:
-            user_global_ns = user_ns
-    if type(user_global_ns) is not dict:
-        raise TypeError("user_global_ns must be a true dict; got %r"
-            % type(user_global_ns))
-
-    return user_ns, user_global_ns
-
-
-def make_session(user_ns = None, shellclass = None):
-    """Makes, but does not launch an IPython session.
-    
-    Later on you can call obj.mainloop() on the returned object.
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
 
-    Inputs:
+from IPython.core.error import TryNext, UsageError
 
-      - user_ns(None): a dict to be used as the user's namespace with initial
-      data.
-    
-    WARNING: This should *not* be run when a session exists already."""
+#-----------------------------------------------------------------------------
+# Classes and functions
+#-----------------------------------------------------------------------------
 
-    import IPython.core.shell
-    if shellclass is None:
-        return IPython.core.shell.start(user_ns)
-    return shellclass(user_ns = user_ns)
+def get():
+    """Get the most recently created InteractiveShell instance."""
+    from IPython.core.iplib import InteractiveShell
+    insts = InteractiveShell.get_instances()
+    most_recent = insts[0]
+    for inst in insts[1:]:
+        if inst.created > most_recent.created:
+            most_recent = inst
+    return most_recent

IPython/core/macro.py

@@ -7,10 +7,8 b''
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
-from IPython.core import ipapi 
-
 from IPython.utils.genutils import Term
-from IPython.core.ipapi import IPyAutocall
+from IPython.core.autocall import IPyAutocall
 
 class Macro(IPyAutocall):
     """Simple class to store the value of macros as strings.

IPython/core/magic.py

@@ -45,16 +45,18 b' except ImportError:'
 import IPython
 from IPython.utils import wildcard
 from IPython.core import debugger, oinspect
+from IPython.core.error import TryNext
 from IPython.core.fakemodule import FakeModule
+from IPython.core.prefilter import ESC_MAGIC
 from IPython.external.Itpl import Itpl, itpl, printpl,itplns
 from IPython.utils.PyColorize import Parser
 from IPython.utils.ipstruct import Struct
 from IPython.core.macro import Macro
 from IPython.utils.genutils import *
+from IPython.core.page import page
 from IPython.utils import platutils
 import IPython.utils.generics
-from IPython.core import ipapi
-from IPython.core.ipapi import UsageError
+from IPython.core.error import UsageError
 from IPython.testing import decorators as testdec
 
 #***************************************************************************
@@ -204,9 +206,9 b' python-profiler package from non-free.""")'
             namespaces = [ ('Interactive', self.shell.user_ns),
                            ('IPython internal', self.shell.internal_ns),
                            ('Python builtin', __builtin__.__dict__),
-                           ('Alias', self.shell.alias_table),
+                           ('Alias', self.shell.alias_manager.alias_table),
                            ]
-            alias_ns = self.shell.alias_table
+            alias_ns = self.shell.alias_manager.alias_table
 
         # initialize results to 'null'
         found = 0; obj = None;  ospace = None;  ds = None;
@@ -243,7 +245,7 b' python-profiler package from non-free.""")'
 
         # Try to see if it's magic
         if not found:
-            if oname.startswith(self.shell.ESC_MAGIC):
+            if oname.startswith(ESC_MAGIC):
                 oname = oname[1:]
             obj = getattr(self,'magic_'+oname,None)
             if obj is not None:
@@ -271,10 +273,10 b' python-profiler package from non-free.""")'
         # Characters that need to be escaped for latex:
         escape_re = re.compile(r'(%|_|\$|#|&)',re.MULTILINE)
         # Magic command names as headers:
-        cmd_name_re = re.compile(r'^(%s.*?):' % self.shell.ESC_MAGIC,
+        cmd_name_re = re.compile(r'^(%s.*?):' % ESC_MAGIC,
                                  re.MULTILINE)
         # Magic commands 
-        cmd_re = re.compile(r'(?P<cmd>%s.+?\b)(?!\}\}:)' % self.shell.ESC_MAGIC,
+        cmd_re = re.compile(r'(?P<cmd>%s.+?\b)(?!\}\}:)' % ESC_MAGIC,
                             re.MULTILINE)
         # Paragraph continue
         par_re = re.compile(r'\\$',re.MULTILINE)
@@ -375,10 +377,10 b' python-profiler package from non-free.""")'
     # Functions for IPython shell work (vars,funcs, config, etc)
     def magic_lsmagic(self, parameter_s = ''):
         """List currently available magic functions."""
-        mesc = self.shell.ESC_MAGIC
+        mesc = ESC_MAGIC
         print 'Available magic functions:\n'+mesc+\
               ('  '+mesc).join(self.lsmagic())
-        print '\n' + Magic.auto_status[self.shell.rc.automagic]
+        print '\n' + Magic.auto_status[self.shell.automagic]
         return None
         
     def magic_magic(self, parameter_s = ''):
@@ -423,11 +425,11 b' python-profiler package from non-free.""")'
                 
                 
             if mode == 'rest':
-                rest_docs.append('**%s%s**::\n\n\t%s\n\n' %(self.shell.ESC_MAGIC,
+                rest_docs.append('**%s%s**::\n\n\t%s\n\n' %(ESC_MAGIC,
                                                     fname,fndoc))
                 
             else:
-                magic_docs.append('%s%s:\n\t%s\n' %(self.shell.ESC_MAGIC,
+                magic_docs.append('%s%s:\n\t%s\n' %(ESC_MAGIC,
                                                     fname,fndoc))
                 
         magic_docs = ''.join(magic_docs)
@@ -470,22 +472,22 b' ipythonrc file, placing a line like:'
 
 will define %pf as a new name for %profile.
 
-You can also call magics in code using the ipmagic() function, which IPython
-automatically adds to the builtin namespace.  Type 'ipmagic?' for details.
+You can also call magics in code using the magic() function, which IPython
+automatically adds to the builtin namespace.  Type 'magic?' for details.
 
 For a list of the available magic functions, use %lsmagic. For a description
 of any of them, type %magic_name?, e.g. '%cd?'.
 
 Currently the magic system has the following functions:\n"""
 
-        mesc = self.shell.ESC_MAGIC
+        mesc = ESC_MAGIC
         outmsg = ("%s\n%s\n\nSummary of magic functions (from %slsmagic):"
                   "\n\n%s%s\n\n%s" % (outmsg,
                                      magic_docs,mesc,mesc,
                                      ('  '+mesc).join(self.lsmagic()),
-                                     Magic.auto_status[self.shell.rc.automagic] ) )
+                                     Magic.auto_status[self.shell.automagic] ) )
 
-        page(outmsg,screen_lines=self.shell.rc.screen_length)
+        page(outmsg,screen_lines=self.shell.usable_screen_length)
   
 
     def magic_autoindent(self, parameter_s = ''):
@@ -512,15 +514,14 b' Currently the magic system has the following functions:\\n"""'
         delete the variable (del var), the previously shadowed magic function
         becomes visible to automagic again."""
 
-        rc = self.shell.rc
         arg = parameter_s.lower()
         if parameter_s in ('on','1','true'):
-            rc.automagic = True
+            self.shell.automagic = True
         elif parameter_s in ('off','0','false'):
-            rc.automagic = False
+            self.shell.automagic = False
         else:
-            rc.automagic = not rc.automagic
-        print '\n' + Magic.auto_status[rc.automagic]
+            self.shell.automagic = not self.shell.automagic
+        print '\n' + Magic.auto_status[self.shell.automagic]
 
     @testdec.skip_doctest
     def magic_autocall(self, parameter_s = ''):
@@ -566,8 +567,6 b' Currently the magic system has the following functions:\\n"""'
         # all-random (note for auto-testing)
         """
 
-        rc = self.shell.rc
-
         if parameter_s:
             arg = int(parameter_s)
         else:
@@ -578,18 +577,18 b' Currently the magic system has the following functions:\\n"""'
             return
 
         if arg in (0,1,2):
-            rc.autocall = arg
+            self.shell.autocall = arg
         else: # toggle
-            if rc.autocall:
-                self._magic_state.autocall_save = rc.autocall
-                rc.autocall = 0
+            if self.shell.autocall:
+                self._magic_state.autocall_save = self.shell.autocall
+                self.shell.autocall = 0
             else:
                 try:
-                    rc.autocall = self._magic_state.autocall_save
+                    self.shell.autocall = self._magic_state.autocall_save
                 except AttributeError:
-                    rc.autocall = self._magic_state.autocall_save = 1
+                    self.shell.autocall = self._magic_state.autocall_save = 1
 
-        print "Automatic calling is:",['OFF','Smart','Full'][rc.autocall]
+        print "Automatic calling is:",['OFF','Smart','Full'][self.shell.autocall]
 
     def magic_system_verbose(self, parameter_s = ''):
         """Set verbose printing of system calls.
@@ -600,10 +599,13 b' Currently the magic system has the following functions:\\n"""'
             val = bool(eval(parameter_s))
         else:
             val = None
-            
-        self.shell.rc_set_toggle('system_verbose',val)
+
+        if self.shell.system_verbose:
+            self.shell.system_verbose = False
+        else:
+            self.shell.system_verbose = True
         print "System verbose printing is:",\
-              ['OFF','ON'][self.shell.rc.system_verbose]
+              ['OFF','ON'][self.shell.system_verbose]
 
 
     def magic_page(self, parameter_s=''):
@@ -633,8 +635,8 b' Currently the magic system has the following functions:\\n"""'
 
     def magic_profile(self, parameter_s=''):
         """Print your currently active IPyhton profile."""
-        if self.shell.rc.profile:
-            printpl('Current IPython profile: $self.shell.rc.profile.')
+        if self.shell.profile:
+            printpl('Current IPython profile: $self.shell.profile.')
         else:
             print 'No profile active.'
 
@@ -720,7 +722,7 b' Currently the magic system has the following functions:\\n"""'
             try:
                 IPython.utils.generics.inspect_object(info.obj)
                 return
-            except ipapi.TryNext:
+            except TryNext:
                 pass
             # Get the docstring of the class property if it exists.
             path = oname.split('.')
@@ -848,7 +850,7 b' Currently the magic system has the following functions:\\n"""'
         elif opts.has_key('c'):
             ignore_case = False
         else:
-            ignore_case = not shell.rc.wildcards_case_sensitive
+            ignore_case = not shell.wildcards_case_sensitive
 
         # Build list of namespaces to search from user options
         def_search.extend(opt('s',[]))
@@ -1132,7 +1134,6 b' Currently the magic system has the following functions:\\n"""'
         log_raw_input = 'r' in opts
         timestamp = 't' in opts
 
-        rc = self.shell.rc
         logger = self.shell.logger
 
         # if no args are given, the defaults set in the logger constructor by
@@ -1149,11 +1150,12 b' Currently the magic system has the following functions:\\n"""'
         # put logfname into rc struct as if it had been called on the command
         # line, so it ends up saved in the log header Save it in case we need
         # to restore it...
-        old_logfile = rc.opts.get('logfile','')  
+        old_logfile = self.shell.logfile
         if logfname:
             logfname = os.path.expanduser(logfname)
-        rc.opts.logfile = logfname
-        loghead = self.shell.loghead_tpl % (rc.opts,rc.args)
+        self.shell.logfile = logfname
+
+        loghead = '# IPython log file\n\n'
         try:
             started  = logger.logstart(logfname,loghead,logmode,
                                        log_output,timestamp,log_raw_input)
@@ -1421,7 +1423,7 b' Currently the magic system has the following functions:\\n"""'
         output = stdout_trap.getvalue()
         output = output.rstrip()
 
-        page(output,screen_lines=self.shell.rc.screen_length)
+        page(output,screen_lines=self.shell.usable_screen_length)
         print sys_exit,
 
         dump_file = opts.D[0]
@@ -1569,7 +1571,7 b' Currently the magic system has the following functions:\\n"""'
             return
 
         if filename.lower().endswith('.ipy'):
-            self.api.runlines(open(filename).read())
+            self.safe_execfile_ipy(filename)
             return
         
         # Control the response to exit() calls made by the script being run
@@ -1622,7 +1624,7 b' Currently the magic system has the following functions:\\n"""'
                 stats = self.magic_prun('',0,opts,arg_lst,prog_ns)
             else:
                 if opts.has_key('d'):
-                    deb = debugger.Pdb(self.shell.rc.colors)
+                    deb = debugger.Pdb(self.shell.colors)
                     # reset Breakpoint state, which is moronically kept
                     # in a class
                     bdb.Breakpoint.next = 1
@@ -1739,25 +1741,6 b' Currently the magic system has the following functions:\\n"""'
                 
         return stats
 
-    def magic_runlog(self, parameter_s =''):
-        """Run files as logs.
-
-        Usage:\\
-          %runlog file1 file2 ...
-
-        Run the named files (treating them as log files) in sequence inside
-        the interpreter, and return to the prompt.  This is much slower than
-        %run because each line is executed in a try/except block, but it
-        allows running files with syntax errors in them.
-
-        Normally IPython will guess when a file is one of its own logfiles, so
-        you can typically use %run even for logs. This shorthand allows you to
-        force any file to be treated as a log file."""
-
-        for f in parameter_s.split():
-            self.shell.safe_execfile(f,self.shell.user_ns,
-                                     self.shell.user_ns,islog=1)
-
     @testdec.skip_doctest
     def magic_timeit(self, parameter_s =''):
         """Time execution of a Python statement or expression
@@ -2061,7 +2044,7 b' Currently the magic system has the following functions:\\n"""'
         #print 'rng',ranges  # dbg
         lines = self.extract_input_slices(ranges,opts.has_key('r'))
         macro = Macro(lines)
-        self.shell.user_ns.update({name:macro})
+        self.shell.define_macro(name, macro)
         print 'Macro `%s` created. To execute, type its name (without quotes).' % name
         print 'Macro contents:'
         print macro,
@@ -2391,7 +2374,7 b' Currently the magic system has the following functions:\\n"""'
         sys.stdout.flush()
         try:
             self.shell.hooks.editor(filename,lineno)
-        except ipapi.TryNext:
+        except TryNext:
             warn('Could not open editor')
             return
         
@@ -2492,7 +2475,7 b' Defaulting color scheme to \'NoColor\'"""'
         except:
             color_switch_err('prompt')
         else:
-            shell.rc.colors = \
+            shell.colors = \
                        shell.outputcache.color_table.active_scheme_name
         # Set exception colors
         try:
@@ -2509,7 +2492,7 b' Defaulting color scheme to \'NoColor\'"""'
                 color_switch_err('system exception handler')
         
         # Set info (for 'object?') colors
-        if shell.rc.color_info:
+        if shell.color_info:
             try:
                 shell.inspector.set_active_scheme(new_scheme)
             except:
@@ -2528,17 +2511,17 b' Defaulting color scheme to \'NoColor\'"""'
         than more) in your system, using colored object information displays
         will not work properly. Test it and see."""
         
-        self.shell.rc.color_info = 1 - self.shell.rc.color_info
-        self.magic_colors(self.shell.rc.colors)
+        self.shell.color_info = not self.shell.color_info
+        self.magic_colors(self.shell.colors)
         print 'Object introspection functions have now coloring:',
-        print ['OFF','ON'][self.shell.rc.color_info]
+        print ['OFF','ON'][int(self.shell.color_info)]
 
     def magic_Pprint(self, parameter_s=''):
         """Toggle pretty printing on/off."""
         
-        self.shell.rc.pprint = 1 - self.shell.rc.pprint
+        self.shell.pprint = 1 - self.shell.pprint
         print 'Pretty printing has been turned', \
-              ['OFF','ON'][self.shell.rc.pprint]
+              ['OFF','ON'][self.shell.pprint]
         
     def magic_exit(self, parameter_s=''):
         """Exit IPython, confirming if configured to do so.
@@ -2617,52 +2600,27 b' Defaulting color scheme to \'NoColor\'"""'
         par = parameter_s.strip()
         if not par:
             stored = self.db.get('stored_aliases', {} )
-            atab = self.shell.alias_table
-            aliases = atab.keys()
-            aliases.sort()
-            res = []
-            showlast = []
-            for alias in aliases:
-                special = False
-                try:
-                    tgt = atab[alias][1]
-                except (TypeError, AttributeError):
-                    # unsubscriptable? probably a callable
-                    tgt = atab[alias]
-                    special = True
-                # 'interesting' aliases
-                if (alias in stored or
-                    special or 
-                    alias.lower() != os.path.splitext(tgt)[0].lower() or
-                    ' ' in tgt):
-                    showlast.append((alias, tgt))
-                else:
-                    res.append((alias, tgt ))                
-            
-            # show most interesting aliases last
-            res.extend(showlast)
-            print "Total number of aliases:",len(aliases)
-            return res
+            aliases = sorted(self.shell.alias_manager.aliases)
+            # for k, v in stored:
+            #     atab.append(k, v[0])
+
+            print "Total number of aliases:", len(aliases)
+            return aliases
+        
+        # Now try to define a new one
         try:
-            alias,cmd = par.split(None,1)
+            alias,cmd = par.split(None, 1)
         except:
             print oinspect.getdoc(self.magic_alias)
         else:
-            nargs = cmd.count('%s')
-            if nargs>0 and cmd.find('%l')>=0:
-                error('The %s and %l specifiers are mutually exclusive '
-                      'in alias definitions.')
-            else:  # all looks OK
-                self.shell.alias_table[alias] = (nargs,cmd)
-                self.shell.alias_table_validate(verbose=0)
+            self.shell.alias_manager.soft_define_alias(alias, cmd)
     # end magic_alias
 
     def magic_unalias(self, parameter_s = ''):
         """Remove an alias"""
 
         aname = parameter_s.strip()
-        if aname in self.shell.alias_table:
-            del self.shell.alias_table[aname]
+        self.shell.alias_manager.undefine_alias(aname)
         stored = self.db.get('stored_aliases', {} )
         if aname in stored:
             print "Removing %stored alias",aname
@@ -2683,24 +2641,21 b' Defaulting color scheme to \'NoColor\'"""'
         This function also resets the root module cache of module completer,
         used on slow filesystems.
         """
-        
-        
-        ip = self.api
+        from IPython.core.alias import InvalidAliasError
 
         # for the benefit of module completer in ipy_completers.py
-        del ip.db['rootmodules']
+        del self.db['rootmodules']
         
         path = [os.path.abspath(os.path.expanduser(p)) for p in 
             os.environ.get('PATH','').split(os.pathsep)]
         path = filter(os.path.isdir,path)
-        
-        alias_table = self.shell.alias_table
+
         syscmdlist = []
+        # Now define isexec in a cross platform manner.
         if os.name == 'posix':
             isexec = lambda fname:os.path.isfile(fname) and \
                      os.access(fname,os.X_OK)
         else:
-
             try:
                 winext = os.environ['pathext'].replace(';','|').replace('.','')
             except KeyError:
@@ -2710,6 +2665,8 b' Defaulting color scheme to \'NoColor\'"""'
             execre = re.compile(r'(.*)\.(%s)$' % winext,re.IGNORECASE)
             isexec = lambda fname:os.path.isfile(fname) and execre.match(fname)
         savedir = os.getcwd()
+
+        # Now walk the paths looking for executables to alias.
         try:
             # write the whole loop for posix/Windows so we don't have an if in
             # the innermost part
@@ -2717,14 +2674,16 b' Defaulting color scheme to \'NoColor\'"""'
                 for pdir in path:
                     os.chdir(pdir)
                     for ff in os.listdir(pdir):
-                        if isexec(ff) and ff not in self.shell.no_alias:
-                            # each entry in the alias table must be (N,name),
-                            # where N is the number of positional arguments of the
-                            # alias.                            
-                            # Dots will be removed from alias names, since ipython
-                            # assumes names with dots to be python code
-                            alias_table[ff.replace('.','')] = (0,ff)
-                            syscmdlist.append(ff)
+                        if isexec(ff):
+                            try:
+                                # Removes dots from the name since ipython
+                                # will assume names with dots to be python.
+                                self.shell.alias_manager.define_alias(
+                                    ff.replace('.',''), ff)
+                            except InvalidAliasError:
+                                pass
+                            else:
+                                syscmdlist.append(ff)
             else:
                 for pdir in path:
                     os.chdir(pdir)
@@ -2733,17 +2692,15 b' Defaulting color scheme to \'NoColor\'"""'
                         if isexec(ff) and base.lower() not in self.shell.no_alias:
                             if ext.lower() == '.exe':
                                 ff = base
-                            alias_table[base.lower().replace('.','')] = (0,ff)
-                            syscmdlist.append(ff)
-            # Make sure the alias table doesn't contain keywords or builtins
-            self.shell.alias_table_validate()
-            # Call again init_auto_alias() so we get 'rm -i' and other
-            # modified aliases since %rehashx will probably clobber them
-            
-            # no, we don't want them. if %rehashx clobbers them, good,
-            # we'll probably get better versions
-            # self.shell.init_auto_alias()
-            db = ip.db
+                                try:
+                                    # Removes dots from the name since ipython
+                                    # will assume names with dots to be python.
+                                    self.shell.alias_manager.define_alias(
+                                        base.lower().replace('.',''), ff)
+                                except InvalidAliasError:
+                                    pass
+                                syscmdlist.append(ff)
+            db = self.db
             db['syscmdlist'] = syscmdlist
         finally:
             os.chdir(savedir)
@@ -2853,9 +2810,8 b' Defaulting color scheme to \'NoColor\'"""'
         if ps:
             try:                
                 os.chdir(os.path.expanduser(ps))
-                if self.shell.rc.term_title:
-                    #print 'set term title:',self.shell.rc.term_title  # dbg
-                    platutils.set_term_title('IPy ' + abbrev_cwd())
+                if self.shell.term_title:
+                    platutils.set_term_title('IPython: ' + abbrev_cwd())
             except OSError:
                 print sys.exc_info()[1]
             else:
@@ -2867,8 +2823,8 b' Defaulting color scheme to \'NoColor\'"""'
                 
         else:
             os.chdir(self.shell.home_dir)
-            if self.shell.rc.term_title:
-                platutils.set_term_title("IPy ~")
+            if self.shell.term_title:
+                platutils.set_term_title('IPython: ' + '~')
             cwd = os.getcwd()
             dhist = self.shell.user_ns['_dh']
             
@@ -3168,10 +3124,10 b' Defaulting color scheme to \'NoColor\'"""'
         """
 
         start = parameter_s.strip()
-        esc_magic = self.shell.ESC_MAGIC
+        esc_magic = ESC_MAGIC
         # Identify magic commands even if automagic is on (which means
         # the in-memory version is different from that typed by the user).
-        if self.shell.rc.automagic:
+        if self.shell.automagic:
             start_magic = esc_magic+start
         else:
             start_magic = start
@@ -3265,7 +3221,7 b' Defaulting color scheme to \'NoColor\'"""'
             return
             
         page(self.shell.pycolorize(cont),
-             screen_lines=self.shell.rc.screen_length)
+             screen_lines=self.shell.usable_screen_length)
 
     def _rerun_pasted(self):
         """ Rerun a previously pasted command.
@@ -3438,7 +3394,7 b' Defaulting color scheme to \'NoColor\'"""'
         ipinstallation = path(IPython.__file__).dirname()
         upgrade_script = '%s "%s"' % (sys.executable,ipinstallation / 'utils' / 'upgradedir.py')
         src_config = ipinstallation / 'config' / 'userconfig'
-        userdir = path(ip.options.ipythondir)
+        userdir = path(ip.config.IPYTHONDIR)
         cmd = '%s "%s" "%s"' % (upgrade_script, src_config, userdir)
         print ">",cmd
         shell(cmd)
@@ -3478,7 +3434,6 b' Defaulting color scheme to \'NoColor\'"""'
         # Shorthands
         shell = self.shell
         oc = shell.outputcache
-        rc = shell.rc
         meta = shell.meta
         # dstore is a data store kept in the instance metadata bag to track any
         # changes we make, so we can undo them later.
@@ -3487,12 +3442,12 b' Defaulting color scheme to \'NoColor\'"""'
 
         # save a few values we'll need to recover later
         mode = save_dstore('mode',False)
-        save_dstore('rc_pprint',rc.pprint)
+        save_dstore('rc_pprint',shell.pprint)
         save_dstore('xmode',shell.InteractiveTB.mode)
-        save_dstore('rc_separate_out',rc.separate_out)
-        save_dstore('rc_separate_out2',rc.separate_out2)
-        save_dstore('rc_prompts_pad_left',rc.prompts_pad_left)
-        save_dstore('rc_separate_in',rc.separate_in)
+        save_dstore('rc_separate_out',shell.separate_out)
+        save_dstore('rc_separate_out2',shell.separate_out2)
+        save_dstore('rc_prompts_pad_left',shell.prompts_pad_left)
+        save_dstore('rc_separate_in',shell.separate_in)
 
         if mode == False:
             # turn on
@@ -3510,7 +3465,7 b' Defaulting color scheme to \'NoColor\'"""'
             oc.prompt1.pad_left = oc.prompt2.pad_left = \
                                   oc.prompt_out.pad_left = False
 
-            rc.pprint = False
+            shell.pprint = False
 
             shell.magic_xmode('Plain')
 
@@ -3518,9 +3473,9 b' Defaulting color scheme to \'NoColor\'"""'
             # turn off
             ipaste.deactivate_prefilter()
 
-            oc.prompt1.p_template = rc.prompt_in1
-            oc.prompt2.p_template = rc.prompt_in2
-            oc.prompt_out.p_template = rc.prompt_out
+            oc.prompt1.p_template = shell.prompt_in1
+            oc.prompt2.p_template = shell.prompt_in2
+            oc.prompt_out.p_template = shell.prompt_out
 
             oc.input_sep = oc.prompt1.sep = dstore.rc_separate_in
 

IPython/core/oinspect.py

@@ -28,7 +28,8 b' import types'
 
 # IPython's own
 from IPython.utils import PyColorize
-from IPython.utils.genutils import page,indent,Term
+from IPython.utils.genutils import indent, Term
+from IPython.core.page import page
 from IPython.external.Itpl import itpl
 from IPython.utils.wildcard import list_namespace
 from IPython.utils.coloransi import *

IPython/core/prefilter.py

@@ -1,14 +1,103 b''
-# -*- coding: utf-8 -*-
+#!/usr/bin/env python
+# encoding: utf-8
 """
-Classes and functions for prefiltering (transforming) a line of user input.
-This module is responsible, primarily, for breaking the line up into useful
-pieces and triggering the appropriate handlers in iplib to do the actual
-transforming work.
+Prefiltering components.
+
+Prefilters transform user input before it is exec'd by Python.  These
+transforms are used to implement additional syntax such as !ls and %magic.
+
+Authors:
+
+* Brian Granger
+* Fernando Perez
+* Dan Milstein
+* Ville Vainio
 """
-__docformat__ = "restructuredtext en"
 
+#-----------------------------------------------------------------------------
+#  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 codeop
+import keyword
+import os
 import re
-from IPython.core import ipapi
+import sys
+
+from IPython.core.alias import AliasManager
+from IPython.core.autocall import IPyAutocall
+from IPython.core.component import Component
+from IPython.core.splitinput import split_user_input
+from IPython.core.page import page
+
+from IPython.utils.traitlets import List, Int, Any, Str, CBool, Bool
+from IPython.utils.genutils import make_quoted_expr
+from IPython.utils.autoattr import auto_attr
+
+#-----------------------------------------------------------------------------
+# Global utilities, errors and constants
+#-----------------------------------------------------------------------------
+
+# Warning, these cannot be changed unless various regular expressions
+# are updated in a number of places.  Not great, but at least we told you.
+ESC_SHELL  = '!'
+ESC_SH_CAP = '!!'
+ESC_HELP   = '?'
+ESC_MAGIC  = '%'
+ESC_QUOTE  = ','
+ESC_QUOTE2 = ';'
+ESC_PAREN  = '/'
+
+
+class PrefilterError(Exception):
+    pass
+
+
+# RegExp to identify potential function names
+re_fun_name = re.compile(r'[a-zA-Z_]([a-zA-Z0-9_.]*) *$')
+
+# RegExp to exclude strings with this start from autocalling.  In
+# particular, all binary operators should be excluded, so that if foo is
+# callable, foo OP bar doesn't become foo(OP bar), which is invalid.  The
+# characters '!=()' don't need to be checked for, as the checkPythonChars
+# routine explicitely does so, to catch direct calls and rebindings of
+# existing names.
+
+# Warning: the '-' HAS TO BE AT THE END of the first group, otherwise
+# it affects the rest of the group in square brackets.
+re_exclude_auto = re.compile(r'^[,&^\|\*/\+-]'
+                             r'|^is |^not |^in |^and |^or ')
+
+# try to catch also methods for stuff in lists/tuples/dicts: off
+# (experimental). For this to work, the line_split regexp would need
+# to be modified so it wouldn't break things at '['. That line is
+# nasty enough that I shouldn't change it until I can test it _well_.
+#self.re_fun_name = re.compile (r'[a-zA-Z_]([a-zA-Z0-9_.\[\]]*) ?$')
+
+
+# Handler Check Utilities
+def is_shadowed(identifier, ip):
+    """Is the given identifier defined in one of the namespaces which shadow
+    the alias and magic namespaces?  Note that an identifier is different
+    than ifun, because it can not contain a '.' character."""
+    # This is much safer than calling ofind, which can change state
+    return (identifier in ip.user_ns \
+            or identifier in ip.internal_ns \
+            or identifier in ip.ns_table['builtin'])
+
+
+#-----------------------------------------------------------------------------
+# The LineInfo class used throughout
+#-----------------------------------------------------------------------------
+
 
 class LineInfo(object):
     """A single line of input and associated info.
@@ -24,39 +113,39 b' class LineInfo(object):'
     pre
       The initial esc character or whitespace.
     
-    preChar
+    pre_char
       The escape character(s) in pre or the empty string if there isn't one.
-      Note that '!!' is a possible value for preChar.  Otherwise it will
+      Note that '!!' is a possible value for pre_char.  Otherwise it will
       always be a single character.
     
-    preWhitespace
-      The leading whitespace from pre if it exists.  If there is a preChar,
+    pre_whitespace
+      The leading whitespace from pre if it exists.  If there is a pre_char,
       this is just ''.
     
-    iFun
+    ifun
       The 'function part', which is basically the maximal initial sequence
       of valid python identifiers and the '.' character.  This is what is
       checked for alias and magic transformations, used for auto-calling,
       etc.
     
-    theRest
+    the_rest
       Everything else on the line.
     """
     def __init__(self, line, continue_prompt):
         self.line            = line
         self.continue_prompt = continue_prompt
-        self.pre, self.iFun, self.theRest = splitUserInput(line)
+        self.pre, self.ifun, self.the_rest = split_user_input(line)
 
-        self.preChar       = self.pre.strip()
-        if self.preChar:
-            self.preWhitespace = '' # No whitespace allowd before esc chars
+        self.pre_char       = self.pre.strip()
+        if self.pre_char:
+            self.pre_whitespace = '' # No whitespace allowd before esc chars
         else: 
-            self.preWhitespace = self.pre
+            self.pre_whitespace = self.pre
 
         self._oinfo = None
 
     def ofind(self, ip):
-        """Do a full, attribute-walking lookup of the iFun in the various
+        """Do a full, attribute-walking lookup of the ifun in the various
         namespaces for the given IPython InteractiveShell instance.
 
         Return a dict with keys: found,obj,ospace,ismagic
@@ -69,252 +158,838 b' class LineInfo(object):'
         without worrying about *further* damaging state.
         """
         if not self._oinfo:
-            self._oinfo = ip._ofind(self.iFun)
+            self._oinfo = ip._ofind(self.ifun)
         return self._oinfo
+
     def __str__(self):                                                         
-        return "Lineinfo [%s|%s|%s]" %(self.pre,self.iFun,self.theRest)        
+        return "Lineinfo [%s|%s|%s]" %(self.pre,self.ifun,self.the_rest) 
 
-def splitUserInput(line, pattern=None):
-    """Split user input into pre-char/whitespace, function part and rest.
 
-    Mostly internal to this module, but also used by iplib.expand_aliases,
-    which passes in a shell pattern.
-    """
-    # It seems to me that the shell splitting should be a separate method.
-    
-    if not pattern:
-        pattern = line_split
-    match = pattern.match(line)
-    if not match:
-        #print "match failed for line '%s'" % line
-        try:
-            iFun,theRest = line.split(None,1)
-        except ValueError:
-            #print "split failed for line '%s'" % line
-            iFun,theRest = line,''
-        pre = re.match('^(\s*)(.*)',line).groups()[0]
-    else:
-        pre,iFun,theRest = match.groups()
-
-    # iFun has to be a valid python identifier, so it better be only pure
-    # ascii, no unicode:
-    try:
-        iFun = iFun.encode('ascii')
-    except UnicodeEncodeError:
-        theRest = iFun + u' ' + theRest
-        iFun = u''
-
-    #print 'line:<%s>' % line # dbg
-    #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun.strip(),theRest) # dbg
-    return pre,iFun.strip(),theRest.lstrip()
-
-
-# RegExp for splitting line contents into pre-char//first word-method//rest.
-# For clarity, each group in on one line.
-
-# WARNING: update the regexp if the escapes in iplib are changed, as they
-# are hardwired in.
-
-# Although it's not solely driven by the regex, note that:
-# ,;/% only trigger if they are the first character on the line
-# ! and !! trigger if they are first char(s) *or* follow an indent 
-# ? triggers as first or last char.
-
-# The three parts of the regex are:
-#  1) pre:     pre_char *or* initial whitespace 
-#  2) iFun:    first word/method (mix of \w and '.')
-#  3) theRest: rest of line (separated from iFun by space if non-empty)
-line_split = re.compile(r'^([,;/%?]|!!?|\s*)'
-                        r'\s*([\w\.]+)'
-                        r'(\s+.*$|$)')
-
-shell_line_split = re.compile(r'^(\s*)(\S*\s*)(.*$)')
-
-def prefilter(line_info, ip):
-    """Call one of the passed-in InteractiveShell's handler preprocessors,
-    depending on the form of the line.  Return the results, which must be a
-    value, even if it's a blank ('')."""
-    # Note: the order of these checks does matter. 
-    for check in [ checkEmacs,
-                   checkShellEscape,
-                   checkIPyAutocall,
-                   checkMultiLineMagic,
-                   checkEscChars,
-                   checkAssignment,
-                   checkAutomagic,
-                   checkAlias,
-                   checkPythonOps,
-                   checkAutocall,
-                   ]:
-        handler = check(line_info, ip)
-        if handler:
-            return handler(line_info)
-
-    return ip.handle_normal(line_info)
-
-# Handler checks
-#
-# All have the same interface: they take a LineInfo object and a ref to the
-# iplib.InteractiveShell object.  They check the line to see if a particular
-# handler should be called, and return either a handler or None.  The
-# handlers which they return are *bound* methods of the InteractiveShell
-# object. 
-#
-# In general, these checks should only take responsibility for their 'own'
-# handler.  If it doesn't get triggered, they should just return None and
-# let the rest of the check sequence run.
-
-def checkShellEscape(l_info,ip):
-    if l_info.line.lstrip().startswith(ip.ESC_SHELL):
-        return ip.handle_shell_escape
-
-def checkEmacs(l_info,ip):
-    "Emacs ipython-mode tags certain input lines."
-    if l_info.line.endswith('# PYTHON-MODE'):
-        return ip.handle_emacs
-    else:
-        return None
+#-----------------------------------------------------------------------------
+# Main Prefilter manager
+#-----------------------------------------------------------------------------
 
-def checkIPyAutocall(l_info,ip):
-    "Instances of IPyAutocall in user_ns get autocalled immediately"
-    obj = ip.user_ns.get(l_info.iFun, None)
-    if isinstance(obj, ipapi.IPyAutocall):
-        obj.set_ip(ip.api)
-        return ip.handle_auto
-    else:
-        return None
-    
-    
-def checkMultiLineMagic(l_info,ip):
-    "Allow ! and !! in multi-line statements if multi_line_specials is on"
-    # Note that this one of the only places we check the first character of
-    # iFun and *not* the preChar.  Also note that the below test matches
-    # both ! and !!.    
-    if l_info.continue_prompt \
-        and ip.rc.multi_line_specials:
-            if l_info.iFun.startswith(ip.ESC_MAGIC):
-                return ip.handle_magic
-    else:
-        return None
 
-def checkEscChars(l_info,ip):
-    """Check for escape character and return either a handler to handle it,
-    or None if there is no escape char."""
-    if l_info.line[-1] == ip.ESC_HELP \
-           and l_info.preChar != ip.ESC_SHELL \
-           and l_info.preChar != ip.ESC_SH_CAP:
-        # the ? can be at the end, but *not* for either kind of shell escape,
-        # because a ? can be a vaild final char in a shell cmd
-        return ip.handle_help
-    elif l_info.preChar in ip.esc_handlers:
-        return ip.esc_handlers[l_info.preChar]
-    else:
-        return None
+class PrefilterManager(Component):
+    """Main prefilter component.
+
+    The IPython prefilter is run on all user input before it is run.  The
+    prefilter consumes lines of input and produces transformed lines of 
+    input.
+
+    The iplementation consists of two phases:
+
+    1. Transformers
+    2. Checkers and handlers
+
+    Over time, we plan on deprecating the checkers and handlers and doing
+    everything in the transformers.
 
+    The transformers are instances of :class:`PrefilterTransformer` and have
+    a single method :meth:`transform` that takes a line and returns a
+    transformed line.  The transformation can be accomplished using any
+    tool, but our current ones use regular expressions for speed.  We also
+    ship :mod:`pyparsing` in :mod:`IPython.external` for use in transformers.
 
-def checkAssignment(l_info,ip):
-    """Check to see if user is assigning to a var for the first time, in
-    which case we want to avoid any sort of automagic / autocall games.
+    After all the transformers have been run, the line is fed to the checkers,
+    which are instances of :class:`PrefilterChecker`.  The line is passed to
+    the :meth:`check` method, which either returns `None` or a 
+    :class:`PrefilterHandler` instance.  If `None` is returned, the other
+    checkers are tried.  If an :class:`PrefilterHandler` instance is returned,
+    the line is passed to the :meth:`handle` method of the returned
+    handler and no further checkers are tried.
     
-    This allows users to assign to either alias or magic names true python
-    variables (the magic/alias systems always take second seat to true
-    python code).  E.g. ls='hi', or ls,that=1,2"""
-    if l_info.theRest and l_info.theRest[0] in '=,':
-        return ip.handle_normal
-    else:
-        return None
+    Both transformers and checkers have a `priority` attribute, that determines
+    the order in which they are called.  Smaller priorities are tried first.
 
+    Both transformers and checkers also have `enabled` attribute, which is
+    a boolean that determines if the instance is used.
 
-def checkAutomagic(l_info,ip):
-    """If the iFun is magic, and automagic is on, run it.  Note: normal,
-    non-auto magic would already have been triggered via '%' in
-    check_esc_chars. This just checks for automagic.  Also, before
-    triggering the magic handler, make sure that there is nothing in the
-    user namespace which could shadow it."""
-    if not ip.rc.automagic or not hasattr(ip,'magic_'+l_info.iFun):
-        return None
+    Users or developers can change the priority or enabled attribute of
+    transformers or checkers, but they must call the :meth:`sort_checkers`
+    or :meth:`sort_transformers` method after changing the priority.
+    """
 
-    # We have a likely magic method.  Make sure we should actually call it.
-    if l_info.continue_prompt and not ip.rc.multi_line_specials:
-        return None
+    multi_line_specials = CBool(True, config=True)
 
-    head = l_info.iFun.split('.',1)[0]
-    if isShadowed(head,ip):
-        return None
+    def __init__(self, parent, config=None):
+        super(PrefilterManager, self).__init__(parent, config=config)
+        self.init_transformers()
+        self.init_handlers()
+        self.init_checkers()
+
+    @auto_attr
+    def shell(self):
+        return Component.get_instances(
+            root=self.root,
+            klass='IPython.core.iplib.InteractiveShell')[0]
 
-    return ip.handle_magic
+    #-------------------------------------------------------------------------
+    # API for managing transformers
+    #-------------------------------------------------------------------------
 
+    def init_transformers(self):
+        """Create the default transformers."""
+        self._transformers = []
+        for transformer_cls in _default_transformers:
+            transformer_cls(self, config=self.config)
+
+    def sort_transformers(self):
+        """Sort the transformers by priority.
+
+        This must be called after the priority of a transformer is changed.
+        The :meth:`register_transformer` method calls this automatically.
+        """
+        self._transformers.sort(cmp=lambda x,y: x.priority-y.priority)
+
+    @property
+    def transformers(self):
+        """Return a list of checkers, sorted by priority."""
+        return self._transformers
+
+    def register_transformer(self, transformer):
+        """Register a transformer instance."""
+        if transformer not in self._transformers:
+            self._transformers.append(transformer)
+            self.sort_transformers()
+
+    def unregister_transformer(self, transformer):
+        """Unregister a transformer instance."""
+        if transformer in self._transformers:
+            self._transformers.remove(transformer)
+
+    #-------------------------------------------------------------------------
+    # API for managing checkers
+    #-------------------------------------------------------------------------
+
+    def init_checkers(self):
+        """Create the default checkers."""
+        self._checkers = []
+        for checker in _default_checkers:
+            checker(self, config=self.config)
+
+    def sort_checkers(self):
+        """Sort the checkers by priority.
+
+        This must be called after the priority of a checker is changed.
+        The :meth:`register_checker` method calls this automatically.
+        """
+        self._checkers.sort(cmp=lambda x,y: x.priority-y.priority)
+
+    @property
+    def checkers(self):
+        """Return a list of checkers, sorted by priority."""
+        return self._checkers
+
+    def register_checker(self, checker):
+        """Register a checker instance."""
+        if checker not in self._checkers:
+            self._checkers.append(checker)
+            self.sort_checkers()
+
+    def unregister_checker(self, checker):
+        """Unregister a checker instance."""
+        if checker in self._checkers:
+            self._checkers.remove(checker)
+
+    #-------------------------------------------------------------------------
+    # API for managing checkers
+    #-------------------------------------------------------------------------
+
+    def init_handlers(self):
+        """Create the default handlers."""
+        self._handlers = {}
+        self._esc_handlers = {}
+        for handler in _default_handlers:
+            handler(self, config=self.config)
+
+    @property
+    def handlers(self):
+        """Return a dict of all the handlers."""
+        return self._handlers
+
+    def register_handler(self, name, handler, esc_strings):
+        """Register a handler instance by name with esc_strings."""
+        self._handlers[name] = handler
+        for esc_str in esc_strings:
+            self._esc_handlers[esc_str] = handler
+
+    def unregister_handler(self, name, handler, esc_strings):
+        """Unregister a handler instance by name with esc_strings."""
+        try:
+            del self._handlers[name]
+        except KeyError:
+            pass
+        for esc_str in esc_strings:
+            h = self._esc_handlers.get(esc_str)
+            if h is handler:
+                del self._esc_handlers[esc_str]
+
+    def get_handler_by_name(self, name):
+        """Get a handler by its name."""
+        return self._handlers.get(name)
+
+    def get_handler_by_esc(self, esc_str):
+        """Get a handler by its escape string."""
+        return self._esc_handlers.get(esc_str)
+
+    #-------------------------------------------------------------------------
+    # Main prefiltering API
+    #-------------------------------------------------------------------------
+
+    def prefilter_line_info(self, line_info):
+        """Prefilter a line that has been converted to a LineInfo object.
+
+        This implements the checker/handler part of the prefilter pipe.
+        """
+        # print "prefilter_line_info: ", line_info
+        handler = self.find_handler(line_info)
+        return handler.handle(line_info)
+
+    def find_handler(self, line_info):
+        """Find a handler for the line_info by trying checkers."""
+        for checker in self.checkers:
+            if checker.enabled:
+                handler = checker.check(line_info)
+                if handler:
+                    return handler
+        return self.get_handler_by_name('normal')
+
+    def transform_line(self, line, continue_prompt):
+        """Calls the enabled transformers in order of increasing priority."""
+        for transformer in self.transformers:
+            if transformer.enabled:
+                line = transformer.transform(line, continue_prompt)
+        return line
+
+    def prefilter_line(self, line, continue_prompt):
+        """Prefilter a single input line as text.
+
+        This method prefilters a single line of text by calling the
+        transformers and then the checkers/handlers.
+        """
+
+        # print "prefilter_line: ", line, continue_prompt
+        # All handlers *must* return a value, even if it's blank ('').
+
+        # Lines are NOT logged here. Handlers should process the line as
+        # needed, update the cache AND log it (so that the input cache array
+        # stays synced).
+
+        # save the line away in case we crash, so the post-mortem handler can
+        # record it
+        self.shell._last_input_line = line
+
+        if not line:
+            # Return immediately on purely empty lines, so that if the user
+            # previously typed some whitespace that started a continuation
+            # prompt, he can break out of that loop with just an empty line.
+            # This is how the default python prompt works.
+
+            # Only return if the accumulated input buffer was just whitespace!
+            if ''.join(self.shell.buffer).isspace():
+                self.shell.buffer[:] = []
+            return ''
+
+        # At this point, we invoke our transformers.
+        if not continue_prompt or (continue_prompt and self.multi_line_specials):
+            line = self.transform_line(line, continue_prompt)
+
+        # Now we compute line_info for the checkers and handlers
+        line_info = LineInfo(line, continue_prompt)
         
-def checkAlias(l_info,ip):
-    "Check if the initital identifier on the line is an alias."
-    # Note: aliases can not contain '.'
-    head = l_info.iFun.split('.',1)[0]
-    
-    if l_info.iFun not in ip.alias_table \
-           or head not in ip.alias_table \
-           or isShadowed(head,ip): 
-        return None
+        # the input history needs to track even empty lines
+        stripped = line.strip()
 
-    return ip.handle_alias
+        normal_handler = self.get_handler_by_name('normal')
+        if not stripped:
+            if not continue_prompt:
+                self.shell.outputcache.prompt_count -= 1
 
+            return normal_handler.handle(line_info)
 
-def checkPythonOps(l_info,ip):
-    """If the 'rest' of the line begins with a function call or pretty much
-    any python operator, we should simply execute the line (regardless of
-    whether or not there's a possible autocall expansion).  This avoids
-    spurious (and very confusing) geattr() accesses."""
-    if l_info.theRest and l_info.theRest[0] in '!=()<>,+*/%^&|':
-        return ip.handle_normal
-    else:
-        return None
+        # special handlers are only allowed for single line statements
+        if continue_prompt and not self.multi_line_specials:
+            return normal_handler.handle(line_info)
 
+        prefiltered = self.prefilter_line_info(line_info)
+        # print "prefiltered line: %r" % prefiltered
+        return prefiltered
 
-def checkAutocall(l_info,ip):
-    "Check if the initial word/function is callable and autocall is on."
-    if not ip.rc.autocall:
-        return None
+    def prefilter_lines(self, lines, continue_prompt):
+        """Prefilter multiple input lines of text.
+
+        This is the main entry point for prefiltering multiple lines of
+        input.  This simply calls :meth:`prefilter_line` for each line of
+        input.
+
+        This covers cases where there are multiple lines in the user entry,
+        which is the case when the user goes back to a multiline history
+        entry and presses enter.
+        """
+        out = []
+        for line in lines.rstrip('\n').split('\n'):
+            out.append(self.prefilter_line(line, continue_prompt))
+        return '\n'.join(out)
+
+
+#-----------------------------------------------------------------------------
+# Prefilter transformers
+#-----------------------------------------------------------------------------
+
+
+class PrefilterTransformer(Component):
+    """Transform a line of user input."""
+
+    priority = Int(100, config=True)
+    shell = Any
+    prefilter_manager = Any
+    enabled = Bool(True, config=True)
+
+    def __init__(self, parent, config=None):
+        super(PrefilterTransformer, self).__init__(parent, config=config)
+        self.prefilter_manager.register_transformer(self)
+
+    @auto_attr
+    def shell(self):
+        return Component.get_instances(
+            root=self.root,
+            klass='IPython.core.iplib.InteractiveShell')[0]
+
+    @auto_attr
+    def prefilter_manager(self):
+        return PrefilterManager.get_instances(root=self.root)[0]
 
-    oinfo = l_info.ofind(ip) # This can mutate state via getattr
-    if not oinfo['found']:
+    def transform(self, line, continue_prompt):
+        """Transform a line, returning the new one."""
         return None
-        
-    if callable(oinfo['obj']) \
-           and (not re_exclude_auto.match(l_info.theRest)) \
-           and re_fun_name.match(l_info.iFun):
-        #print 'going auto'  # dbg
-        return ip.handle_auto
-    else:
-        #print 'was callable?', callable(l_info.oinfo['obj'])  # dbg
+
+    def __repr__(self):
+        return "<%s(priority=%r, enabled=%r)>" % (
+            self.__class__.__name__, self.priority, self.enabled)
+
+
+_assign_system_re = re.compile(r'(?P<lhs>(\s*)([\w\.]+)((\s*,\s*[\w\.]+)*))'
+                               r'\s*=\s*!(?P<cmd>.*)')
+
+
+class AssignSystemTransformer(PrefilterTransformer):
+    """Handle the `files = !ls` syntax."""
+
+    priority = Int(100, config=True)
+
+    def transform(self, line, continue_prompt):
+        m = _assign_system_re.match(line)
+        if m is not None:
+            cmd = m.group('cmd')
+            lhs = m.group('lhs')
+            expr = make_quoted_expr("sc -l =%s" % cmd)
+            new_line = '%s = get_ipython().magic(%s)' % (lhs, expr)
+            return new_line
+        return line
+
+
+_assign_magic_re = re.compile(r'(?P<lhs>(\s*)([\w\.]+)((\s*,\s*[\w\.]+)*))'
+                               r'\s*=\s*%(?P<cmd>.*)')
+
+class AssignMagicTransformer(PrefilterTransformer):
+    """Handle the `a = %who` syntax."""
+
+    priority = Int(200, config=True)
+
+    def transform(self, line, continue_prompt):
+        m = _assign_magic_re.match(line)
+        if m is not None:
+            cmd = m.group('cmd')
+            lhs = m.group('lhs')
+            expr = make_quoted_expr(cmd)
+            new_line = '%s = get_ipython().magic(%s)' % (lhs, expr)
+            return new_line
+        return line
+
+
+#-----------------------------------------------------------------------------
+# Prefilter checkers
+#-----------------------------------------------------------------------------
+
+
+class PrefilterChecker(Component):
+    """Inspect an input line and return a handler for that line."""
+
+    priority = Int(100, config=True)
+    shell = Any
+    prefilter_manager = Any
+    enabled = Bool(True, config=True)
+
+    def __init__(self, parent, config=None):
+        super(PrefilterChecker, self).__init__(parent, config=config)
+        self.prefilter_manager.register_checker(self)
+
+    @auto_attr
+    def shell(self):
+        return Component.get_instances(
+            root=self.root,
+            klass='IPython.core.iplib.InteractiveShell')[0]
+
+    @auto_attr
+    def prefilter_manager(self):
+        return PrefilterManager.get_instances(root=self.root)[0]
+
+    def check(self, line_info):
+        """Inspect line_info and return a handler instance or None."""
         return None
+
+    def __repr__(self):
+        return "<%s(priority=%r, enabled=%r)>" % (
+            self.__class__.__name__, self.priority, self.enabled)
+
+
+class EmacsChecker(PrefilterChecker):
+
+    priority = Int(100, config=True)
+    enabled = Bool(False, config=True)
+
+    def check(self, line_info):
+        "Emacs ipython-mode tags certain input lines."
+        if line_info.line.endswith('# PYTHON-MODE'):
+            return self.prefilter_manager.get_handler_by_name('emacs')
+        else:
+            return None
+
+
+class ShellEscapeChecker(PrefilterChecker):
+
+    priority = Int(200, config=True)
+
+    def check(self, line_info):
+        if line_info.line.lstrip().startswith(ESC_SHELL):
+            return self.prefilter_manager.get_handler_by_name('shell')
+
+
+class IPyAutocallChecker(PrefilterChecker):
+
+    priority = Int(300, config=True)
+
+    def check(self, line_info):
+        "Instances of IPyAutocall in user_ns get autocalled immediately"
+        obj = self.shell.user_ns.get(line_info.ifun, None)
+        if isinstance(obj, IPyAutocall):
+            obj.set_ip(self.shell)
+            return self.prefilter_manager.get_handler_by_name('auto')
+        else:
+            return None
+
+
+class MultiLineMagicChecker(PrefilterChecker):
+
+    priority = Int(400, config=True)
+
+    def check(self, line_info):
+        "Allow ! and !! in multi-line statements if multi_line_specials is on"
+        # Note that this one of the only places we check the first character of
+        # ifun and *not* the pre_char.  Also note that the below test matches
+        # both ! and !!.    
+        if line_info.continue_prompt \
+            and self.prefilter_manager.multi_line_specials:
+                if line_info.ifun.startswith(ESC_MAGIC):
+                    return self.prefilter_manager.get_handler_by_name('magic')
+        else:
+            return None
+
+
+class EscCharsChecker(PrefilterChecker):
+
+    priority = Int(500, config=True)
+
+    def check(self, line_info):
+        """Check for escape character and return either a handler to handle it,
+        or None if there is no escape char."""
+        if line_info.line[-1] == ESC_HELP \
+               and line_info.pre_char != ESC_SHELL \
+               and line_info.pre_char != ESC_SH_CAP:
+            # the ? can be at the end, but *not* for either kind of shell escape,
+            # because a ? can be a vaild final char in a shell cmd
+            return self.prefilter_manager.get_handler_by_name('help')
+        else:
+            # This returns None like it should if no handler exists
+            return self.prefilter_manager.get_handler_by_esc(line_info.pre_char)
+
+
+class AssignmentChecker(PrefilterChecker):
+
+    priority = Int(600, config=True)
+
+    def check(self, line_info):
+        """Check to see if user is assigning to a var for the first time, in
+        which case we want to avoid any sort of automagic / autocall games.
     
-# RegExp to identify potential function names
-re_fun_name = re.compile(r'[a-zA-Z_]([a-zA-Z0-9_.]*) *$')
+        This allows users to assign to either alias or magic names true python
+        variables (the magic/alias systems always take second seat to true
+        python code).  E.g. ls='hi', or ls,that=1,2"""
+        if line_info.the_rest:
+            if line_info.the_rest[0] in '=,':
+                return self.prefilter_manager.get_handler_by_name('normal')
+        else:
+            return None
 
-# RegExp to exclude strings with this start from autocalling.  In
-# particular, all binary operators should be excluded, so that if foo is
-# callable, foo OP bar doesn't become foo(OP bar), which is invalid.  The
-# characters '!=()' don't need to be checked for, as the checkPythonChars
-# routine explicitely does so, to catch direct calls and rebindings of
-# existing names.
 
-# Warning: the '-' HAS TO BE AT THE END of the first group, otherwise
-# it affects the rest of the group in square brackets.
-re_exclude_auto = re.compile(r'^[,&^\|\*/\+-]'
-                             r'|^is |^not |^in |^and |^or ')
+class AutoMagicChecker(PrefilterChecker):
 
-# try to catch also methods for stuff in lists/tuples/dicts: off
-# (experimental). For this to work, the line_split regexp would need
-# to be modified so it wouldn't break things at '['. That line is
-# nasty enough that I shouldn't change it until I can test it _well_.
-#self.re_fun_name = re.compile (r'[a-zA-Z_]([a-zA-Z0-9_.\[\]]*) ?$')
+    priority = Int(700, config=True)
 
-# Handler Check Utilities
-def isShadowed(identifier,ip):
-    """Is the given identifier defined in one of the namespaces which shadow
-    the alias and magic namespaces?  Note that an identifier is different
-    than iFun, because it can not contain a '.' character."""
-    # This is much safer than calling ofind, which can change state
-    return (identifier in ip.user_ns \
-            or identifier in ip.internal_ns \
-            or identifier in ip.ns_table['builtin'])
+    def check(self, line_info):
+        """If the ifun is magic, and automagic is on, run it.  Note: normal,
+        non-auto magic would already have been triggered via '%' in
+        check_esc_chars. This just checks for automagic.  Also, before
+        triggering the magic handler, make sure that there is nothing in the
+        user namespace which could shadow it."""
+        if not self.shell.automagic or not hasattr(self.shell,'magic_'+line_info.ifun):
+            return None
+
+        # We have a likely magic method.  Make sure we should actually call it.
+        if line_info.continue_prompt and not self.shell.multi_line_specials:
+            return None
+
+        head = line_info.ifun.split('.',1)[0]
+        if is_shadowed(head, self.shell):
+            return None
+
+        return self.prefilter_manager.get_handler_by_name('magic')
+
+
+class AliasChecker(PrefilterChecker):
+
+    priority = Int(800, config=True)
+
+    @auto_attr
+    def alias_manager(self):
+        return AliasManager.get_instances(root=self.root)[0]
+
+    def check(self, line_info):
+        "Check if the initital identifier on the line is an alias."
+        # Note: aliases can not contain '.'
+        head = line_info.ifun.split('.',1)[0]
+        if line_info.ifun not in self.alias_manager \
+               or head not in self.alias_manager \
+               or is_shadowed(head, self.shell):
+            return None
+
+        return self.prefilter_manager.get_handler_by_name('alias')
+
+
+class PythonOpsChecker(PrefilterChecker):
+
+    priority = Int(900, config=True)
+
+    def check(self, line_info):
+        """If the 'rest' of the line begins with a function call or pretty much
+        any python operator, we should simply execute the line (regardless of
+        whether or not there's a possible autocall expansion).  This avoids
+        spurious (and very confusing) geattr() accesses."""
+        if line_info.the_rest and line_info.the_rest[0] in '!=()<>,+*/%^&|':
+            return self.prefilter_manager.get_handler_by_name('normal')
+        else:
+            return None
+
+
+class AutocallChecker(PrefilterChecker):
+
+    priority = Int(1000, config=True)
+
+    def check(self, line_info):
+        "Check if the initial word/function is callable and autocall is on."
+        if not self.shell.autocall:
+            return None
+
+        oinfo = line_info.ofind(self.shell) # This can mutate state via getattr
+        if not oinfo['found']:
+            return None
+        
+        if callable(oinfo['obj']) \
+               and (not re_exclude_auto.match(line_info.the_rest)) \
+               and re_fun_name.match(line_info.ifun):
+            return self.prefilter_manager.get_handler_by_name('auto')
+        else:
+            return None
+
+
+#-----------------------------------------------------------------------------
+# Prefilter handlers
+#-----------------------------------------------------------------------------
+
+
+class PrefilterHandler(Component):
+
+    handler_name = Str('normal')
+    esc_strings = List([])
+    shell = Any
+    prefilter_manager = Any
+
+    def __init__(self, parent, config=None):
+        super(PrefilterHandler, self).__init__(parent, config=config)
+        self.prefilter_manager.register_handler(
+            self.handler_name,
+            self,
+            self.esc_strings
+        )
+
+    @auto_attr
+    def shell(self):
+        return Component.get_instances(
+            root=self.root,
+            klass='IPython.core.iplib.InteractiveShell')[0]
+
+    @auto_attr
+    def prefilter_manager(self):
+        return PrefilterManager.get_instances(root=self.root)[0]
+
+    def handle(self, line_info):
+        # print "normal: ", line_info
+        """Handle normal input lines. Use as a template for handlers."""
+
+        # With autoindent on, we need some way to exit the input loop, and I
+        # don't want to force the user to have to backspace all the way to
+        # clear the line.  The rule will be in this case, that either two
+        # lines of pure whitespace in a row, or a line of pure whitespace but
+        # of a size different to the indent level, will exit the input loop.
+        line = line_info.line
+        continue_prompt = line_info.continue_prompt
+
+        if (continue_prompt and self.shell.autoindent and line.isspace() and
+            (0 < abs(len(line) - self.shell.indent_current_nsp) <= 2 or
+             (self.shell.buffer[-1]).isspace() )):
+            line = ''
+
+        self.shell.log(line, line, continue_prompt)
+        return line
+
+    def __str__(self):
+        return "<%s(name=%s)>" % (self.__class__.__name__, self.handler_name)
+
+
+class AliasHandler(PrefilterHandler):
+
+    handler_name = Str('alias')
+
+    @auto_attr
+    def alias_manager(self):
+        return AliasManager.get_instances(root=self.root)[0]
+
+    def handle(self, line_info):
+        """Handle alias input lines. """
+        transformed = self.alias_manager.expand_aliases(line_info.ifun,line_info.the_rest)
+        # pre is needed, because it carries the leading whitespace.  Otherwise
+        # aliases won't work in indented sections.
+        line_out = '%sget_ipython().system(%s)' % (line_info.pre_whitespace,
+                                         make_quoted_expr(transformed))
+        
+        self.shell.log(line_info.line, line_out, line_info.continue_prompt)
+        return line_out
+
+
+class ShellEscapeHandler(PrefilterHandler):
+
+    handler_name = Str('shell')
+    esc_strings = List([ESC_SHELL, ESC_SH_CAP])
+
+    def handle(self, line_info):
+        """Execute the line in a shell, empty return value"""
+        magic_handler = self.prefilter_manager.get_handler_by_name('magic')
+
+        line = line_info.line
+        if line.lstrip().startswith(ESC_SH_CAP):
+            # rewrite LineInfo's line, ifun and the_rest to properly hold the
+            # call to %sx and the actual command to be executed, so
+            # handle_magic can work correctly.  Note that this works even if
+            # the line is indented, so it handles multi_line_specials
+            # properly.
+            new_rest = line.lstrip()[2:]
+            line_info.line = '%ssx %s' % (ESC_MAGIC, new_rest)
+            line_info.ifun = 'sx'
+            line_info.the_rest = new_rest
+            return magic_handler.handle(line_info)
+        else:
+            cmd = line.lstrip().lstrip(ESC_SHELL)
+            line_out = '%sget_ipython().system(%s)' % (line_info.pre_whitespace,
+                                             make_quoted_expr(cmd))
+        # update cache/log and return
+        self.shell.log(line, line_out, line_info.continue_prompt)
+        return line_out
+
+
+class MagicHandler(PrefilterHandler):
+
+    handler_name = Str('magic')
+    esc_strings = List([ESC_MAGIC])
+
+    def handle(self, line_info):
+        """Execute magic functions."""
+        ifun    = line_info.ifun
+        the_rest = line_info.the_rest
+        cmd = '%sget_ipython().magic(%s)' % (line_info.pre_whitespace,
+                                   make_quoted_expr(ifun + " " + the_rest))
+        self.shell.log(line_info.line, cmd, line_info.continue_prompt)
+        return cmd
+
+
+class AutoHandler(PrefilterHandler):
+
+    handler_name = Str('auto')
+    esc_strings = List([ESC_PAREN, ESC_QUOTE, ESC_QUOTE2])
+
+    def handle(self, line_info):
+        """Hande lines which can be auto-executed, quoting if requested."""
+        line    = line_info.line
+        ifun    = line_info.ifun
+        the_rest = line_info.the_rest
+        pre     = line_info.pre
+        continue_prompt = line_info.continue_prompt
+        obj = line_info.ofind(self)['obj']
+
+        #print 'pre <%s> ifun <%s> rest <%s>' % (pre,ifun,the_rest)  # dbg
+
+        # This should only be active for single-line input!
+        if continue_prompt:
+            self.log(line,line,continue_prompt)
+            return line
+
+        force_auto = isinstance(obj, IPyAutocall)
+        auto_rewrite = True
+        
+        if pre == ESC_QUOTE:
+            # Auto-quote splitting on whitespace
+            newcmd = '%s("%s")' % (ifun,'", "'.join(the_rest.split()) )
+        elif pre == ESC_QUOTE2:
+            # Auto-quote whole string
+            newcmd = '%s("%s")' % (ifun,the_rest)
+        elif pre == ESC_PAREN:
+            newcmd = '%s(%s)' % (ifun,",".join(the_rest.split()))
+        else:
+            # Auto-paren.
+            # We only apply it to argument-less calls if the autocall
+            # parameter is set to 2.  We only need to check that autocall is <
+            # 2, since this function isn't called unless it's at least 1.
+            if not the_rest and (self.shell.autocall < 2) and not force_auto:
+                newcmd = '%s %s' % (ifun,the_rest)
+                auto_rewrite = False
+            else:
+                if not force_auto and the_rest.startswith('['):
+                    if hasattr(obj,'__getitem__'):
+                        # Don't autocall in this case: item access for an object
+                        # which is BOTH callable and implements __getitem__.
+                        newcmd = '%s %s' % (ifun,the_rest)
+                        auto_rewrite = False
+                    else:
+                        # if the object doesn't support [] access, go ahead and
+                        # autocall
+                        newcmd = '%s(%s)' % (ifun.rstrip(),the_rest)
+                elif the_rest.endswith(';'):
+                    newcmd = '%s(%s);' % (ifun.rstrip(),the_rest[:-1])
+                else:
+                    newcmd = '%s(%s)' % (ifun.rstrip(), the_rest)
+
+        if auto_rewrite:
+            rw = self.shell.outputcache.prompt1.auto_rewrite() + newcmd
+            
+            try:
+                # plain ascii works better w/ pyreadline, on some machines, so
+                # we use it and only print uncolored rewrite if we have unicode
+                rw = str(rw)
+                print >>Term.cout, rw
+            except UnicodeEncodeError:
+                print "-------------->" + newcmd
+            
+        # log what is now valid Python, not the actual user input (without the
+        # final newline)
+        self.shell.log(line,newcmd,continue_prompt)
+        return newcmd
+
+
+class HelpHandler(PrefilterHandler):
+
+    handler_name = Str('help')
+    esc_strings = List([ESC_HELP])
+
+    def handle(self, line_info):
+        """Try to get some help for the object.
+
+        obj? or ?obj   -> basic information.
+        obj?? or ??obj -> more details.
+        """
+        normal_handler = self.prefilter_manager.get_handler_by_name('normal')
+        line = line_info.line
+        # We need to make sure that we don't process lines which would be
+        # otherwise valid python, such as "x=1 # what?"
+        try:
+            codeop.compile_command(line)
+        except SyntaxError:
+            # We should only handle as help stuff which is NOT valid syntax
+            if line[0]==ESC_HELP:
+                line = line[1:]
+            elif line[-1]==ESC_HELP:
+                line = line[:-1]
+            self.shell.log(line, '#?'+line, line_info.continue_prompt)
+            if line:
+                #print 'line:<%r>' % line  # dbg
+                self.shell.magic_pinfo(line)
+            else:
+                page(self.shell.usage, screen_lines=self.shell.usable_screen_length)
+            return '' # Empty string is needed here!
+        except:
+            raise
+            # Pass any other exceptions through to the normal handler
+            return normal_handler.handle(line_info)
+        else:
+            raise
+            # If the code compiles ok, we should handle it normally
+            return normal_handler.handle(line_info)
+
+
+class EmacsHandler(PrefilterHandler):
+
+    handler_name = Str('emacs')
+    esc_strings = List([])
+
+    def handle(self, line_info):
+        """Handle input lines marked by python-mode."""
+
+        # Currently, nothing is done.  Later more functionality can be added
+        # here if needed.
+
+        # The input cache shouldn't be updated
+        return line_info.line
+
+
+#-----------------------------------------------------------------------------
+# Defaults
+#-----------------------------------------------------------------------------
+
+
+_default_transformers = [
+    AssignSystemTransformer,
+    AssignMagicTransformer
+]
+
+_default_checkers = [
+    EmacsChecker,
+    ShellEscapeChecker,
+    IPyAutocallChecker,
+    MultiLineMagicChecker,
+    EscCharsChecker,
+    AssignmentChecker,
+    AutoMagicChecker,
+    AliasChecker,
+    PythonOpsChecker,
+    AutocallChecker
+]
+
+_default_handlers = [
+    PrefilterHandler,
+    AliasHandler,
+    ShellEscapeHandler,
+    MagicHandler,
+    AutoHandler,
+    HelpHandler,
+    EmacsHandler
+]
 

IPython/core/prompts.py

@@ -23,7 +23,7 b' import time'
 from IPython.utils import coloransi
 from IPython.core import release
 from IPython.external.Itpl import ItplNS
-from IPython.core.ipapi import TryNext
+from IPython.core.error import TryNext
 from IPython.utils.ipstruct import Struct
 from IPython.core.macro import Macro
 import IPython.utils.generics
@@ -546,8 +546,11 b' class CachedOutput:'
             # don't use print, puts an extra space
             cout_write(self.output_sep)
             outprompt = self.shell.hooks.generate_output_prompt()
+            # print "Got prompt: ", outprompt
             if self.do_full_cache:
                 cout_write(outprompt)
+            else:
+                print "self.do_full_cache = False"
 
             # and now call a possibly user-defined print mechanism
             manipulated_val = self.display(arg)

IPython/core/tests/obj_del.py

@@ -31,4 +31,5 b' class A(object):'
 a = A()
 
 # Now, we force an exit, the caller will check that the del printout was given
-_ip.IP.ask_exit()
+_ip = get_ipython()
+_ip.ask_exit()