Merging with upstream trunk

IPython/config/default/ipcluster_config.py

@@ -0,0 +1,184 b''
+import os
+
+c = get_config()
+
+#-----------------------------------------------------------------------------
+# Select which launchers to use
+#-----------------------------------------------------------------------------
+
+# This allows you to control what method is used to start the controller
+# and engines.  The following methods are currently supported:
+# - Start as a regular process on localhost.
+# - Start using mpiexec.
+# - Start using the Windows HPC Server 2008 scheduler
+# - Start using PBS
+# - Start using SSH (currently broken)
+
+
+# The selected launchers can be configured below.
+
+# Options are:
+# - LocalControllerLauncher
+# - MPIExecControllerLauncher
+# - PBSControllerLauncher
+# - WindowsHPCControllerLauncher
+# c.Global.controller_launcher = 'IPython.kernel.launcher.LocalControllerLauncher'
+
+# Options are:
+# - LocalEngineSetLauncher
+# - MPIExecEngineSetLauncher
+# - PBSEngineSetLauncher
+# - WindowsHPCEngineSetLauncher
+# c.Global.engine_launcher = 'IPython.kernel.launcher.LocalEngineSetLauncher'
+
+#-----------------------------------------------------------------------------
+# Global configuration
+#-----------------------------------------------------------------------------
+
+# The default number of engines that will be started. This is overridden by
+# the -n command line option: "ipcluster start -n 4"
+# c.Global.n = 2
+
+# Log to a file in cluster_dir/log, otherwise just log to sys.stdout.
+# c.Global.log_to_file = False
+
+# Remove old logs from cluster_dir/log before starting.
+# c.Global.clean_logs = True
+
+# The working directory for the process. The application will use os.chdir
+# to change to this directory before starting.
+# c.Global.work_dir = os.getcwd()
+
+
+#-----------------------------------------------------------------------------
+# Local process launchers
+#-----------------------------------------------------------------------------
+
+# The command line arguments to call the controller with.
+# c.LocalControllerLauncher.controller_args = \
+#    ['--log-to-file','--log-level', '40']
+
+# The working directory for the controller
+# c.LocalEngineSetLauncher.work_dir = u''
+
+# Command line argument passed to the engines.
+# c.LocalEngineSetLauncher.engine_args = ['--log-to-file','--log-level', '40']
+
+#-----------------------------------------------------------------------------
+# MPIExec launchers
+#-----------------------------------------------------------------------------
+
+# The mpiexec/mpirun command to use in started the controller.
+# c.MPIExecControllerLauncher.mpi_cmd = ['mpiexec']
+
+# Additional arguments to pass to the actual mpiexec command.
+# c.MPIExecControllerLauncher.mpi_args = []
+
+# The command line argument to call the controller with.
+# c.MPIExecControllerLauncher.controller_args = \
+#     ['--log-to-file','--log-level', '40']
+
+
+# The mpiexec/mpirun command to use in started the controller.
+# c.MPIExecEngineSetLauncher.mpi_cmd = ['mpiexec']
+
+# Additional arguments to pass to the actual mpiexec command.
+# c.MPIExecEngineSetLauncher.mpi_args = []
+
+# Command line argument passed to the engines.
+# c.MPIExecEngineSetLauncher.engine_args = ['--log-to-file','--log-level', '40']
+
+# The default number of engines to start if not given elsewhere.
+# c.MPIExecEngineSetLauncher.n = 1
+
+#-----------------------------------------------------------------------------
+# SSH launchers
+#-----------------------------------------------------------------------------
+
+# Todo
+
+
+#-----------------------------------------------------------------------------
+# Unix batch (PBS) schedulers launchers
+#-----------------------------------------------------------------------------
+
+# The command line program to use to submit a PBS job.
+# c.PBSControllerLauncher.submit_command = 'qsub'
+
+# The command line program to use to delete a PBS job.
+# c.PBSControllerLauncher.delete_command = 'qdel'
+
+# A regular expression that takes the output of qsub and find the job id.
+# c.PBSControllerLauncher.job_id_regexp = r'\d+'
+
+# The batch submission script used to start the controller. This is where
+# environment variables would be setup, etc. This string is interpolated using
+# the Itpl module in IPython.external. Basically, you can use ${n} for the
+# number of engine and ${cluster_dir} for the cluster_dir.
+# c.PBSControllerLauncher.batch_template = """"""
+
+# The name of the instantiated batch script that will actually be used to
+# submit the job. This will be written to the cluster directory.
+# c.PBSControllerLauncher.batch_file_name = u'pbs_batch_script_controller'
+
+
+# The command line program to use to submit a PBS job.
+# c.PBSEngineSetLauncher.submit_command = 'qsub'
+
+# The command line program to use to delete a PBS job.
+# c.PBSEngineSetLauncher.delete_command = 'qdel'
+
+# A regular expression that takes the output of qsub and find the job id.
+# c.PBSEngineSetLauncher.job_id_regexp = r'\d+'
+
+# The batch submission script used to start the engines. This is where
+# environment variables would be setup, etc. This string is interpolated using
+# the Itpl module in IPython.external. Basically, you can use ${n} for the
+# number of engine and ${cluster_dir} for the cluster_dir.
+# c.PBSEngineSetLauncher.batch_template = """"""
+
+# The name of the instantiated batch script that will actually be used to
+# submit the job. This will be written to the cluster directory.
+# c.PBSEngineSetLauncher.batch_file_name = u'pbs_batch_script_engines'
+
+#-----------------------------------------------------------------------------
+# Windows HPC Server 2008 launcher configuration
+#-----------------------------------------------------------------------------
+
+# c.IPControllerJob.job_name = 'IPController'
+# c.IPControllerJob.is_exclusive = False
+# c.IPControllerJob.username = r'USERDOMAIN\USERNAME'
+# c.IPControllerJob.priority = 'Highest'
+# c.IPControllerJob.requested_nodes = ''
+# c.IPControllerJob.project = 'MyProject'
+
+# c.IPControllerTask.task_name = 'IPController'
+# c.IPControllerTask.controller_cmd = [u'ipcontroller.exe']
+# c.IPControllerTask.controller_args = ['--log-to-file', '--log-level', '40']
+# c.IPControllerTask.environment_variables = {}
+
+# c.WindowsHPCControllerLauncher.scheduler = 'HEADNODE'
+# c.WindowsHPCControllerLauncher.job_file_name = u'ipcontroller_job.xml'
+
+
+# c.IPEngineSetJob.job_name = 'IPEngineSet'
+# c.IPEngineSetJob.is_exclusive = False
+# c.IPEngineSetJob.username = r'USERDOMAIN\USERNAME'
+# c.IPEngineSetJob.priority = 'Highest'
+# c.IPEngineSetJob.requested_nodes = ''
+# c.IPEngineSetJob.project = 'MyProject'
+
+# c.IPEngineTask.task_name = 'IPEngine'
+# c.IPEngineTask.engine_cmd = [u'ipengine.exe']
+# c.IPEngineTask.engine_args = ['--log-to-file', '--log-level', '40']
+# c.IPEngineTask.environment_variables = {}
+
+# c.WindowsHPCEngineSetLauncher.scheduler = 'HEADNODE'
+# c.WindowsHPCEngineSetLauncher.job_file_name = u'ipengineset_job.xml'
+
+
+
+
+
+
+

IPython/config/default/ipcontroller_config.py

@@ -0,0 +1,136 b''
+from IPython.config.loader import Config
+
+c = get_config()
+
+#-----------------------------------------------------------------------------
+# Global configuration
+#-----------------------------------------------------------------------------
+
+# Basic Global config attributes
+
+# Start up messages are logged to stdout using the logging module.
+# These all happen before the twisted reactor is started and are
+# useful for debugging purposes. Can be (10=DEBUG,20=INFO,30=WARN,40=CRITICAL) 
+# and smaller is more verbose.
+# c.Global.log_level = 20
+
+# Log to a file in cluster_dir/log, otherwise just log to sys.stdout.
+# c.Global.log_to_file = False
+
+# Remove old logs from cluster_dir/log before starting.
+# c.Global.clean_logs = True
+
+# A list of Python statements that will be run before starting the 
+# controller. This is provided because occasionally certain things need to 
+# be imported in the controller for pickling to work.
+# c.Global.import_statements = ['import math']
+
+# Reuse the controller's FURL files. If False, FURL files are regenerated
+# each time the controller is run. If True, they will be reused, *but*, you
+# also must set the network ports by hand. If set, this will override the
+# values set for the client and engine connections below.
+# c.Global.reuse_furls = True
+
+# Enable SSL encryption on all connections to the controller. If set, this
+# will override the values set for the client and engine connections below.
+# c.Global.secure = True
+
+# The working directory for the process. The application will use os.chdir
+# to change to this directory before starting.
+# c.Global.work_dir = os.getcwd()
+
+#-----------------------------------------------------------------------------
+# Configure the client services
+#-----------------------------------------------------------------------------
+
+# Basic client service config attributes
+
+# The network interface the controller will listen on for client connections.
+# This should be an IP address or hostname of the controller's host. The empty
+# string means listen on all interfaces.
+# c.FCClientServiceFactory.ip = ''
+
+# The TCP/IP port the controller will listen on for client connections. If 0
+# a random port will be used. If the controller's host has a firewall running
+# it must allow incoming traffic on this port.
+# c.FCClientServiceFactory.port = 0
+
+# The client learns how to connect to the controller by looking at the
+# location field embedded in the FURL. If this field is empty, all network
+# interfaces that the controller is listening on will be listed. To have the
+# client connect on a particular interface, list it here.
+# c.FCClientServiceFactory.location = ''
+
+# Use SSL encryption for the client connection.
+# c.FCClientServiceFactory.secure =  True
+
+# Reuse the client FURL each time the controller is started. If set, you must
+# also pick a specific network port above (FCClientServiceFactory.port).
+# c.FCClientServiceFactory.reuse_furls = False
+
+#-----------------------------------------------------------------------------
+# Configure the engine services
+#-----------------------------------------------------------------------------
+
+# Basic config attributes for the engine services.
+
+# The network interface the controller will listen on for engine connections.
+# This should be an IP address or hostname of the controller's host. The empty
+# string means listen on all interfaces.
+# c.FCEngineServiceFactory.ip = ''
+
+# The TCP/IP port the controller will listen on for engine connections. If 0
+# a random port will be used. If the controller's host has a firewall running
+# it must allow incoming traffic on this port.
+# c.FCEngineServiceFactory.port = 0
+
+# The engine learns how to connect to the controller by looking at the
+# location field embedded in the FURL. If this field is empty, all network
+# interfaces that the controller is listening on will be listed. To have the
+# client connect on a particular interface, list it here.
+# c.FCEngineServiceFactory.location = ''
+
+# Use SSL encryption for the engine connection.
+# c.FCEngineServiceFactory.secure = True
+
+# Reuse the client FURL each time the controller is started. If set, you must
+# also pick a specific network port above (FCClientServiceFactory.port).
+# c.FCEngineServiceFactory.reuse_furls = False
+
+#-----------------------------------------------------------------------------
+# Developer level configuration attributes
+#-----------------------------------------------------------------------------
+
+# You shouldn't have to modify anything in this section. These attributes
+# are more for developers who want to change the behavior of the controller
+# at a fundamental level.
+
+# c.FCClientServiceFactory.cert_file = u'ipcontroller-client.pem'
+
+# default_client_interfaces = Config()
+# default_client_interfaces.Task.interface_chain = [
+#     'IPython.kernel.task.ITaskController',
+#     'IPython.kernel.taskfc.IFCTaskController'
+# ]
+# 
+# default_client_interfaces.Task.furl_file = u'ipcontroller-tc.furl'
+# 
+# default_client_interfaces.MultiEngine.interface_chain = [
+#     'IPython.kernel.multiengine.IMultiEngine',
+#     'IPython.kernel.multienginefc.IFCSynchronousMultiEngine'
+# ]
+# 
+# default_client_interfaces.MultiEngine.furl_file = u'ipcontroller-mec.furl'
+# 
+# c.FCEngineServiceFactory.interfaces = default_client_interfaces
+
+# c.FCEngineServiceFactory.cert_file = u'ipcontroller-engine.pem'
+
+# default_engine_interfaces = Config()
+# default_engine_interfaces.Default.interface_chain = [
+#     'IPython.kernel.enginefc.IFCControllerBase'
+# ]
+# 
+# default_engine_interfaces.Default.furl_file = u'ipcontroller-engine.furl'
+# 
+# c.FCEngineServiceFactory.interfaces = default_engine_interfaces

IPython/config/default/ipengine_config.py

@@ -0,0 +1,90 b''
+c = get_config()
+
+#-----------------------------------------------------------------------------
+# Global configuration
+#-----------------------------------------------------------------------------
+
+# Start up messages are logged to stdout using the logging module.
+# These all happen before the twisted reactor is started and are
+# useful for debugging purposes. Can be (10=DEBUG,20=INFO,30=WARN,40=CRITICAL) 
+# and smaller is more verbose.
+# c.Global.log_level = 20
+
+# Log to a file in cluster_dir/log, otherwise just log to sys.stdout.
+# c.Global.log_to_file = False
+
+# Remove old logs from cluster_dir/log before starting.
+# c.Global.clean_logs = True
+
+# A list of strings that will be executed in the users namespace on the engine
+# before it connects to the controller.
+# c.Global.exec_lines = ['import numpy']
+
+# The engine will try to connect to the controller multiple times, to allow
+# the controller time to startup and write its FURL file. These parameters 
+# control the number of retries (connect_max_tries) and the initial delay
+# (connect_delay) between attemps. The actual delay between attempts gets
+# longer each time by a factor of 1.5 (delay[i] = 1.5*delay[i-1])
+# those attemps.
+# c.Global.connect_delay = 0.1
+# c.Global.connect_max_tries = 15
+
+# By default, the engine will look for the controller's FURL file in its own
+# cluster directory. Sometimes, the FURL file will be elsewhere and this 
+# attribute can be set to the full path of the FURL file.
+# c.Global.furl_file = u''
+
+# The working directory for the process. The application will use os.chdir
+# to change to this directory before starting.
+# c.Global.work_dir = os.getcwd()
+
+#-----------------------------------------------------------------------------
+# MPI configuration
+#-----------------------------------------------------------------------------
+
+# Upon starting the engine can be configured to call MPI_Init. This section
+# configures that.
+
+# Select which MPI section to execute to setup MPI. The value of this 
+# attribute must match the name of another attribute in the MPI config 
+# section (mpi4py, pytrilinos, etc.). This can also be set by the --mpi
+# command line option.
+# c.MPI.use = ''
+
+# Initialize MPI using mpi4py. To use this, set c.MPI.use = 'mpi4py' to use
+# --mpi=mpi4py at the command line.
+# c.MPI.mpi4py = """from mpi4py import MPI as mpi
+# mpi.size = mpi.COMM_WORLD.Get_size()
+# mpi.rank = mpi.COMM_WORLD.Get_rank()
+# """
+
+# Initialize MPI using pytrilinos. To use this, set c.MPI.use = 'pytrilinos' 
+# to use --mpi=pytrilinos at the command line.
+# c.MPI.pytrilinos = """from PyTrilinos import Epetra
+# class SimpleStruct:
+# pass
+# mpi = SimpleStruct()
+# mpi.rank = 0
+# mpi.size = 0
+# """
+
+#-----------------------------------------------------------------------------
+# Developer level configuration attributes
+#-----------------------------------------------------------------------------
+
+# You shouldn't have to modify anything in this section. These attributes
+# are more for developers who want to change the behavior of the controller
+# at a fundamental level.
+
+# You should not have to change these attributes.
+
+# c.Global.shell_class = 'IPython.kernel.core.interpreter.Interpreter'
+
+# c.Global.furl_file_name = u'ipcontroller-engine.furl'
+
+
+
+
+
+
+

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 ipython_dir 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 = u'ipython_log.py'
+
+# c.InteractiveShell.logappend = u'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,336 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)
+            try:
+                sub_config = loader.load_config()
+            except IOError:
+                # Pass silently if the sub config is not there. This happens
+                # when a user us using a profile, but not the default config.
+                pass
+            else:
+                self.config._merge(sub_config)
+
+        # Again, this needs to be a closure and should be used in config
+        # files to get the config being loaded.
+        def get_config():
+            return self.config
+
+        namespace = dict(load_subconfig=load_subconfig, get_config=get_config)
+        execfile(self.full_filename, namespace)
+
+    def _convert_to_config(self):
+        if self.data is None:
+            ConfigLoaderError('self.data does not exist')
+
+
+class CommandLineConfigLoader(ConfigLoader):
+    """A config loader for command line arguments.
+
+    As we add more command line based loaders, the common logic should go
+    here.
+    """
+
+
+class NoConfigDefault(object): pass
+NoConfigDefault = NoConfigDefault()
+
+
+class ArgParseConfigLoader(CommandLineConfigLoader):
+    
+    # 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_cluster.py

@@ -0,0 +1,24 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 IPython.kernel.client 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]
+
+# Load the parallelmagic extension to enable %result, %px, %autopx magics.
+if hasattr(c.Global, 'extensions'):
+    c.Global.extensions.append('parallelmagic')
+else:
+    c.Global.extensions = ['parallelmagic']
+

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_imports.py

@@ -0,0 +1,5 b''
+#!/usr/bin/env python
+# encoding: utf-8
+
+
+

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,364 b''
+#!/usr/bin/env python
+# encoding: utf-8
+"""
+An application for IPython.
+
+All top-level applications should use the classes in this module for
+handling configuration and creating componenets.
+
+The job of an :class:`Application` is to create the master configuration 
+object and then create the components, passing the config to them.
+
+Authors:
+
+* Brian Granger
+* Fernando Perez
+
+Notes
+-----
+"""
+
+#-----------------------------------------------------------------------------
+#  Copyright (C) 2008-2009  The IPython Development Team
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
+import logging
+import os
+import sys
+
+from IPython.core import release
+from IPython.utils.genutils import get_ipython_dir
+from IPython.config.loader import (
+    PyFileConfigLoader,
+    ArgParseConfigLoader,
+    Config,
+    NoConfigDefault
+)
+
+#-----------------------------------------------------------------------------
+# Classes and functions
+#-----------------------------------------------------------------------------
+
+
+class BaseAppArgParseConfigLoader(ArgParseConfigLoader):
+    """Default command line options for IPython based applications."""
+
+    def _add_other_arguments(self):
+        self.parser.add_argument('--ipython-dir', 
+            dest='Global.ipython_dir',type=unicode,
+            help='Set to override default location of Global.ipython_dir.',
+            default=NoConfigDefault,
+            metavar='Global.ipython_dir')
+        self.parser.add_argument('-p', '--profile',
+            dest='Global.profile',type=unicode,
+            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,
+            metavar='Global.log_level')
+        self.parser.add_argument('--config-file',
+            dest='Global.config_file',type=unicode,
+            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 components and set them running."""
+
+    name = u'ipython'
+    description = 'IPython: an enhanced interactive Python shell.'
+    config_file_name = u'ipython_config.py'
+    default_log_level = logging.WARN
+
+    def __init__(self):
+        self._exiting = False
+        self.init_logger()
+        # Track the default and actual separately because some messages are
+        # only printed if we aren't using the default.
+        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(self.default_log_level)
+        self._log_handler = logging.StreamHandler()
+        self._log_formatter = logging.Formatter("[%(name)s] %(message)s")
+        self._log_handler.setFormatter(self._log_formatter)
+        self.log.addHandler(self._log_handler)
+
+    def _set_log_level(self, level):
+        self.log.setLevel(level)
+
+    def _get_log_level(self):
+        return self.log.level
+
+    log_level = property(_get_log_level, _set_log_level)
+
+    def start(self):
+        """Start the application."""
+        self.attempt(self.create_default_config)
+        self.log_default_config()
+        self.set_default_config_log_level()
+        self.attempt(self.pre_load_command_line_config)
+        self.attempt(self.load_command_line_config, action='abort')
+        self.set_command_line_config_log_level()
+        self.attempt(self.post_load_command_line_config)
+        self.log_command_line_config()
+        self.attempt(self.find_ipython_dir)
+        self.attempt(self.find_resources)
+        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.set_file_config_log_level()
+        self.attempt(self.post_load_file_config)
+        self.log_file_config()
+        self.attempt(self.merge_configs)
+        self.log_master_config()
+        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.ipython_dir = get_ipython_dir()
+        self.default_config.Global.log_level = self.log_level
+
+    def log_default_config(self):
+        self.log.debug('Default config loaded:')
+        self.log.debug(repr(self.default_config))
+
+    def set_default_config_log_level(self):
+        try:
+            self.log_level = self.default_config.Global.log_level
+        except AttributeError:
+            # Fallback to the default_log_level class attribute
+            pass
+
+    def create_command_line_config(self):
+        """Create and return a command line config loader."""
+        return BaseAppArgParseConfigLoader(
+            description=self.description, 
+            version=release.version
+        )
+
+    def pre_load_command_line_config(self):
+        """Do actions just before loading the command line config."""
+        pass
+
+    def load_command_line_config(self):
+        """Load the command line config."""
+        loader = self.create_command_line_config()
+        self.command_line_config = loader.load_config()
+        self.extra_args = loader.get_extra_args()
+
+    def set_command_line_config_log_level(self):
+        try:
+            self.log_level = self.command_line_config.Global.log_level
+        except AttributeError:
+            pass
+
+    def post_load_command_line_config(self):
+        """Do actions just after loading the command line config."""
+        pass
+
+    def log_command_line_config(self):
+        self.log.debug("Command line config loaded:")
+        self.log.debug(repr(self.command_line_config))
+
+    def find_ipython_dir(self):
+        """Set the IPython directory.
+
+        This sets ``self.ipython_dir``, but the actual value that is passed
+        to the application is kept in either ``self.default_config`` or
+        ``self.command_line_config``.  This also adds ``self.ipython_dir`` to
+        ``sys.path`` so config files there can be references by other config
+        files.
+        """
+
+        try:
+            self.ipython_dir = self.command_line_config.Global.ipython_dir
+        except AttributeError:
+            self.ipython_dir = self.default_config.Global.ipython_dir
+        sys.path.append(os.path.abspath(self.ipython_dir))
+        if not os.path.isdir(self.ipython_dir):
+            os.makedirs(self.ipython_dir, mode=0777)
+        self.log.debug("IPYTHON_DIR set to: %s" % self.ipython_dir)
+
+    def find_resources(self):
+        """Find other resources that need to be in place.
+
+        Things like cluster directories need to be in place to find the
+        config file.  These happen right after the IPython directory has
+        been set.
+        """
+        pass
+
+    def find_config_file_name(self):
+        """Find the config file name for this application.
+
+        This must set ``self.config_file_name`` to the filename of the
+        config file to use (just the filename). The search paths for the
+        config file are set in :meth:`find_config_file_paths` and then passed
+        to the config file loader where they are resolved to an absolute path.
+
+        If a profile has been set at the command line, this will resolve
+        it.
+        """
+
+        try:
+            self.config_file_name = self.command_line_config.Global.config_file
+        except AttributeError:
+            pass
+
+        try:
+            self.profile_name = self.command_line_config.Global.profile
+            name_parts = self.config_file_name.split('.')
+            name_parts.insert(1, u'_' + self.profile_name + u'.')
+            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.
+
+        This must set ``self.config_file_paths`` to a sequence of search
+        paths to pass to the config file loader.
+        """
+        self.config_file_paths = (os.getcwd(), self.ipython_dir)
+
+    def pre_load_file_config(self):
+        """Do actions before the config file is loaded."""
+        pass
+
+    def load_file_config(self):
+        """Load the config file.
+        
+        This tries to load the config file from disk.  If successful, the
+        ``CONFIG_FILE`` config variable is set to the resolved config file
+        location.  If not successful, an empty config is used.
+        """
+        self.log.debug("Attempting to load config file: %s" % self.config_file_name)
+        loader = PyFileConfigLoader(self.config_file_name,
+                                    path=self.config_file_paths)
+        try:
+            self.file_config = loader.load_config()
+            self.file_config.Global.config_file = loader.full_filename
+        except IOError:
+            # Only warn if the default config file was NOT being used.
+            if not self.config_file_name==self.default_config_file_name:
+                self.log.warn("Config file not found, skipping: %s" % \
+                               self.config_file_name, exc_info=True)
+            self.file_config = Config()
+        except:
+            self.log.warn("Error loading config file: %s" % \
+                          self.config_file_name, exc_info=True)
+            self.file_config = Config()
+
+    def set_file_config_log_level(self):
+        # We need to keeep self.log_level updated.  But we only use the value
+        # of the file_config if a value was not specified at the command
+        # line, because the command line overrides everything.
+        if not hasattr(self.command_line_config.Global, 'log_level'):
+            try:
+                self.log_level = self.file_config.Global.log_level
+            except AttributeError:
+                pass # Use existing value
+
+    def post_load_file_config(self):
+        """Do actions after the config file is loaded."""
+        pass
+
+    def log_file_config(self):
+        if hasattr(self.file_config.Global, 'config_file'):
+            self.log.debug("Config file loaded: %s" % self.file_config.Global.config_file)
+            self.log.debug(repr(self.file_config))
+
+    def merge_configs(self):
+        """Merge the default, command line and file config objects."""
+        config = Config()
+        config._merge(self.default_config)
+        config._merge(self.file_config)
+        config._merge(self.command_line_config)
+        self.master_config = config
+
+    def log_master_config(self):
+        self.log.debug("Master config created:")
+        self.log.debug(repr(self.master_config))
+
+    def pre_construct(self):
+        """Do actions after the config has been built, but before construct."""
+        pass
+
+    def construct(self):
+        """Construct the main components that make up this app."""
+        self.log.debug("Constructing components for application")
+
+    def post_construct(self):
+        """Do actions after construct, but before starting the app."""
+        pass
+
+    def start_app(self):
+        """Actually start the app."""
+        self.log.debug("Starting application")
+
+    #-------------------------------------------------------------------------
+    # Utility methods
+    #-------------------------------------------------------------------------
+
+    def abort(self):
+        """Abort the starting of the application."""
+        if self._exiting:
+            pass
+        else:
+            self.log.critical("Aborting application: %s" % self.name, exc_info=True)
+            self._exiting = True
+            sys.exit(1)
+
+    def exit(self, exit_status=0):
+        if self._exiting:
+            pass
+        else:
+            self.log.debug("Exiting application: %s" % self.name)
+            self._exiting = True
+            sys.exit(exit_status)
+
+    def attempt(self, func, action='abort'):
+        try:
+            func()
+        except SystemExit:
+            raise
+        except:
+            if action == 'abort':
+                self.abort()
+            elif action == 'exit':
+                self.exit(0)
+

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,118 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
+        # Returning False will cause exceptions to propagate
+        return False
+
+    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'))
+        self.add_builtin('get_ipython', self.shell.get_ipython)
+
+        # 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,346 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. In fact, I did find such a side effect in
+            # _config_changed below. If a config attribute value was a mutable type
+            # all instances of a component were getting the same copy, effectively
+            # making that a class attribute.
+            # 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. In fact, I did find such a side effect in
+                # _config_changed below. If a config attribute value was a mutable type
+                # all instances of a component were getting the same copy, effectively
+                # making that a class attribute.
+                # 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():
+                    # Don't allow traitlets with config=True to start with
+                    # uppercase.  Otherwise, they are confused with Config
+                    # subsections.  But, developers shouldn't have uppercase
+                    # attributes anyways! (PEP 6)
+                    if k[0].upper()==k[0] and not k.startswith('_'):
+                        raise ComponentError('Component traitlets with '
+                        'config=True must start with a lowercase so they are '
+                        'not confused with Config subsections: %s.%s' % \
+                        (self.__class__.__name__, k))
+                    try:
+                        # Here we grab the value from the config
+                        # If k has the naming convention of a config
+                        # section, it will be auto created.
+                        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)
+                        # We have to do a deepcopy here if we don't deepcopy the entire
+                        # config object. If we don't, a mutable config_value will be
+                        # shared by all instances, effectively making it a class attribute.
+                        setattr(self, k, deepcopy(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,77 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
+        # Returning False will cause exceptions to propagate
+        return False
+
+    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,272 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, ipython_dir=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, ipython_dir=ipython_dir, 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)
+
+
+_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/ipapi.py

@@ -0,0 +1,38 b''
+#!/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.
+"""
+
+#-----------------------------------------------------------------------------
+#  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 IPython.core.error import TryNext, UsageError, IPythonCoreError
+
+#-----------------------------------------------------------------------------
+# Classes and functions
+#-----------------------------------------------------------------------------
+
+
+def get():
+    """Get the most recently created InteractiveShell instance."""
+    from IPython.core.iplib import InteractiveShell
+    insts = InteractiveShell.get_instances()
+    if len(insts)==0:
+        return None
+    most_recent = insts[0]
+    for inst in insts[1:]:
+        if inst.created > most_recent.created:
+            most_recent = inst
+    return most_recent

IPython/core/ipapp.py

@@ -0,0 +1,544 b''
+#!/usr/bin/env python
+# encoding: utf-8
+"""
+The :class:`~IPython.core.application.Application` object for the command
+line :command:`ipython` program.
+
+Authors:
+
+* Brian Granger
+* Fernando Perez
+
+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, BaseAppArgParseConfigLoader
+from IPython.core import release
+from IPython.core.iplib import InteractiveShell
+from IPython.config.loader import (
+    NoConfigDefault, 
+    Config,
+    PyFileConfigLoader
+)
+
+from IPython.lib import inputhook
+
+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.')
+    ),
+    (('--no-autoindent',), dict(
+        action='store_false', dest='InteractiveShell.autoindent', default=NoConfigDefault,
+        help='Turn off autoindenting.')
+    ),
+    (('--automagic',), dict(
+        action='store_true', dest='InteractiveShell.automagic', default=NoConfigDefault,
+        help='Turn on the auto calling of magic commands.')
+    ),
+    (('--no-automagic',), dict(
+        action='store_false', dest='InteractiveShell.automagic', default=NoConfigDefault,
+        help='Turn off the auto calling of magic commands.')
+    ),
+    (('--autoedit-syntax',), dict(
+        action='store_true', dest='InteractiveShell.autoedit_syntax', default=NoConfigDefault,
+        help='Turn on auto editing of files with syntax errors.')
+    ),
+    (('--no-autoedit-syntax',), dict(
+        action='store_false', dest='InteractiveShell.autoedit_syntax', default=NoConfigDefault,
+        help='Turn off auto editing of files with syntax errors.')
+    ),
+    (('--banner',), dict(
+        action='store_true', dest='Global.display_banner', default=NoConfigDefault,
+        help='Display a banner upon starting IPython.')
+    ),
+    (('--no-banner',), dict(
+        action='store_false', dest='Global.display_banner', default=NoConfigDefault,
+        help="Don't display a banner upon starting IPython.")
+    ),
+    (('--cache-size',), dict(
+        type=int, dest='InteractiveShell.cache_size', default=NoConfigDefault,
+        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.")
+    ),
+    (('--no-color-info',), dict(
+        action='store_false', dest='InteractiveShell.color_info', default=NoConfigDefault,
+        help="Disable using colors for info related things.")
+    ),
+    (('--confirm-exit',), dict(
+        action='store_true', dest='InteractiveShell.confirm_exit', default=NoConfigDefault,
+        help="Prompt the user when existing.")
+    ),
+    (('--no-confirm-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.")
+    ),
+    (('--no-deep-reload',), dict(
+        action='store_false', dest='InteractiveShell.deep_reload', default=NoConfigDefault,
+        help="Disable deep (recursive) reloading by default.")
+    ),
+    (('--editor',), dict(
+        type=str, dest='InteractiveShell.editor', default=NoConfigDefault,
+        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=unicode, dest='InteractiveShell.logfile', default=NoConfigDefault,
+        help="Start logging to logfile.",
+        metavar='InteractiveShell.logfile')
+    ),
+    (('--log-append','-la'), dict(
+        type=unicode, dest='InteractiveShell.logappend', default=NoConfigDefault,
+        help="Start logging to the give file in append mode.",
+        metavar='InteractiveShell.logfile')
+    ),
+    (('--pdb',), dict(
+        action='store_true', dest='InteractiveShell.pdb', default=NoConfigDefault,
+        help="Enable auto calling the pdb debugger after every exception.")
+    ),
+    (('--no-pdb',), dict(
+        action='store_false', dest='InteractiveShell.pdb', default=NoConfigDefault,
+        help="Disable auto calling the pdb debugger after every exception.")
+    ),
+    (('--pprint',), dict(
+        action='store_true', dest='InteractiveShell.pprint', default=NoConfigDefault,
+        help="Enable auto pretty printing of results.")
+    ),
+    (('--no-pprint',), dict(
+        action='store_false', dest='InteractiveShell.pprint', default=NoConfigDefault,
+        help="Disable auto auto pretty printing of results.")
+    ),
+    (('--prompt-in1','-pi1'), dict(
+        type=str, dest='InteractiveShell.prompt_in1', default=NoConfigDefault,
+        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.")
+    ),
+    (('--no-readline',), dict(
+        action='store_false', dest='InteractiveShell.readline_use', default=NoConfigDefault,
+        help="Disable readline for command line usage.")
+    ),
+    (('--screen-length','-sl'), dict(
+        type=int, dest='InteractiveShell.screen_length', default=NoConfigDefault,
+        help='Number of lines 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')
+    ),
+    (('-no-sep',), 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.")
+    ),
+    (('--no-term-title',), dict(
+        action='store_false', dest='InteractiveShell.term_title', default=NoConfigDefault,
+        help="Disable auto setting the terminal title.")
+    ),
+    (('--xmode',), dict(
+        type=str, dest='InteractiveShell.xmode', default=NoConfigDefault,
+        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(BaseAppArgParseConfigLoader):
+
+    arguments = cl_args
+
+
+default_config_file_name = u'ipython_config.py'
+
+
+class IPythonApp(Application):
+    name = u'ipython'
+    description = 'IPython: an enhanced interactive Python shell.'
+    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
+
+        # 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=self.description, 
+            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, [u'.', self.ipython_dir])
+        if os.path.isfile(full_filename):
+            if full_filename.endswith(u'.py'):
+                self.log.info("Running file in user namespace: %s" % full_filename)
+                self.shell.safe_execfile(full_filename, self.shell.user_ns)
+            elif full_filename.endswith('.ipy'):
+                self.log.info("Running file in user namespace: %s" % full_filename)
+                self.shell.safe_execfile_ipy(full_filename)
+            else:
+                self.log.warn("File does not have a .py or .ipy extension: <%s>" % full_filename)
+
+    def _run_exec_files(self):
+        try:
+            if hasattr(self.master_config.Global, 'exec_files'):
+                self.log.debug("Running files in Global.exec_files...")
+                exec_files = self.master_config.Global.exec_files
+                for fname in exec_files:
+                    self._exec_file(fname)
+        except:
+            self.log.warn("Unknown error in handling Global.exec_files:")
+            self.shell.showtraceback()
+
+    def _run_cmd_line_code(self):
+        if hasattr(self.master_config.Global, 'code_to_run'):
+            line = self.master_config.Global.code_to_run
+            try:
+                self.log.info("Running code given at command line (-c): %s" % line)
+                self.shell.runlines(line)
+            except:
+                self.log.warn("Error in executing line in user namespace: %s" % line)
+                self.shell.showtraceback()
+            return
+        # Like Python itself, ignore the second if the first of these is present
+        try:
+            fname = self.extra_args[0]
+        except:
+            pass
+        else:
+            try:
+                self._exec_file(fname)
+            except:
+                self.log.warn("Error in executing file in user namespace: %s" % fname)
+                self.shell.showtraceback()
+
+    def start_app(self):
+        if self.master_config.Global.interact:
+            self.log.debug("Starting IPython's mainloop...")
+            self.shell.mainloop()
+
+
+def load_default_config(ipython_dir=None):
+    """Load the default config file from the default ipython_dir.
+
+    This is useful for embedded shells.
+    """
+    if ipython_dir is None:
+        ipython_dir = get_ipython_dir()
+    cl = PyFileConfigLoader(default_config_file_name, ipython_dir)
+    config = cl.load_config()
+    return config
+
+
+def launch_new_instance():
+    """Create and run a full blown IPython instance"""
+    app = IPythonApp()
+    app.start()
+

IPython/core/iplib.py

@@ -0,0 +1,2488 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
+#-----------------------------------------------------------------------------
+
+from __future__ import with_statement
+
+import __builtin__
+import StringIO
+import bdb
+import codeop
+import exceptions
+import new
+import os
+import re
+import string
+import sys
+import tempfile
+from contextlib import nested
+
+from IPython.core import ultratb
+from IPython.core import debugger, oinspect
+from IPython.core import shadowns
+from IPython.core import history as ipcorehist
+from IPython.core import prefilter
+from IPython.core.alias import AliasManager
+from IPython.core.builtin_trap import BuiltinTrap
+from IPython.core.display_trap import DisplayTrap
+from IPython.core.fakemodule import FakeModule, init_fakemod_dict
+from IPython.core.logger import Logger
+from IPython.core.magic import Magic
+from IPython.core.prompts import CachedOutput
+from IPython.core.prefilter import PrefilterManager
+from IPython.core.component import Component
+from IPython.core.usage import interactive_usage, default_banner
+from IPython.core.error import TryNext, UsageError
+
+from IPython.utils import pickleshare
+from IPython.external.Itpl import ItplNS
+from IPython.lib.backgroundjobs import BackgroundJobManager
+from IPython.utils.ipstruct import Struct
+from IPython.utils import PyColorize
+from IPython.utils.genutils import *
+from IPython.utils.genutils import get_ipython_dir
+from IPython.utils.platutils import toggle_set_term_title, set_term_title
+from IPython.utils.strdispatch import StrDispatch
+from IPython.utils.syspathcontext import prepended_to_syspath
+
+# from IPython.utils import growl
+# growl.start("IPython")
+
+from IPython.utils.traitlets import (
+    Int, Str, CBool, CaselessStrEnum, Enum, List, Unicode
+)
+
+#-----------------------------------------------------------------------------
+# Globals
+#-----------------------------------------------------------------------------
+
+
+# store the builtin raw_input globally, and use this always, in case user code
+# overwrites it (like wx.py.PyShell does)
+raw_input_original = raw_input
+
+# compiled regexps for autoindent management
+dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')
+
+
+#-----------------------------------------------------------------------------
+# Utilities
+#-----------------------------------------------------------------------------
+
+
+ini_spaces_re = re.compile(r'^(\s+)')
+
+
+def num_ini_spaces(strng):
+    """Return the number of initial spaces in a string"""
+
+    ini_spaces = ini_spaces_re.match(strng)
+    if ini_spaces:
+        return ini_spaces.end()
+    else:
+        return 0
+
+
+def softspace(file, newvalue):
+    """Copied from code.py, to remove the dependency"""
+
+    oldvalue = 0
+    try:
+        oldvalue = file.softspace
+    except AttributeError:
+        pass
+    try:
+        file.softspace = newvalue
+    except (AttributeError, TypeError):
+        # "attribute-less object" or "read-only attributes"
+        pass
+    return oldvalue
+
+
+class SpaceInInput(exceptions.Exception): pass
+
+class Bunch: pass
+
+class InputList(list):
+    """Class to store user input.
+
+    It's basically a list, but slices return a string instead of a list, thus
+    allowing things like (assuming 'In' is an instance):
+
+    exec In[4:7]
+
+    or
+
+    exec In[5:9] + In[14] + In[21:25]"""
+
+    def __getslice__(self,i,j):
+        return ''.join(list.__getslice__(self,i,j))
+
+
+class SyntaxTB(ultratb.ListTB):
+    """Extension which holds some state: the last exception value"""
+
+    def __init__(self,color_scheme = 'NoColor'):
+        ultratb.ListTB.__init__(self,color_scheme)
+        self.last_syntax_error = None
+
+    def __call__(self, etype, value, elist):
+        self.last_syntax_error = value
+        ultratb.ListTB.__call__(self,etype,value,elist)
+
+    def clear_err_state(self):
+        """Return the current error state and clear it"""
+        e = self.last_syntax_error
+        self.last_syntax_error = None
+        return e
+
+
+def get_default_editor():
+    try:
+        ed = os.environ['EDITOR']
+    except KeyError:
+        if os.name == 'posix':
+            ed = 'vi'  # the only one guaranteed to be there!
+        else:
+            ed = 'notepad' # same in Windows!
+    return ed
+
+
+def get_default_colors():
+    if sys.platform=='darwin':
+        return "LightBG"
+    elif os.name=='nt':
+        return 'Linux'
+    else:
+        return 'Linux'
+
+
+class SeparateStr(Str):
+    """A Str subclass to validate separate_in, separate_out, etc.
+
+    This is a Str based traitlet that converts '0'->'' and '\\n'->'\n'.
+    """
+
+    def validate(self, obj, value):
+        if value == '0': value = ''
+        value = value.replace('\\n','\n')
+        return super(SeparateStr, self).validate(obj, value)
+
+
+#-----------------------------------------------------------------------------
+# Main IPython class
+#-----------------------------------------------------------------------------
+
+
+class InteractiveShell(Component, Magic):
+    """An enhanced, interactive shell for Python."""
+
+    autocall = Enum((0,1,2), default_value=1, config=True)
+    autoedit_syntax = CBool(False, config=True)
+    autoindent = CBool(True, config=True)
+    automagic = CBool(True, config=True)
+    banner = Str('')
+    banner1 = Str(default_banner, config=True)
+    banner2 = Str('', config=True)
+    cache_size = Int(1000, config=True)
+    color_info = CBool(True, config=True)
+    colors = CaselessStrEnum(('NoColor','LightBG','Linux'), 
+                             default_value=get_default_colors(), config=True)
+    confirm_exit = CBool(True, config=True)
+    debug = CBool(False, config=True)
+    deep_reload = CBool(False, config=True)
+    # This display_banner only controls whether or not self.show_banner()
+    # is called when mainloop/interact are called.  The default is False
+    # because for the terminal based application, the banner behavior
+    # is controlled by Global.display_banner, which IPythonApp looks at
+    # to determine if *it* should call show_banner() by hand or not.
+    display_banner = CBool(False) # This isn't configurable!
+    embedded = CBool(False)
+    embedded_active = CBool(False)
+    editor = Str(get_default_editor(), config=True)
+    filename = Str("<ipython console>")
+    ipython_dir= Unicode('', config=True) # Set to get_ipython_dir() in __init__
+    logstart = CBool(False, config=True)
+    logfile = Str('', config=True)
+    logappend = Str('', config=True)
+    object_info_string_level = Enum((0,1,2), default_value=0,
+                                    config=True)
+    pager = Str('less', config=True)
+    pdb = CBool(False, config=True)
+    pprint = CBool(True, config=True)
+    profile = Str('', config=True)
+    prompt_in1 = Str('In [\\#]: ', config=True)
+    prompt_in2 = Str('   .\\D.: ', config=True)
+    prompt_out = Str('Out[\\#]: ', config=True)
+    prompts_pad_left = CBool(True, config=True)
+    quiet = CBool(False, config=True)
+
+    readline_use = CBool(True, config=True)
+    readline_merge_completions = CBool(True, config=True)
+    readline_omit__names = Enum((0,1,2), default_value=0, config=True)
+    readline_remove_delims = Str('-/~', config=True)
+    readline_parse_and_bind = List([
+            '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',
+        ], allow_none=False, config=True)
+
+    screen_length = Int(0, config=True)
+    
+    # Use custom TraitletTypes that convert '0'->'' and '\\n'->'\n'
+    separate_in = SeparateStr('\n', config=True)
+    separate_out = SeparateStr('', config=True)
+    separate_out2 = SeparateStr('', config=True)
+
+    system_header = Str('IPython system call: ', config=True)
+    system_verbose = CBool(False, config=True)
+    term_title = CBool(False, config=True)
+    wildcards_case_sensitive = CBool(True, config=True)
+    xmode = CaselessStrEnum(('Context','Plain', 'Verbose'), 
+                            default_value='Context', config=True)
+
+    autoexec = List(allow_none=False)
+
+    # class attribute to indicate whether the class supports threads or not.
+    # Subclasses with thread support should override this as needed.
+    isthreaded = False
+
+    def __init__(self, parent=None, config=None, ipython_dir=None, usage=None,
+                 user_ns=None, user_global_ns=None,
+                 banner1=None, banner2=None, display_banner=None,
+                 custom_exceptions=((),None)):
+
+        # This is where traitlets with a config_key argument are updated
+        # from the values on config.
+        super(InteractiveShell, self).__init__(parent, config=config)
+
+        # These are relatively independent and stateless
+        self.init_ipython_dir(ipython_dir)
+        self.init_instance_attrs()
+        self.init_term_title()
+        self.init_usage(usage)
+        self.init_banner(banner1, banner2, display_banner)
+
+        # Create namespaces (user_ns, user_global_ns, etc.)
+        self.init_create_namespaces(user_ns, user_global_ns)
+        # This has to be done after init_create_namespaces because it uses
+        # something in self.user_ns, but before init_sys_modules, which
+        # is the first thing to modify sys.
+        self.save_sys_module_state()
+        self.init_sys_modules()
+
+        self.init_history()
+        self.init_encoding()
+        self.init_prefilter()
+
+        Magic.__init__(self, self)
+
+        self.init_syntax_highlighting()
+        self.init_hooks()
+        self.init_pushd_popd_magic()
+        self.init_traceback_handlers(custom_exceptions)
+        self.init_user_ns()
+        self.init_logger()
+        self.init_alias()
+        self.init_builtins()
+        
+        # pre_config_initialization
+        self.init_shadow_hist()
+
+        # The next section should contain averything that was in ipmaker.
+        self.init_logstart()
+
+        # The following was in post_config_initialization
+        self.init_inspector()
+        self.init_readline()
+        self.init_prompts()
+        self.init_displayhook()
+        self.init_reload_doctest()
+        self.init_magics()
+        self.init_pdb()
+        self.hooks.late_startup_hook()
+
+    def get_ipython(self):
+        return self
+
+    #-------------------------------------------------------------------------
+    # Traitlet changed handlers
+    #-------------------------------------------------------------------------
+
+    def _banner1_changed(self):
+        self.compute_banner()
+
+    def _banner2_changed(self):
+        self.compute_banner()
+
+    def _ipython_dir_changed(self, name, new):
+        if not os.path.isdir(new):
+            os.makedirs(new, mode = 0777)
+        if not os.path.isdir(self.ipython_extension_dir):
+            os.makedirs(self.ipython_extension_dir, mode = 0777)
+
+    @property
+    def ipython_extension_dir(self):
+        return os.path.join(self.ipython_dir, 'extensions')
+
+    @property
+    def usable_screen_length(self):
+        if self.screen_length == 0:
+            return 0
+        else:
+            num_lines_bot = self.separate_in.count('\n')+1
+            return self.screen_length - num_lines_bot
+
+    def _term_title_changed(self, name, new_value):
+        self.init_term_title()
+
+    def set_autoindent(self,value=None):
+        """Set the autoindent flag, checking for readline support.
+
+        If called with no arguments, it acts as a toggle."""
+
+        if not self.has_readline:
+            if os.name == 'posix':
+                warn("The auto-indent feature requires the readline library")
+            self.autoindent = 0
+            return
+        if value is None:
+            self.autoindent = not self.autoindent
+        else:
+            self.autoindent = value
+
+    #-------------------------------------------------------------------------
+    # init_* methods called by __init__
+    #-------------------------------------------------------------------------
+
+    def init_ipython_dir(self, ipython_dir):
+        if ipython_dir is not None:
+            self.ipython_dir = ipython_dir
+            self.config.Global.ipython_dir = self.ipython_dir
+            return
+
+        if hasattr(self.config.Global, 'ipython_dir'):
+            self.ipython_dir = self.config.Global.ipython_dir
+        else:
+            self.ipython_dir = get_ipython_dir()
+
+        # All children can just read this
+        self.config.Global.ipython_dir = self.ipython_dir
+
+    def init_instance_attrs(self):
+        self.jobs = BackgroundJobManager()
+        self.more = False
+
+        # command compiler
+        self.compile = codeop.CommandCompiler()
+
+        # User input buffer
+        self.buffer = []
+
+        # Make an empty namespace, which extension writers can rely on both
+        # existing and NEVER being used by ipython itself.  This gives them a
+        # convenient location for storing additional information and state
+        # their extensions may require, without fear of collisions with other
+        # ipython names that may develop later.
+        self.meta = Struct()
+
+        # Object variable to store code object waiting execution.  This is
+        # used mainly by the multithreaded shells, but it can come in handy in
+        # other situations.  No need to use a Queue here, since it's a single
+        # item which gets cleared once run.
+        self.code_to_run = None
+
+        # Flag to mark unconditional exit
+        self.exit_now = False
+
+        # Temporary files used for various purposes.  Deleted at exit.
+        self.tempfiles = []
+
+        # Keep track of readline usage (later set by init_readline)
+        self.has_readline = False
+
+        # keep track of where we started running (mainly for crash post-mortem)
+        # This is not being used anywhere currently.
+        self.starting_dir = os.getcwd()
+
+        # Indentation management
+        self.indent_current_nsp = 0
+
+    def init_term_title(self):
+        # Enable or disable the terminal title.
+        if self.term_title:
+            toggle_set_term_title(True)
+            set_term_title('IPython: ' + abbrev_cwd())
+        else:
+            toggle_set_term_title(False)
+
+    def init_usage(self, usage=None):
+        if usage is None:
+            self.usage = interactive_usage
+        else:
+            self.usage = usage
+
+    def init_encoding(self):
+        # Get system encoding at startup time.  Certain terminals (like Emacs
+        # under Win32 have it set to None, and we need to have a known valid
+        # encoding to use in the raw_input() method
+        try:
+            self.stdin_encoding = sys.stdin.encoding or 'ascii'
+        except AttributeError:
+            self.stdin_encoding = 'ascii'
+
+    def init_syntax_highlighting(self):
+        # Python source parser/formatter for syntax highlighting
+        pyformat = PyColorize.Parser().format
+        self.pycolorize = lambda src: pyformat(src,'str',self.colors)
+
+    def init_pushd_popd_magic(self):
+        # for pushd/popd management
+        try:
+            self.home_dir = get_home_dir()
+        except HomeDirError, msg:
+            fatal(msg)
+
+        self.dir_stack = []
+
+    def init_logger(self):
+        self.logger = Logger(self, logfname='ipython_log.py', logmode='rotate')
+        # local shortcut, this is used a LOT
+        self.log = self.logger.log
+
+    def init_logstart(self):
+        if self.logappend:
+            self.magic_logstart(self.logappend + ' append')
+        elif self.logfile:
+            self.magic_logstart(self.logfile)
+        elif self.logstart:
+            self.magic_logstart()
+
+    def init_builtins(self):
+        self.builtin_trap = BuiltinTrap(self)
+
+    def init_inspector(self):
+        # Object inspector
+        self.inspector = oinspect.Inspector(oinspect.InspectColors,
+                                            PyColorize.ANSICodeColors,
+                                            'NoColor',
+                                            self.object_info_string_level)
+
+    def init_prompts(self):
+        # Initialize cache, set in/out prompts and printing system
+        self.outputcache = CachedOutput(self,
+                                        self.cache_size,
+                                        self.pprint,
+                                        input_sep = self.separate_in,
+                                        output_sep = self.separate_out,
+                                        output_sep2 = self.separate_out2,
+                                        ps1 = self.prompt_in1,
+                                        ps2 = self.prompt_in2,
+                                        ps_out = self.prompt_out,
+                                        pad_left = self.prompts_pad_left)
+
+        # user may have over-ridden the default print hook:
+        try:
+            self.outputcache.__class__.display = self.hooks.display
+        except AttributeError:
+            pass
+
+    def init_displayhook(self):
+        self.display_trap = DisplayTrap(self, self.outputcache)
+
+    def init_reload_doctest(self):
+        # Do a proper resetting of doctest, including the necessary displayhook
+        # monkeypatching
+        try:
+            doctest_reload()
+        except ImportError:
+            warn("doctest module does not exist.")
+
+    #-------------------------------------------------------------------------
+    # Things related to the banner
+    #-------------------------------------------------------------------------
+
+    def init_banner(self, banner1, banner2, display_banner):
+        if banner1 is not None:
+            self.banner1 = banner1
+        if banner2 is not None:
+            self.banner2 = banner2
+        if display_banner is not None:
+            self.display_banner = display_banner
+        self.compute_banner()
+
+    def show_banner(self, banner=None):
+        if banner is None:
+            banner = self.banner
+        self.write(banner)
+
+    def compute_banner(self):
+        self.banner = self.banner1 + '\n'
+        if self.profile:
+            self.banner += '\nIPython profile: %s\n' % self.profile
+        if self.banner2:
+            self.banner += '\n' + self.banner2 + '\n'
+
+    #-------------------------------------------------------------------------
+    # Things related to injections into the sys module
+    #-------------------------------------------------------------------------
+
+    def save_sys_module_state(self):
+        """Save the state of hooks in the sys module.
+
+        This has to be called after self.user_ns is created.
+        """
+        self._orig_sys_module_state = {}
+        self._orig_sys_module_state['stdin'] = sys.stdin
+        self._orig_sys_module_state['stdout'] = sys.stdout
+        self._orig_sys_module_state['stderr'] = sys.stderr
+        self._orig_sys_module_state['excepthook'] = sys.excepthook
+        try:
+            self._orig_sys_modules_main_name = self.user_ns['__name__']
+        except KeyError:
+            pass
+
+    def restore_sys_module_state(self):
+        """Restore the state of the sys module."""
+        try:
+            for k, v in self._orig_sys_module_state.items():
+                setattr(sys, k, v)
+        except AttributeError:
+            pass
+        try:
+            delattr(sys, 'ipcompleter')
+        except AttributeError:
+            pass
+        # Reset what what done in self.init_sys_modules
+        try:
+            sys.modules[self.user_ns['__name__']] = self._orig_sys_modules_main_name
+        except (AttributeError, KeyError):
+            pass
+
+    #-------------------------------------------------------------------------
+    # Things related to hooks
+    #-------------------------------------------------------------------------
+
+    def init_hooks(self):
+        # hooks holds pointers used for user-side customizations
+        self.hooks = Struct()
+
+        self.strdispatchers = {}
+
+        # Set all default hooks, defined in the IPython.hooks module.
+        import IPython.core.hooks
+        hooks = IPython.core.hooks
+        for hook_name in hooks.__all__:
+            # default hooks have priority 100, i.e. low; user hooks should have
+            # 0-100 priority
+            self.set_hook(hook_name,getattr(hooks,hook_name), 100)
+
+    def set_hook(self,name,hook, priority = 50, str_key = None, re_key = None):
+        """set_hook(name,hook) -> sets an internal IPython hook.
+
+        IPython exposes some of its internal API as user-modifiable hooks.  By
+        adding your function to one of these hooks, you can modify IPython's 
+        behavior to call at runtime your own routines."""
+
+        # At some point in the future, this should validate the hook before it
+        # accepts it.  Probably at least check that the hook takes the number
+        # of args it's supposed to.
+        
+        f = new.instancemethod(hook,self,self.__class__)
+
+        # check if the hook is for strdispatcher first
+        if str_key is not None:
+            sdp = self.strdispatchers.get(name, StrDispatch())
+            sdp.add_s(str_key, f, priority )
+            self.strdispatchers[name] = sdp
+            return
+        if re_key is not None:
+            sdp = self.strdispatchers.get(name, StrDispatch())
+            sdp.add_re(re.compile(re_key), f, priority )
+            self.strdispatchers[name] = sdp
+            return
+            
+        dp = getattr(self.hooks, name, None)
+        if name not in IPython.core.hooks.__all__:
+            print "Warning! Hook '%s' is not one of %s" % (name, IPython.core.hooks.__all__ )
+        if not dp:
+            dp = IPython.core.hooks.CommandChainDispatcher()
+        
+        try:
+            dp.add(f,priority)
+        except AttributeError:
+            # it was not commandchain, plain old func - replace
+            dp = f
+
+        setattr(self.hooks,name, dp)
+
+    #-------------------------------------------------------------------------
+    # Things related to the "main" module
+    #-------------------------------------------------------------------------
+
+    def new_main_mod(self,ns=None):
+        """Return a new 'main' module object for user code execution.
+        """
+        main_mod = self._user_main_module
+        init_fakemod_dict(main_mod,ns)
+        return main_mod
+
+    def cache_main_mod(self,ns,fname):
+        """Cache a main module's namespace.
+
+        When scripts are executed via %run, we must keep a reference to the
+        namespace of their __main__ module (a FakeModule instance) around so
+        that Python doesn't clear it, rendering objects defined therein
+        useless.
+
+        This method keeps said reference in a private dict, keyed by the
+        absolute path of the module object (which corresponds to the script
+        path).  This way, for multiple executions of the same script we only
+        keep one copy of the namespace (the last one), thus preventing memory
+        leaks from old references while allowing the objects from the last
+        execution to be accessible.
+
+        Note: we can not allow the actual FakeModule instances to be deleted,
+        because of how Python tears down modules (it hard-sets all their
+        references to None without regard for reference counts).  This method
+        must therefore make a *copy* of the given namespace, to allow the
+        original module's __dict__ to be cleared and reused.
+
+        
+        Parameters
+        ----------
+          ns : a namespace (a dict, typically)
+
+          fname : str
+            Filename associated with the namespace.
+
+        Examples
+        --------
+
+        In [10]: import IPython
+
+        In [11]: _ip.cache_main_mod(IPython.__dict__,IPython.__file__)
+
+        In [12]: IPython.__file__ in _ip._main_ns_cache
+        Out[12]: True
+        """
+        self._main_ns_cache[os.path.abspath(fname)] = ns.copy()
+
+    def clear_main_mod_cache(self):
+        """Clear the cache of main modules.
+
+        Mainly for use by utilities like %reset.
+
+        Examples
+        --------
+
+        In [15]: import IPython
+
+        In [16]: _ip.cache_main_mod(IPython.__dict__,IPython.__file__)
+
+        In [17]: len(_ip._main_ns_cache) > 0
+        Out[17]: True
+
+        In [18]: _ip.clear_main_mod_cache()
+
+        In [19]: len(_ip._main_ns_cache) == 0
+        Out[19]: True
+        """
+        self._main_ns_cache.clear()
+
+    #-------------------------------------------------------------------------
+    # Things related to debugging
+    #-------------------------------------------------------------------------
+
+    def init_pdb(self):
+        # Set calling of pdb on exceptions
+        # self.call_pdb is a property
+        self.call_pdb = self.pdb
+
+    def _get_call_pdb(self):
+        return self._call_pdb
+
+    def _set_call_pdb(self,val):
+
+        if val not in (0,1,False,True):
+            raise ValueError,'new call_pdb value must be boolean'
+
+        # store value in instance
+        self._call_pdb = val
+
+        # notify the actual exception handlers
+        self.InteractiveTB.call_pdb = val
+        if self.isthreaded:
+            try:
+                self.sys_excepthook.call_pdb = val
+            except:
+                warn('Failed to activate pdb for threaded exception handler')
+
+    call_pdb = property(_get_call_pdb,_set_call_pdb,None,
+                        'Control auto-activation of pdb at exceptions')
+
+    def debugger(self,force=False):
+        """Call the pydb/pdb debugger.
+
+        Keywords:
+
+          - force(False): by default, this routine checks the instance call_pdb
+          flag and does not actually invoke the debugger if the flag is false.
+          The 'force' option forces the debugger to activate even if the flag
+          is false.
+        """
+
+        if not (force or self.call_pdb):
+            return
+
+        if not hasattr(sys,'last_traceback'):
+            error('No traceback has been produced, nothing to debug.')
+            return
+
+        # use pydb if available
+        if debugger.has_pydb:
+            from pydb import pm
+        else:
+            # fallback to our internal debugger
+            pm = lambda : self.InteractiveTB.debugger(force=True)
+        self.history_saving_wrapper(pm)()
+
+    #-------------------------------------------------------------------------
+    # Things related to IPython's various namespaces
+    #-------------------------------------------------------------------------
+
+    def init_create_namespaces(self, user_ns=None, user_global_ns=None):
+        # Create the namespace where the user will operate.  user_ns is
+        # normally the only one used, and it is passed to the exec calls as
+        # the locals argument.  But we do carry a user_global_ns namespace
+        # given as the exec 'globals' argument,  This is useful in embedding
+        # situations where the ipython shell opens in a context where the
+        # distinction between locals and globals is meaningful.  For
+        # non-embedded contexts, it is just the same object as the user_ns dict.
+
+        # FIXME. For some strange reason, __builtins__ is showing up at user
+        # level as a dict instead of a module. This is a manual fix, but I
+        # should really track down where the problem is coming from. Alex
+        # Schmolck reported this problem first.
+
+        # A useful post by Alex Martelli on this topic:
+        # Re: inconsistent value from __builtins__
+        # Von: Alex Martelli <[e-mail]>
+        # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
+        # Gruppen: comp.lang.python
+
+        # Michael Hohn <[e-mail]> wrote:
+        # > >>> print type(builtin_check.get_global_binding('__builtins__'))
+        # > <type 'dict'>
+        # > >>> print type(__builtins__)
+        # > <type 'module'>
+        # > Is this difference in return value intentional?
+
+        # Well, it's documented that '__builtins__' can be either a dictionary
+        # or a module, and it's been that way for a long time. Whether it's
+        # intentional (or sensible), I don't know. In any case, the idea is
+        # that if you need to access the built-in namespace directly, you
+        # should start with "import __builtin__" (note, no 's') which will
+        # definitely give you a module. Yeah, it's somewhat confusing:-(.
+
+        # These routines return properly built dicts as needed by the rest of
+        # the code, and can also be used by extension writers to generate
+        # properly initialized namespaces.
+        user_ns, user_global_ns = self.make_user_namespaces(user_ns,
+            user_global_ns)
+
+        # Assign namespaces
+        # This is the namespace where all normal user variables live
+        self.user_ns = user_ns
+        self.user_global_ns = user_global_ns
+
+        # An auxiliary namespace that checks what parts of the user_ns were
+        # loaded at startup, so we can list later only variables defined in
+        # actual interactive use.  Since it is always a subset of user_ns, it
+        # doesn't need to be seaparately tracked in the ns_table
+        self.user_config_ns = {}
+
+        # A namespace to keep track of internal data structures to prevent
+        # them from cluttering user-visible stuff.  Will be updated later
+        self.internal_ns = {}
+
+        # Now that FakeModule produces a real module, we've run into a nasty
+        # problem: after script execution (via %run), the module where the user
+        # code ran is deleted.  Now that this object is a true module (needed
+        # so docetst and other tools work correctly), the Python module
+        # teardown mechanism runs over it, and sets to None every variable
+        # present in that module.  Top-level references to objects from the
+        # script survive, because the user_ns is updated with them.  However,
+        # calling functions defined in the script that use other things from
+        # the script will fail, because the function's closure had references
+        # to the original objects, which are now all None.  So we must protect
+        # these modules from deletion by keeping a cache.
+        # 
+        # To avoid keeping stale modules around (we only need the one from the
+        # last run), we use a dict keyed with the full path to the script, so
+        # only the last version of the module is held in the cache.  Note,
+        # however, that we must cache the module *namespace contents* (their
+        # __dict__).  Because if we try to cache the actual modules, old ones
+        # (uncached) could be destroyed while still holding references (such as
+        # those held by GUI objects that tend to be long-lived)>
+        # 
+        # The %reset command will flush this cache.  See the cache_main_mod()
+        # and clear_main_mod_cache() methods for details on use.
+
+        # This is the cache used for 'main' namespaces
+        self._main_ns_cache = {}
+        # And this is the single instance of FakeModule whose __dict__ we keep
+        # copying and clearing for reuse on each %run
+        self._user_main_module = FakeModule()
+
+        # A table holding all the namespaces IPython deals with, so that
+        # introspection facilities can search easily.
+        self.ns_table = {'user':user_ns,
+                         'user_global':user_global_ns,
+                         'internal':self.internal_ns,
+                         'builtin':__builtin__.__dict__
+                         }
+
+        # Similarly, track all namespaces where references can be held and that
+        # we can safely clear (so it can NOT include builtin).  This one can be
+        # a simple list.
+        self.ns_refs_table = [ user_ns, user_global_ns, self.user_config_ns,
+                               self.internal_ns, self._main_ns_cache ]
+
+    def init_sys_modules(self):
+        # We need to insert into sys.modules something that looks like a
+        # module but which accesses the IPython namespace, for shelve and
+        # pickle to work interactively. Normally they rely on getting
+        # everything out of __main__, but for embedding purposes each IPython
+        # instance has its own private namespace, so we can't go shoving
+        # everything into __main__.
+
+        # note, however, that we should only do this for non-embedded
+        # ipythons, which really mimic the __main__.__dict__ with their own
+        # namespace.  Embedded instances, on the other hand, should not do
+        # this because they need to manage the user local/global namespaces
+        # only, but they live within a 'normal' __main__ (meaning, they
+        # shouldn't overtake the execution environment of the script they're
+        # embedded in).
+
+        # This is overridden in the InteractiveShellEmbed subclass to a no-op.
+
+        try:
+            main_name = self.user_ns['__name__']
+        except KeyError:
+            raise KeyError('user_ns dictionary MUST have a "__name__" key')
+        else:
+            sys.modules[main_name] = FakeModule(self.user_ns)
+
+    def make_user_namespaces(self, 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:
+            # 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:
+            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 init_user_ns(self):
+        """Initialize all user-visible namespaces to their minimum defaults.
+
+        Certain history lists are also initialized here, as they effectively
+        act as user namespaces.
+
+        Notes
+        -----
+        All data structures here are only filled in, they are NOT reset by this
+        method.  If they were not empty before, data will simply be added to
+        therm.
+        """
+        # Store myself as the public api!!!
+        self.user_ns['get_ipython'] = self.get_ipython
+
+        # make global variables for user access to the histories
+        self.user_ns['_ih'] = self.input_hist
+        self.user_ns['_oh'] = self.output_hist
+        self.user_ns['_dh'] = self.dir_hist
+
+        # user aliases to input and output histories
+        self.user_ns['In']  = self.input_hist
+        self.user_ns['Out'] = self.output_hist
+
+        self.user_ns['_sh'] = shadowns
+
+        # Put 'help' in the user namespace
+        try:
+            from site import _Helper
+            self.user_ns['help'] = _Helper()
+        except ImportError:
+            warn('help() not available - check site.py')
+
+    def reset(self):
+        """Clear all internal namespaces.
+
+        Note that this is much more aggressive than %reset, since it clears
+        fully all namespaces, as well as all input/output lists.
+        """
+        for ns in self.ns_refs_table:
+            ns.clear()
+
+        self.alias_manager.clear_aliases()
+
+        # Clear input and output histories
+        self.input_hist[:] = []
+        self.input_hist_raw[:] = []
+        self.output_hist.clear()
+
+        # Restore the user namespaces to minimal usability
+        self.init_user_ns()
+
+        # Restore the default and user aliases
+        self.alias_manager.init_aliases()
+
+    def push(self, variables, interactive=True):
+        """Inject a group of variables into the IPython user namespace.
+
+        Parameters
+        ----------
+        variables : dict, str or list/tuple of str
+            The variables to inject into the user's namespace.  If a dict,
+            a simple update is done.  If a str, the string is assumed to 
+            have variable names separated by spaces.  A list/tuple of str
+            can also be used to give the variable names.  If just the variable
+            names are give (list/tuple/str) then the variable values looked
+            up in the callers frame.
+        interactive : bool
+            If True (default), the variables will be listed with the ``who``
+            magic.
+        """
+        vdict = None
+
+        # We need a dict of name/value pairs to do namespace updates.
+        if isinstance(variables, dict):
+            vdict = variables
+        elif isinstance(variables, (basestring, list, tuple)):
+            if isinstance(variables, basestring):
+                vlist = variables.split()
+            else:
+                vlist = variables
+            vdict = {}
+            cf = sys._getframe(1)
+            for name in vlist:
+                try:
+                    vdict[name] = eval(name, cf.f_globals, cf.f_locals)
+                except:
+                    print ('Could not get variable %s from %s' %
+                           (name,cf.f_code.co_name))
+        else:
+            raise ValueError('variables must be a dict/str/list/tuple')
+            
+        # Propagate variables to user namespace
+        self.user_ns.update(vdict)
+
+        # And configure interactive visibility
+        config_ns = self.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
+
+    #-------------------------------------------------------------------------
+    # Things related to history management
+    #-------------------------------------------------------------------------
+
+    def init_history(self):
+        # List of input with multi-line handling.
+        self.input_hist = InputList()
+        # This one will hold the 'raw' input history, without any
+        # pre-processing.  This will allow users to retrieve the input just as
+        # it was exactly typed in by the user, with %hist -r.
+        self.input_hist_raw = InputList()
+
+        # list of visited directories
+        try:
+            self.dir_hist = [os.getcwd()]
+        except OSError:
+            self.dir_hist = []
+
+        # dict of output history
+        self.output_hist = {}
+
+        # Now the history file
+        if self.profile:
+            histfname = 'history-%s' % self.profile
+        else:
+            histfname = 'history'
+        self.histfile = os.path.join(self.ipython_dir, histfname)
+
+        # Fill the history zero entry, user counter starts at 1
+        self.input_hist.append('\n')
+        self.input_hist_raw.append('\n')
+
+    def init_shadow_hist(self):
+        try:
+            self.db = pickleshare.PickleShareDB(self.ipython_dir + "/db")
+        except exceptions.UnicodeDecodeError:
+            print "Your ipython_dir can't be decoded to unicode!"
+            print "Please set HOME environment variable to something that"
+            print r"only has ASCII characters, e.g. c:\home"
+            print "Now it is", self.ipython_dir
+            sys.exit()
+        self.shadowhist = ipcorehist.ShadowHist(self.db)
+
+    def savehist(self):
+        """Save input history to a file (via readline library)."""
+
+        if not self.has_readline:
+            return
+        
+        try:
+            self.readline.write_history_file(self.histfile)
+        except:
+            print 'Unable to save IPython command history to file: ' + \
+                  `self.histfile`
+
+    def reloadhist(self):
+        """Reload the input history from disk file."""
+
+        if self.has_readline:
+            try:
+                self.readline.clear_history()
+                self.readline.read_history_file(self.shell.histfile)
+            except AttributeError:
+                pass
+
+    def history_saving_wrapper(self, func):
+        """ Wrap func for readline history saving
+
+        Convert func into callable that saves & restores
+        history around the call """
+
+        if not self.has_readline:
+            return func
+
+        def wrapper():
+            self.savehist()
+            try:
+                func()
+            finally:
+                readline.read_history_file(self.histfile)
+        return wrapper
+
+    #-------------------------------------------------------------------------
+    # Things related to exception handling and tracebacks (not debugging)
+    #-------------------------------------------------------------------------
+
+    def init_traceback_handlers(self, custom_exceptions):
+        # Syntax error handler.
+        self.SyntaxTB = SyntaxTB(color_scheme='NoColor')
+        
+        # The interactive one is initialized with an offset, meaning we always
+        # want to remove the topmost item in the traceback, which is our own
+        # internal code. Valid modes: ['Plain','Context','Verbose']
+        self.InteractiveTB = ultratb.AutoFormattedTB(mode = 'Plain',
+                                                     color_scheme='NoColor',
+                                                     tb_offset = 1)
+
+        # IPython itself shouldn't crash. This will produce a detailed
+        # post-mortem if it does.  But we only install the crash handler for
+        # non-threaded shells, the threaded ones use a normal verbose reporter
+        # and lose the crash handler.  This is because exceptions in the main
+        # thread (such as in GUI code) propagate directly to sys.excepthook,
+        # and there's no point in printing crash dumps for every user exception.
+        if self.isthreaded:
+            ipCrashHandler = ultratb.FormattedTB()
+        else:
+            from IPython.core import crashhandler
+            ipCrashHandler = crashhandler.IPythonCrashHandler(self)
+        self.set_crash_handler(ipCrashHandler)
+
+        # and add any custom exception handlers the user may have specified
+        self.set_custom_exc(*custom_exceptions)
+
+    def set_crash_handler(self, crashHandler):
+        """Set the IPython crash handler.
+
+        This must be a callable with a signature suitable for use as
+        sys.excepthook."""
+
+        # Install the given crash handler as the Python exception hook
+        sys.excepthook = crashHandler
+        
+        # The instance will store a pointer to this, so that runtime code
+        # (such as magics) can access it.  This is because during the
+        # read-eval loop, it gets temporarily overwritten (to deal with GUI
+        # frameworks).
+        self.sys_excepthook = sys.excepthook
+
+    def set_custom_exc(self,exc_tuple,handler):
+        """set_custom_exc(exc_tuple,handler)
+
+        Set a custom exception handler, which will be called if any of the
+        exceptions in exc_tuple occur in the mainloop (specifically, in the
+        runcode() method.
+
+        Inputs:
+
+          - exc_tuple: a *tuple* of valid exceptions to call the defined
+          handler for.  It is very important that you use a tuple, and NOT A
+          LIST here, because of the way Python's except statement works.  If
+          you only want to trap a single exception, use a singleton tuple:
+
+            exc_tuple == (MyCustomException,)
+
+          - handler: this must be defined as a function with the following
+          basic interface: def my_handler(self,etype,value,tb).
+
+          This will be made into an instance method (via new.instancemethod)
+          of IPython itself, and it will be called if any of the exceptions
+          listed in the exc_tuple are caught.  If the handler is None, an
+          internal basic one is used, which just prints basic info.
+
+        WARNING: by putting in your own exception handler into IPython's main
+        execution loop, you run a very good chance of nasty crashes.  This
+        facility should only be used if you really know what you are doing."""
+
+        assert type(exc_tuple)==type(()) , \
+               "The custom exceptions must be given AS A TUPLE."
+
+        def dummy_handler(self,etype,value,tb):
+            print '*** Simple custom exception handler ***'
+            print 'Exception type :',etype
+            print 'Exception value:',value
+            print 'Traceback      :',tb
+            print 'Source code    :','\n'.join(self.buffer)
+
+        if handler is None: handler = dummy_handler
+
+        self.CustomTB = new.instancemethod(handler,self,self.__class__)
+        self.custom_exceptions = exc_tuple
+
+    def excepthook(self, etype, value, tb):
+      """One more defense for GUI apps that call sys.excepthook.
+
+      GUI frameworks like wxPython trap exceptions and call
+      sys.excepthook themselves.  I guess this is a feature that
+      enables them to keep running after exceptions that would
+      otherwise kill their mainloop. This is a bother for IPython
+      which excepts to catch all of the program exceptions with a try:
+      except: statement.
+
+      Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
+      any app directly invokes sys.excepthook, it will look to the user like
+      IPython crashed.  In order to work around this, we can disable the
+      CrashHandler and replace it with this excepthook instead, which prints a
+      regular traceback using our InteractiveTB.  In this fashion, apps which
+      call sys.excepthook will generate a regular-looking exception from
+      IPython, and the CrashHandler will only be triggered by real IPython
+      crashes.
+
+      This hook should be used sparingly, only in places which are not likely
+      to be true IPython errors.
+      """
+      self.showtraceback((etype,value,tb),tb_offset=0)
+
+    def showtraceback(self,exc_tuple = None,filename=None,tb_offset=None):
+        """Display the exception that just occurred.
+
+        If nothing is known about the exception, this is the method which
+        should be used throughout the code for presenting user tracebacks,
+        rather than directly invoking the InteractiveTB object.
+
+        A specific showsyntaxerror() also exists, but this method can take
+        care of calling it if needed, so unless you are explicitly catching a
+        SyntaxError exception, don't try to analyze the stack manually and
+        simply call this method."""
+
+        
+        # Though this won't be called by syntax errors in the input line,
+        # there may be SyntaxError cases whith imported code.
+        
+        try:
+            if exc_tuple is None:
+                etype, value, tb = sys.exc_info()
+            else:
+                etype, value, tb = exc_tuple
+    
+            if etype is SyntaxError:
+                self.showsyntaxerror(filename)
+            elif etype is UsageError:
+                print "UsageError:", value
+            else:
+                # WARNING: these variables are somewhat deprecated and not
+                # necessarily safe to use in a threaded environment, but tools
+                # like pdb depend on their existence, so let's set them.  If we
+                # find problems in the field, we'll need to revisit their use.
+                sys.last_type = etype
+                sys.last_value = value
+                sys.last_traceback = tb
+    
+                if etype in self.custom_exceptions:
+                    self.CustomTB(etype,value,tb)
+                else:
+                    self.InteractiveTB(etype,value,tb,tb_offset=tb_offset)
+                    if self.InteractiveTB.call_pdb and self.has_readline:
+                        # pdb mucks up readline, fix it back
+                        self.set_completer()
+        except KeyboardInterrupt:
+            self.write("\nKeyboardInterrupt\n")
+
+    def showsyntaxerror(self, filename=None):
+        """Display the syntax error that just occurred.
+
+        This doesn't display a stack trace because there isn't one.
+
+        If a filename is given, it is stuffed in the exception instead
+        of what was there before (because Python's parser always uses
+        "<string>" when reading from a string).
+        """
+        etype, value, last_traceback = sys.exc_info()
+
+        # See note about these variables in showtraceback() below
+        sys.last_type = etype
+        sys.last_value = value
+        sys.last_traceback = last_traceback
+        
+        if filename and etype is SyntaxError:
+            # Work hard to stuff the correct filename in the exception
+            try:
+                msg, (dummy_filename, lineno, offset, line) = value
+            except:
+                # Not the format we expect; leave it alone
+                pass
+            else:
+                # Stuff in the right filename
+                try:
+                    # Assume SyntaxError is a class exception
+                    value = SyntaxError(msg, (filename, lineno, offset, line))
+                except:
+                    # If that failed, assume SyntaxError is a string
+                    value = msg, (filename, lineno, offset, line)
+        self.SyntaxTB(etype,value,[])
+
+    def edit_syntax_error(self):
+        """The bottom half of the syntax error handler called in the main loop.
+
+        Loop until syntax error is fixed or user cancels.
+        """
+
+        while self.SyntaxTB.last_syntax_error:
+            # copy and clear last_syntax_error
+            err = self.SyntaxTB.clear_err_state()
+            if not self._should_recompile(err):
+                return
+            try:
+                # may set last_syntax_error again if a SyntaxError is raised
+                self.safe_execfile(err.filename,self.user_ns)
+            except:
+                self.showtraceback()
+            else:
+                try:
+                    f = file(err.filename)
+                    try:
+                        # This should be inside a display_trap block and I 
+                        # think it is.
+                        sys.displayhook(f.read())
+                    finally:
+                        f.close()
+                except:
+                    self.showtraceback()
+
+    def _should_recompile(self,e):
+        """Utility routine for edit_syntax_error"""
+
+        if e.filename in ('<ipython console>','<input>','<string>',
+                          '<console>','<BackgroundJob compilation>',
+                          None):
+                              
+            return False
+        try:
+            if (self.autoedit_syntax and 
+                not self.ask_yes_no('Return to editor to correct syntax error? '
+                              '[Y/n] ','y')):
+                return False
+        except EOFError:
+            return False
+
+        def int0(x):
+            try:
+                return int(x)
+            except TypeError:
+                return 0
+        # always pass integer line and offset values to editor hook
+        try:
+            self.hooks.fix_error_editor(e.filename,
+                int0(e.lineno),int0(e.offset),e.msg)
+        except TryNext:
+            warn('Could not open editor')
+            return False
+        return True
+
+    #-------------------------------------------------------------------------
+    # Things related to tab completion
+    #-------------------------------------------------------------------------
+
+    def complete(self, text):
+        """Return a sorted list of all possible completions on text.
+
+        Inputs:
+
+          - text: a string of text to be completed on.
+
+        This is a wrapper around the completion mechanism, similar to what
+        readline does at the command line when the TAB key is hit.  By
+        exposing it as a method, it can be used by other non-readline
+        environments (such as GUIs) for text completion.
+
+        Simple usage example:
+
+        In [7]: x = 'hello'
+
+        In [8]: x
+        Out[8]: 'hello'
+
+        In [9]: print x
+        hello
+
+        In [10]: _ip.complete('x.l')
+        Out[10]: ['x.ljust', 'x.lower', 'x.lstrip']
+        """
+
+        # Inject names into __builtin__ so we can complete on the added names.
+        with self.builtin_trap:
+            complete = self.Completer.complete
+            state = 0
+            # use a dict so we get unique keys, since ipyhton's multiple
+            # completers can return duplicates.  When we make 2.4 a requirement,
+            # start using sets instead, which are faster.
+            comps = {}
+            while True:
+                newcomp = complete(text,state,line_buffer=text)
+                if newcomp is None:
+                    break
+                comps[newcomp] = 1
+                state += 1
+            outcomps = comps.keys()
+            outcomps.sort()
+            #print "T:",text,"OC:",outcomps  # dbg
+            #print "vars:",self.user_ns.keys()
+            return outcomps
+
+    def set_custom_completer(self,completer,pos=0):
+        """Adds a new custom completer function.
+
+        The position argument (defaults to 0) is the index in the completers
+        list where you want the completer to be inserted."""
+
+        newcomp = new.instancemethod(completer,self.Completer,
+                                     self.Completer.__class__)
+        self.Completer.matchers.insert(pos,newcomp)
+
+    def set_completer(self):
+        """Reset readline's completer to be our own."""
+        self.readline.set_completer(self.Completer.complete)
+
+    def set_completer_frame(self, frame=None):
+        """Set the frame of the completer."""
+        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
+
+    #-------------------------------------------------------------------------
+    # Things related to readline
+    #-------------------------------------------------------------------------
+
+    def init_readline(self):
+        """Command history completion/saving/reloading."""
+
+        self.rl_next_input = None
+        self.rl_do_indent = False
+
+        if not self.readline_use:
+            return
+
+        import IPython.utils.rlineimpl as readline
+                  
+        if not readline.have_readline:
+            self.has_readline = 0
+            self.readline = None
+            # no point in bugging windows users with this every time:
+            warn('Readline services not available on this platform.')
+        else:
+            sys.modules['readline'] = readline
+            import atexit
+            from IPython.core.completer import IPCompleter
+            self.Completer = IPCompleter(self,
+                                         self.user_ns,
+                                         self.user_global_ns,
+                                         self.readline_omit__names,
+                                         self.alias_manager.alias_table)
+            sdisp = self.strdispatchers.get('complete_command', StrDispatch())
+            self.strdispatchers['complete_command'] = sdisp
+            self.Completer.custom_completers = sdisp
+            # Platform-specific configuration
+            if os.name == 'nt':
+                self.readline_startup_hook = readline.set_pre_input_hook
+            else:
+                self.readline_startup_hook = readline.set_startup_hook
+
+            # Load user's initrc file (readline config)
+            # Or if libedit is used, load editrc.
+            inputrc_name = os.environ.get('INPUTRC')
+            if inputrc_name is None:
+                home_dir = get_home_dir()
+                if home_dir is not None:
+                    inputrc_name = '.inputrc'
+                    if readline.uses_libedit:
+                        inputrc_name = '.editrc'
+                    inputrc_name = os.path.join(home_dir, inputrc_name)
+            if os.path.isfile(inputrc_name):
+                try:
+                    readline.read_init_file(inputrc_name)
+                except:
+                    warn('Problems reading readline initialization file <%s>'
+                         % inputrc_name)
+            
+            self.has_readline = 1
+            self.readline = readline
+            # save this in sys so embedded copies can restore it properly
+            sys.ipcompleter = self.Completer.complete
+            self.set_completer()
+
+            # Configure readline according to user's prefs
+            # This is only done if GNU readline is being used.  If libedit
+            # is being used (as on Leopard) the readline config is
+            # not run as the syntax for libedit is different.
+            if not readline.uses_libedit:
+                for rlcommand in self.readline_parse_and_bind:
+                    #print "loading rl:",rlcommand  # dbg
+                    readline.parse_and_bind(rlcommand)
+
+            # Remove some chars from the delimiters list.  If we encounter
+            # unicode chars, discard them.
+            delims = readline.get_completer_delims().encode("ascii", "ignore")
+            delims = delims.translate(string._idmap,
+                                      self.readline_remove_delims)
+            readline.set_completer_delims(delims)
+            # otherwise we end up with a monster history after a while:
+            readline.set_history_length(1000)
+            try:
+                #print '*** Reading readline history'  # dbg
+                readline.read_history_file(self.histfile)
+            except IOError:
+                pass  # It doesn't exist yet.
+
+            atexit.register(self.atexit_operations)
+            del atexit
+
+        # Configure auto-indent for all platforms
+        self.set_autoindent(self.autoindent)
+
+    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.rl_next_input = s
+
+    def pre_readline(self):
+        """readline hook to be used at the start of each line.
+
+        Currently it handles auto-indent only."""
+
+        #debugx('self.indent_current_nsp','pre_readline:')
+
+        if self.rl_do_indent:
+            self.readline.insert_text(self._indent_current_str())
+        if self.rl_next_input is not None:
+            self.readline.insert_text(self.rl_next_input)
+            self.rl_next_input = None
+
+    def _indent_current_str(self):
+        """return the current level of indentation as a string"""
+        return self.indent_current_nsp * ' '
+
+    #-------------------------------------------------------------------------
+    # Things related to magics
+    #-------------------------------------------------------------------------
+
+    def init_magics(self):
+        # Set user colors (don't do it in the constructor above so that it
+        # doesn't crash if colors option is invalid)
+        self.magic_colors(self.colors)
+
+    def magic(self,arg_s):
+        """Call a magic function by name.
+
+        Input: a string containing the name of the magic function to call and any
+        additional arguments to be passed to the magic.
+
+        magic('name -opt foo bar') is equivalent to typing at the ipython
+        prompt:
+
+        In[1]: %name -opt foo bar
+
+        To call a magic without arguments, simply use magic('name').
+
+        This provides a proper Python function to call IPython's magics in any
+        valid Python code you can type at the interpreter, including loops and
+        compound statements.
+        """
+
+        args = arg_s.split(' ',1)
+        magic_name = args[0]
+        magic_name = magic_name.lstrip(prefilter.ESC_MAGIC)
+
+        try:
+            magic_args = args[1]
+        except IndexError:
+            magic_args = ''
+        fn = getattr(self,'magic_'+magic_name,None)
+        if fn is None:
+            error("Magic function `%s` not found." % magic_name)
+        else:
+            magic_args = self.var_expand(magic_args,1)
+            with nested(self.builtin_trap,):
+                result = fn(magic_args)
+                return result
+
+    def define_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
+    
+        self.define_magic('foo',foo_impl)
+        """
+        
+        import new
+        im = new.instancemethod(func,self, self.__class__)
+        old = getattr(self, "magic_" + magicname, None)
+        setattr(self, "magic_" + magicname, im)
+        return old
+
+    #-------------------------------------------------------------------------
+    # Things related to macros
+    #-------------------------------------------------------------------------
+
+    def define_macro(self, name, themacro):
+        """Define a new macro
+
+        Parameters
+        ----------
+        name : str
+            The name of the macro.
+        themacro : str or Macro
+            The action to do upon invoking the macro.  If a string, a new 
+            Macro object is created by passing the string to it.
+        """
+        
+        from IPython.core import macro
+
+        if isinstance(themacro, basestring):
+            themacro = macro.Macro(themacro)
+        if not isinstance(themacro, macro.Macro):
+            raise ValueError('A macro must be a string or a Macro instance.')
+        self.user_ns[name] = themacro
+
+    #-------------------------------------------------------------------------
+    # Things related to the running of system commands
+    #-------------------------------------------------------------------------
+
+    def system(self, cmd):
+        """Make a system call, using IPython."""
+        return self.hooks.shell_hook(self.var_expand(cmd, depth=2))
+
+    #-------------------------------------------------------------------------
+    # Things related to aliases
+    #-------------------------------------------------------------------------
+
+    def init_alias(self):
+        self.alias_manager = AliasManager(self, config=self.config)
+        self.ns_table['alias'] = self.alias_manager.alias_table,
+
+    #-------------------------------------------------------------------------
+    # Things related to the running of code
+    #-------------------------------------------------------------------------
+
+    def ex(self, cmd):
+        """Execute a normal python statement in user namespace."""
+        with nested(self.builtin_trap,):
+            exec cmd in self.user_global_ns, self.user_ns
+
+    def ev(self, expr):
+        """Evaluate python expression expr in user namespace.
+
+        Returns the result of evaluation
+        """
+        with nested(self.builtin_trap,):
+            return eval(expr, self.user_global_ns, self.user_ns)
+
+    def mainloop(self, display_banner=None):
+        """Start the mainloop.
+
+        If an optional banner argument is given, it will override the
+        internally created default banner.
+        """
+        
+        with nested(self.builtin_trap, self.display_trap):
+
+            # if you run stuff with -c <cmd>, raw hist is not updated
+            # ensure that it's in sync
+            if len(self.input_hist) != len (self.input_hist_raw):
+                self.input_hist_raw = InputList(self.input_hist)
+
+            while 1:
+                try:
+                    self.interact(display_banner=display_banner)
+                    #self.interact_with_readline()                
+                    # XXX for testing of a readline-decoupled repl loop, call
+                    # interact_with_readline above
+                    break
+                except KeyboardInterrupt:
+                    # this should not be necessary, but KeyboardInterrupt
+                    # handling seems rather unpredictable...
+                    self.write("\nKeyboardInterrupt in interact()\n")
+
+    def interact_prompt(self):
+        """ Print the prompt (in read-eval-print loop) 
+
+        Provided for those who want to implement their own read-eval-print loop (e.g. GUIs), not 
+        used in standard IPython flow.
+        """
+        if self.more:
+            try:
+                prompt = self.hooks.generate_prompt(True)
+            except:
+                self.showtraceback()
+            if self.autoindent:
+                self.rl_do_indent = True
+
+        else:
+            try:
+                prompt = self.hooks.generate_prompt(False)
+            except:
+                self.showtraceback()
+        self.write(prompt)
+
+    def interact_handle_input(self,line):
+        """ Handle the input line (in read-eval-print loop)
+        
+        Provided for those who want to implement their own read-eval-print loop (e.g. GUIs), not 
+        used in standard IPython flow.        
+        """
+        if line.lstrip() == line:
+            self.shadowhist.add(line.strip())
+        lineout = self.prefilter_manager.prefilter_lines(line,self.more)
+
+        if line.strip():
+            if self.more:
+                self.input_hist_raw[-1] += '%s\n' % line
+            else:
+                self.input_hist_raw.append('%s\n' % line)                
+
+        
+        self.more = self.push_line(lineout)
+        if (self.SyntaxTB.last_syntax_error and
+            self.autoedit_syntax):
+            self.edit_syntax_error()
+
+    def interact_with_readline(self):
+        """ Demo of using interact_handle_input, interact_prompt
+        
+        This is the main read-eval-print loop. If you need to implement your own (e.g. for GUI),
+        it should work like this.
+        """ 
+        self.readline_startup_hook(self.pre_readline)
+        while not self.exit_now:
+            self.interact_prompt()
+            if self.more:
+                self.rl_do_indent = True
+            else:
+                self.rl_do_indent = False
+            line = raw_input_original().decode(self.stdin_encoding)
+            self.interact_handle_input(line)
+
+    def interact(self, display_banner=None):
+        """Closely emulate the interactive Python console."""
+
+        # batch run -> do not interact        
+        if self.exit_now:
+            return
+
+        if display_banner is None:
+            display_banner = self.display_banner
+        if display_banner:
+            self.show_banner()
+
+        more = 0
+        
+        # Mark activity in the builtins
+        __builtin__.__dict__['__IPYTHON__active'] += 1
+        
+        if self.has_readline:
+            self.readline_startup_hook(self.pre_readline)
+        # exit_now is set by a call to %Exit or %Quit, through the
+        # ask_exit callback.
+        
+        while not self.exit_now:
+            self.hooks.pre_prompt_hook()
+            if more:
+                try:
+                    prompt = self.hooks.generate_prompt(True)
+                except:
+                    self.showtraceback()
+                if self.autoindent:
+                    self.rl_do_indent = True
+                    
+            else:
+                try:
+                    prompt = self.hooks.generate_prompt(False)
+                except:
+                    self.showtraceback()
+            try:
+                line = self.raw_input(prompt, more)
+                if self.exit_now:
+                    # quick exit on sys.std[in|out] close
+                    break
+                if self.autoindent:
+                    self.rl_do_indent = False
+                    
+            except KeyboardInterrupt:
+                #double-guard against keyboardinterrupts during kbdint handling
+                try:
+                    self.write('\nKeyboardInterrupt\n')
+                    self.resetbuffer()
+                    # keep cache in sync with the prompt counter:
+                    self.outputcache.prompt_count -= 1
+    
+                    if self.autoindent:
+                        self.indent_current_nsp = 0
+                    more = 0
+                except KeyboardInterrupt:
+                    pass
+            except EOFError:
+                if self.autoindent:
+                    self.rl_do_indent = False
+                    self.readline_startup_hook(None)
+                self.write('\n')
+                self.exit()
+            except bdb.BdbQuit:
+                warn('The Python debugger has exited with a BdbQuit exception.\n'
+                     'Because of how pdb handles the stack, it is impossible\n'
+                     'for IPython to properly format this particular exception.\n'
+                     'IPython will resume normal operation.')
+            except:
+                # exceptions here are VERY RARE, but they can be triggered
+                # asynchronously by signal handlers, for example.
+                self.showtraceback()
+            else:
+                more = self.push_line(line)
+                if (self.SyntaxTB.last_syntax_error and
+                    self.autoedit_syntax):
+                    self.edit_syntax_error()
+            
+        # We are off again...
+        __builtin__.__dict__['__IPYTHON__active'] -= 1
+
+    def safe_execfile(self, fname, *where, **kw):
+        """A safe version of the builtin execfile().
+
+        This version will never throw an exception, but instead print
+        helpful error messages to the screen.  This only works on pure
+        Python files with the .py extension.
+
+        Parameters
+        ----------
+        fname : string
+            The name of the file to be executed.
+        where : tuple
+            One or two namespaces, passed to execfile() as (globals,locals).
+            If only one is given, it is passed as both.
+        exit_ignore : bool (False)
+            If True, then don't print errors for non-zero exit statuses.
+        """
+        kw.setdefault('exit_ignore', False)
+
+        fname = os.path.abspath(os.path.expanduser(fname))
+
+        # Make sure we have a .py file
+        if not fname.endswith('.py'):
+            warn('File must end with .py to be run using execfile: <%s>' % fname)
+
+        # Make sure we can open the file
+        try:
+            with open(fname) as thefile:
+                pass
+        except:
+            warn('Could not open file <%s> for safe execution.' % fname)
+            return
+
+        # Find things also in current directory.  This is needed to mimic the
+        # behavior of running a script from the system command line, where
+        # Python inserts the script's directory into sys.path
+        dname = os.path.dirname(fname)
+
+        with prepended_to_syspath(dname):
+            try:
+                if sys.platform == 'win32' and sys.version_info < (2,5,1):
+                    # Work around a bug in Python for Windows.  The bug was
+                    # fixed in in Python 2.5 r54159 and 54158, but that's still
+                    # SVN Python as of March/07.  For details, see:
+                    # http://projects.scipy.org/ipython/ipython/ticket/123
+                    try:
+                        globs,locs = where[0:2]
+                    except:
+                        try:
+                            globs = locs = where[0]
+                        except:
+                            globs = locs = globals()
+                    exec file(fname) in globs,locs
+                else:
+                    execfile(fname,*where)
+            except SyntaxError:
+                self.showsyntaxerror()
+                warn('Failure executing file: <%s>' % fname)
+            except SystemExit, status:
+                # Code that correctly sets the exit status flag to success (0)
+                # shouldn't be bothered with a traceback.  Note that a plain
+                # sys.exit() does NOT set the message to 0 (it's empty) so that
+                # will still get a traceback.  Note that the structure of the
+                # SystemExit exception changed between Python 2.4 and 2.5, so
+                # the checks must be done in a version-dependent way.
+                show = False
+                if status.args[0]==0 and not kw['exit_ignore']:
+                    show = True
+                if show:
+                    self.showtraceback()
+                    warn('Failure executing file: <%s>' % fname)
+            except:
+                self.showtraceback()
+                warn('Failure executing file: <%s>' % fname)
+
+    def safe_execfile_ipy(self, fname):
+        """Like safe_execfile, but for .ipy files with IPython syntax.
+
+        Parameters
+        ----------
+        fname : str
+            The name of the file to execute.  The filename must have a
+            .ipy extension.
+        """
+        fname = os.path.abspath(os.path.expanduser(fname))
+
+        # Make sure we have a .py file
+        if not fname.endswith('.ipy'):
+            warn('File must end with .py to be run using execfile: <%s>' % fname)
+
+        # Make sure we can open the file
+        try:
+            with open(fname) as thefile:
+                pass
+        except:
+            warn('Could not open file <%s> for safe execution.' % fname)
+            return
+
+        # Find things also in current directory.  This is needed to mimic the
+        # behavior of running a script from the system command line, where
+        # Python inserts the script's directory into sys.path
+        dname = os.path.dirname(fname)
+
+        with prepended_to_syspath(dname):
+            try:
+                with open(fname) as thefile:
+                    script = thefile.read()
+                    # self.runlines currently captures all exceptions
+                    # raise in user code.  It would be nice if there were
+                    # versions of runlines, execfile that did raise, so
+                    # we could catch the errors.
+                    self.runlines(script, clean=True)
+            except:
+                self.showtraceback()
+                warn('Unknown failure executing file: <%s>' % fname)
+                
+    def _is_secondary_block_start(self, 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
+
+    def cleanup_ipy_script(self, script):
+        """Make a script safe for self.runlines()
+
+        Currently, IPython is lines based, with blocks being detected by
+        empty lines.  This is a problem for block based scripts that may
+        not have empty lines after blocks.  This script adds those empty
+        lines to make scripts safe for running in the current line based
+        IPython.
+        """
+        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)                    
+            if level > 0 and newlevel == 0 and \
+                   not self._is_secondary_block_start(stripped): 
+                # add empty line
+                res.append('')
+            res.append(l)
+            level = newlevel
+
+        return '\n'.join(res) + '\n'
+
+    def runlines(self, lines, clean=False):
+        """Run a string of one or more lines of source.
+
+        This method is capable of running a string containing multiple source
+        lines, as if they had been entered at the IPython prompt.  Since it
+        exposes IPython's processing machinery, the given strings can contain
+        magic calls (%magic), special shell access (!cmd), etc.
+        """
+
+        if isinstance(lines, (list, tuple)):
+            lines = '\n'.join(lines)
+
+        if clean:
+            lines = self.cleanup_ipy_script(lines)
+
+        # We must start with a clean buffer, in case this is run from an
+        # interactive IPython session (via a magic, for example).
+        self.resetbuffer()
+        lines = lines.splitlines()
+        more = 0
+
+        with nested(self.builtin_trap, self.display_trap):
+            for line in lines:
+                # skip blank lines so we don't mess up the prompt counter, but do
+                # NOT skip even a blank line if we are in a code block (more is
+                # true)
+            
+                if line or more:
+                    # push to raw history, so hist line numbers stay in sync
+                    self.input_hist_raw.append("# " + line + "\n")
+                    prefiltered = self.prefilter_manager.prefilter_lines(line,more)
+                    more = self.push_line(prefiltered)
+                    # IPython's runsource returns None if there was an error
+                    # compiling the code.  This allows us to stop processing right
+                    # away, so the user gets the error message at the right place.
+                    if more is None:
+                        break
+                else:
+                    self.input_hist_raw.append("\n")
+            # final newline in case the input didn't have it, so that the code
+            # actually does get executed
+            if more:
+                self.push_line('\n')
+
+    def runsource(self, source, filename='<input>', symbol='single'):
+        """Compile and run some source in the interpreter.
+
+        Arguments are as for compile_command().
+
+        One several things can happen:
+
+        1) The input is incorrect; compile_command() raised an
+        exception (SyntaxError or OverflowError).  A syntax traceback
+        will be printed by calling the showsyntaxerror() method.
+
+        2) The input is incomplete, and more input is required;
+        compile_command() returned None.  Nothing happens.
+
+        3) The input is complete; compile_command() returned a code
+        object.  The code is executed by calling self.runcode() (which
+        also handles run-time exceptions, except for SystemExit).
+
+        The return value is:
+
+          - True in case 2
+
+          - False in the other cases, unless an exception is raised, where
+          None is returned instead.  This can be used by external callers to
+          know whether to continue feeding input or not.
+
+        The return value can be used to decide whether to use sys.ps1 or
+        sys.ps2 to prompt the next line."""
+
+        # if the source code has leading blanks, add 'if 1:\n' to it
+        # this allows execution of indented pasted code. It is tempting
+        # to add '\n' at the end of source to run commands like ' a=1'
+        # directly, but this fails for more complicated scenarios
+        source=source.encode(self.stdin_encoding)
+        if source[:1] in [' ', '\t']:
+            source = 'if 1:\n%s' % source
+
+        try:
+            code = self.compile(source,filename,symbol)
+        except (OverflowError, SyntaxError, ValueError, TypeError, MemoryError):
+            # Case 1
+            self.showsyntaxerror(filename)
+            return None
+
+        if code is None:
+            # Case 2
+            return True
+
+        # Case 3
+        # We store the code object so that threaded shells and
+        # custom exception handlers can access all this info if needed.
+        # The source corresponding to this can be obtained from the
+        # buffer attribute as '\n'.join(self.buffer).
+        self.code_to_run = code
+        # now actually execute the code object
+        if self.runcode(code) == 0:
+            return False
+        else:
+            return None
+
+    def runcode(self,code_obj):
+        """Execute a code object.
+
+        When an exception occurs, self.showtraceback() is called to display a
+        traceback.
+
+        Return value: a flag indicating whether the code to be run completed
+        successfully:
+
+          - 0: successful execution.
+          - 1: an error occurred.
+        """
+
+        # Set our own excepthook in case the user code tries to call it
+        # directly, so that the IPython crash handler doesn't get triggered
+        old_excepthook,sys.excepthook = sys.excepthook, self.excepthook
+
+        # we save the original sys.excepthook in the instance, in case config
+        # code (such as magics) needs access to it.
+        self.sys_excepthook = old_excepthook
+        outflag = 1  # happens in more places, so it's easier as default
+        try:
+            try:
+                self.hooks.pre_runcode_hook()
+                exec code_obj in self.user_global_ns, self.user_ns
+            finally:
+                # Reset our crash handler in place
+                sys.excepthook = old_excepthook
+        except SystemExit:
+            self.resetbuffer()
+            self.showtraceback()
+            warn("Type %exit or %quit to exit IPython "
+                 "(%Exit or %Quit do so unconditionally).",level=1)
+        except self.custom_exceptions:
+            etype,value,tb = sys.exc_info()
+            self.CustomTB(etype,value,tb)
+        except:
+            self.showtraceback()
+        else:
+            outflag = 0
+            if softspace(sys.stdout, 0):
+                print
+        # Flush out code object which has been run (and source)
+        self.code_to_run = None
+        return outflag
+        
+    def push_line(self, line):
+        """Push a line to the interpreter.
+
+        The line should not have a trailing newline; it may have
+        internal newlines.  The line is appended to a buffer and the
+        interpreter's runsource() method is called with the
+        concatenated contents of the buffer as source.  If this
+        indicates that the command was executed or invalid, the buffer
+        is reset; otherwise, the command is incomplete, and the buffer
+        is left as it was after the line was appended.  The return
+        value is 1 if more input is required, 0 if the line was dealt
+        with in some way (this is the same as runsource()).
+        """
+
+        # autoindent management should be done here, and not in the
+        # interactive loop, since that one is only seen by keyboard input.  We
+        # need this done correctly even for code run via runlines (which uses
+        # push).
+
+        #print 'push line: <%s>' % line  # dbg
+        for subline in line.splitlines():
+            self._autoindent_update(subline)
+        self.buffer.append(line)
+        more = self.runsource('\n'.join(self.buffer), self.filename)
+        if not more:
+            self.resetbuffer()
+        return more
+
+    def _autoindent_update(self,line):
+        """Keep track of the indent level."""
+
+        #debugx('line')
+        #debugx('self.indent_current_nsp')
+        if self.autoindent:
+            if line:
+                inisp = num_ini_spaces(line)
+                if inisp < self.indent_current_nsp:
+                    self.indent_current_nsp = inisp
+
+                if line[-1] == ':':
+                    self.indent_current_nsp += 4
+                elif dedent_re.match(line):
+                    self.indent_current_nsp -= 4
+            else:
+                self.indent_current_nsp = 0
+
+    def resetbuffer(self):
+        """Reset the input buffer."""
+        self.buffer[:] = []
+        
+    def raw_input(self,prompt='',continue_prompt=False):
+        """Write a prompt and read a line.
+
+        The returned line does not include the trailing newline.
+        When the user enters the EOF key sequence, EOFError is raised.
+
+        Optional inputs:
+
+          - prompt(''): a string to be printed to prompt the user.
+
+          - continue_prompt(False): whether this line is the first one or a
+          continuation in a sequence of inputs.
+        """
+        # growl.notify("raw_input: ", "prompt = %r\ncontinue_prompt = %s" % (prompt, continue_prompt))
+
+        # Code run by the user may have modified the readline completer state.
+        # We must ensure that our completer is back in place.
+
+        if self.has_readline:
+            self.set_completer()
+        
+        try:
+            line = raw_input_original(prompt).decode(self.stdin_encoding)
+        except ValueError:
+            warn("\n********\nYou or a %run:ed script called sys.stdin.close()"
+                 " or sys.stdout.close()!\nExiting IPython!")
+            self.ask_exit()
+            return ""
+
+        # Try to be reasonably smart about not re-indenting pasted input more
+        # than necessary.  We do this by trimming out the auto-indent initial
+        # spaces, if the user's actual input started itself with whitespace.
+        #debugx('self.buffer[-1]')
+
+        if self.autoindent:
+            if num_ini_spaces(line) > self.indent_current_nsp:
+                line = line[self.indent_current_nsp:]
+                self.indent_current_nsp = 0
+            
+        # store the unfiltered input before the user has any chance to modify
+        # it.
+        if line.strip():
+            if continue_prompt:
+                self.input_hist_raw[-1] += '%s\n' % line
+                if self.has_readline and self.readline_use:
+                    try:
+                        histlen = self.readline.get_current_history_length()
+                        if histlen > 1:
+                            newhist = self.input_hist_raw[-1].rstrip()
+                            self.readline.remove_history_item(histlen-1)
+                            self.readline.replace_history_item(histlen-2,
+                                            newhist.encode(self.stdin_encoding))
+                    except AttributeError:
+                        pass # re{move,place}_history_item are new in 2.4.                
+            else:
+                self.input_hist_raw.append('%s\n' % line)                
+            # only entries starting at first column go to shadow history
+            if line.lstrip() == line:
+                self.shadowhist.add(line.strip())
+        elif not continue_prompt:
+            self.input_hist_raw.append('\n')
+        try:
+            lineout = self.prefilter_manager.prefilter_lines(line,continue_prompt)
+        except:
+            # blanket except, in case a user-defined prefilter crashes, so it
+            # can't take all of ipython with it.
+            self.showtraceback()
+            return ''
+        else:
+            return lineout
+
+    #-------------------------------------------------------------------------
+    # Working with components
+    #-------------------------------------------------------------------------
+
+    def get_component(self, name=None, klass=None):
+        """Fetch a component by name and klass in my tree."""
+        c = Component.get_instances(root=self, name=name, klass=klass)
+        if len(c) == 0:
+            return None
+        if len(c) == 1:
+            return c[0]
+        else:
+            return c
+
+    #-------------------------------------------------------------------------
+    # IPython extensions
+    #-------------------------------------------------------------------------
+
+    def load_extension(self, module_str):
+        """Load an IPython extension by its module name.
+
+        An IPython extension is an importable Python module that has
+        a function with the signature::
+
+            def load_ipython_extension(ipython):
+                # Do things with ipython
+
+        This function is called after your extension is imported and the 
+        currently active :class:`InteractiveShell` instance is passed as
+        the only argument.  You can do anything you want with IPython at
+        that point, including defining new magic and aliases, adding new
+        components, etc.
+
+        The :func:`load_ipython_extension` will be called again is you 
+        load or reload the extension again.  It is up to the extension
+        author to add code to manage that.
+
+        You can put your extension modules anywhere you want, as long as
+        they can be imported by Python's standard import mechanism.  However,
+        to make it easy to write extensions, you can also put your extensions
+        in ``os.path.join(self.ipython_dir, 'extensions')``.  This directory
+        is added to ``sys.path`` automatically.
+        """
+        from IPython.utils.syspathcontext import prepended_to_syspath
+
+        if module_str not in sys.modules:
+            with prepended_to_syspath(self.ipython_extension_dir):
+                __import__(module_str)
+        mod = sys.modules[module_str]
+        self._call_load_ipython_extension(mod)
+
+    def unload_extension(self, module_str):
+        """Unload an IPython extension by its module name.
+
+        This function looks up the extension's name in ``sys.modules`` and
+        simply calls ``mod.unload_ipython_extension(self)``.
+        """
+        if module_str in sys.modules:
+            mod = sys.modules[module_str]
+            self._call_unload_ipython_extension(mod)
+
+    def reload_extension(self, module_str):
+        """Reload an IPython extension by calling reload.
+
+        If the module has not been loaded before,
+        :meth:`InteractiveShell.load_extension` is called. Otherwise
+        :func:`reload` is called and then the :func:`load_ipython_extension`
+        function of the module, if it exists is called.
+        """
+        from IPython.utils.syspathcontext import prepended_to_syspath
+
+        with prepended_to_syspath(self.ipython_extension_dir):
+            if module_str in sys.modules:
+                mod = sys.modules[module_str]
+                reload(mod)
+                self._call_load_ipython_extension(mod)
+            else:
+                self.load_extension(module_str)
+
+    def _call_load_ipython_extension(self, mod):
+        if hasattr(mod, 'load_ipython_extension'):
+            mod.load_ipython_extension(self)
+
+    def _call_unload_ipython_extension(self, mod):
+        if hasattr(mod, 'unload_ipython_extension'):
+            mod.unload_ipython_extension(self)
+
+    #-------------------------------------------------------------------------
+    # Things related to the prefilter
+    #-------------------------------------------------------------------------
+
+    def init_prefilter(self):
+        self.prefilter_manager = PrefilterManager(self, config=self.config)
+
+    #-------------------------------------------------------------------------
+    # Utilities
+    #-------------------------------------------------------------------------
+
+    def getoutput(self, cmd):
+        return getoutput(self.var_expand(cmd,depth=2),
+                         header=self.system_header,
+                         verbose=self.system_verbose)
+
+    def getoutputerror(self, cmd):
+        return getoutputerror(self.var_expand(cmd,depth=2),
+                              header=self.system_header,
+                              verbose=self.system_verbose)
+
+    def var_expand(self,cmd,depth=0):
+        """Expand python variables in a string.
+
+        The depth argument indicates how many frames above the caller should
+        be walked to look for the local namespace where to expand variables.
+
+        The global namespace for expansion is always the user's interactive
+        namespace.
+        """
+
+        return str(ItplNS(cmd,
+                          self.user_ns,  # globals
+                          # Skip our own frame in searching for locals:
+                          sys._getframe(depth+1).f_locals # locals
+                          ))
+
+    def mktempfile(self,data=None):
+        """Make a new tempfile and return its filename.
+
+        This makes a call to tempfile.mktemp, but it registers the created
+        filename internally so ipython cleans it up at exit time.
+
+        Optional inputs:
+
+          - data(None): if data is given, it gets written out to the temp file
+          immediately, and the file is closed again."""
+
+        filename = tempfile.mktemp('.py','ipython_edit_')
+        self.tempfiles.append(filename)
+        
+        if data:
+            tmp_file = open(filename,'w')
+            tmp_file.write(data)
+            tmp_file.close()
+        return filename
+
+    def write(self,data):
+        """Write a string to the default output"""
+        Term.cout.write(data)
+
+    def write_err(self,data):
+        """Write a string to the default error output"""
+        Term.cerr.write(data)
+
+    def ask_yes_no(self,prompt,default=True):
+        if self.quiet:
+            return True
+        return ask_yes_no(prompt,default)
+
+    #-------------------------------------------------------------------------
+    # Things related to IPython exiting
+    #-------------------------------------------------------------------------
+
+    def ask_exit(self):
+        """ Call for exiting. Can be overiden and used as a callback. """
+        self.exit_now = True
+
+    def exit(self):
+        """Handle interactive exit.
+
+        This method calls the ask_exit callback."""
+        if self.confirm_exit:
+            if self.ask_yes_no('Do you really want to exit ([y]/n)?','y'):
+                self.ask_exit()
+        else:
+            self.ask_exit()
+
+    def atexit_operations(self):
+        """This will be executed at the time of exit.
+
+        Saving of persistent data should be performed here.
+        """
+        self.savehist()
+
+        # Cleanup all tempfiles left around
+        for tfile in self.tempfiles:
+            try:
+                os.unlink(tfile)
+            except OSError:
+                pass
+
+        # Clear all user namespaces to release all references cleanly.
+        self.reset()
+
+        # Run user hooks
+        self.hooks.shutdown_hook()
+
+    def cleanup(self):
+        self.restore_sys_module_state()
+
+

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/prefilter.py

@@ -0,0 +1,995 b''
+#!/usr/bin/env python
+# encoding: utf-8
+"""
+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
+"""
+
+#-----------------------------------------------------------------------------
+#  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
+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, Term
+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.
+
+    Includes the following as properties: 
+
+    line
+      The original, raw line
+    
+    continue_prompt
+      Is this line a continuation in a sequence of multiline input?
+    
+    pre
+      The initial esc character or whitespace.
+    
+    pre_char
+      The escape character(s) in pre or the empty string if there isn't one.
+      Note that '!!' is a possible value for pre_char.  Otherwise it will
+      always be a single character.
+    
+    pre_whitespace
+      The leading whitespace from pre if it exists.  If there is a pre_char,
+      this is just ''.
+    
+    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.
+    
+    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.the_rest = split_user_input(line)
+
+        self.pre_char       = self.pre.strip()
+        if self.pre_char:
+            self.pre_whitespace = '' # No whitespace allowd before esc chars
+        else: 
+            self.pre_whitespace = self.pre
+
+        self._oinfo = None
+
+    def ofind(self, ip):
+        """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
+
+        Note: can cause state changes because of calling getattr, but should
+        only be run if autocall is on and if the line hasn't matched any
+        other, less dangerous handlers.
+
+        Does cache the results of the call, so can be called multiple times
+        without worrying about *further* damaging state.
+        """
+        if not self._oinfo:
+            self._oinfo = ip._ofind(self.ifun)
+        return self._oinfo
+
+    def __str__(self):                                                         
+        return "Lineinfo [%s|%s|%s]" %(self.pre,self.ifun,self.the_rest) 
+
+
+#-----------------------------------------------------------------------------
+# Main Prefilter manager
+#-----------------------------------------------------------------------------
+
+
+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.
+
+    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.
+    
+    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.
+
+    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.
+    """
+
+    multi_line_specials = CBool(True, config=True)
+
+    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]
+
+    #-------------------------------------------------------------------------
+    # 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)
+        
+        # the input history needs to track even empty lines
+        stripped = line.strip()
+
+        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)
+
+        # 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 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]
+
+    def transform(self, line, continue_prompt):
+        """Transform a line, returning the new one."""
+        return None
+
+    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.
+    
+        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
+
+
+class AutoMagicChecker(PrefilterChecker):
+
+    priority = Int(700, config=True)
+
+    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/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/core/tests/test_component.py

@@ -0,0 +1,214 b''
+#!/usr/bin/env python
+# encoding: utf-8
+"""
+Tests for IPython.core.component
+
+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
+#-----------------------------------------------------------------------------
+
+from unittest import TestCase
+
+from IPython.core.component import Component, ComponentError
+from IPython.utils.traitlets import (
+    TraitletError, Int, Float, Str
+)
+from IPython.config.loader import Config
+
+
+#-----------------------------------------------------------------------------
+# Test cases
+#-----------------------------------------------------------------------------
+
+
+class TestComponentMeta(TestCase):
+
+    def test_get_instances(self):
+        class BaseComponent(Component):
+            pass
+        c1 = BaseComponent(None)
+        c2 = BaseComponent(c1)
+        self.assertEquals(BaseComponent.get_instances(),[c1,c2])
+
+    def test_get_instances_subclass(self):
+        class MyComponent(Component):
+            pass
+        class MyOtherComponent(MyComponent):
+            pass
+        c1 = MyComponent(None)
+        c2 = MyOtherComponent(c1)
+        c3 = MyOtherComponent(c2)
+        self.assertEquals(MyComponent.get_instances(), [c1, c2, c3])
+        self.assertEquals(MyOtherComponent.get_instances(), [c2, c3])
+
+    def test_get_instances_root(self):
+        class MyComponent(Component):
+            pass
+        class MyOtherComponent(MyComponent):
+            pass
+        c1 = MyComponent(None)
+        c2 = MyOtherComponent(c1)
+        c3 = MyOtherComponent(c2)
+        c4 = MyComponent(None)
+        c5 = MyComponent(c4)
+        self.assertEquals(MyComponent.get_instances(root=c1), [c1, c2, c3])
+        self.assertEquals(MyComponent.get_instances(root=c4), [c4, c5])
+
+
+class TestComponent(TestCase):
+
+    def test_parent_child(self):
+        c1 = Component(None)
+        c2 = Component(c1)
+        c3 = Component(c1)
+        c4 = Component(c3)
+        self.assertEquals(c1.parent, None)
+        self.assertEquals(c2.parent, c1)
+        self.assertEquals(c3.parent, c1)
+        self.assertEquals(c4.parent, c3)
+        self.assertEquals(c1.children, [c2, c3])
+        self.assertEquals(c2.children, [])
+        self.assertEquals(c3.children, [c4])
+        self.assertEquals(c4.children, [])
+
+    def test_root(self):
+        c1 = Component(None)
+        c2 = Component(c1)
+        c3 = Component(c1)
+        c4 = Component(c3)
+        self.assertEquals(c1.root, c1.root)
+        self.assertEquals(c2.root, c1)
+        self.assertEquals(c3.root, c1)
+        self.assertEquals(c4.root, c1)
+
+    def test_change_parent(self):
+        c1 = Component(None)
+        c2 = Component(None)
+        c3 = Component(c1)
+        self.assertEquals(c3.root, c1)
+        self.assertEquals(c3.parent, c1)
+        self.assertEquals(c1.children,[c3])
+        c3.parent = c2
+        self.assertEquals(c3.root, c2)
+        self.assertEquals(c3.parent, c2)
+        self.assertEquals(c2.children,[c3])
+        self.assertEquals(c1.children,[])
+
+    def test_subclass_parent(self):
+        c1 = Component(None)
+        self.assertRaises(TraitletError, setattr, c1, 'parent', 10)
+
+        class MyComponent(Component):
+            pass
+        c1 = Component(None)
+        c2 = MyComponent(c1)
+        self.assertEquals(MyComponent.parent.this_class, Component)
+        self.assertEquals(c2.parent, c1)
+
+    def test_bad_root(self):
+        c1 = Component(None)
+        c2 = Component(None)
+        c3 = Component(None)
+        self.assertRaises(ComponentError, setattr, c1, 'root', c2)
+        c1.parent = c2
+        self.assertEquals(c1.root, c2)
+        self.assertRaises(ComponentError, setattr, c1, 'root', c3)
+
+
+class TestComponentConfig(TestCase):
+
+    def test_default(self):
+        c1 = Component(None)
+        c2 = Component(c1)
+        c3 = Component(c2)
+        self.assertEquals(c1.config, c2.config)
+        self.assertEquals(c2.config, c3.config)
+
+    def test_custom(self):
+        config = Config()
+        config.foo = 'foo'
+        config.bar = 'bar'
+        c1 = Component(None, config=config)
+        c2 = Component(c1)
+        c3 = Component(c2)
+        self.assertEquals(c1.config, config)
+        self.assertEquals(c2.config, config)
+        self.assertEquals(c3.config, config)
+        # Test that copies are not made
+        self.assert_(c1.config is config)
+        self.assert_(c2.config is config)
+        self.assert_(c3.config is config)
+        self.assert_(c1.config is c2.config)
+        self.assert_(c2.config is c3.config)
+        
+    def test_inheritance(self):
+        class MyComponent(Component):
+            a = Int(1, config=True)
+            b = Float(1.0, config=True)
+            c = Str('no config')
+        config = Config()
+        config.MyComponent.a = 2
+        config.MyComponent.b = 2.0
+        c1 = MyComponent(None, config=config)
+        c2 = MyComponent(c1)
+        self.assertEquals(c1.a, config.MyComponent.a)
+        self.assertEquals(c1.b, config.MyComponent.b)
+        self.assertEquals(c2.a, config.MyComponent.a)
+        self.assertEquals(c2.b, config.MyComponent.b)
+        c4 = MyComponent(c2, config=Config())
+        self.assertEquals(c4.a, 1)
+        self.assertEquals(c4.b, 1.0)
+
+    def test_parent(self):
+        class Foo(Component):
+            a = Int(0, config=True)
+            b = Str('nope', config=True)
+        class Bar(Foo):
+            b = Str('gotit', config=False)
+            c = Float(config=True)
+        config = Config()
+        config.Foo.a = 10
+        config.Foo.b = "wow"
+        config.Bar.b = 'later'
+        config.Bar.c = 100.0
+        f = Foo(None, config=config)
+        b = Bar(f)
+        self.assertEquals(f.a, 10)
+        self.assertEquals(f.b, 'wow')
+        self.assertEquals(b.b, 'gotit')
+        self.assertEquals(b.c, 100.0)
+
+
+class TestComponentName(TestCase):
+
+    def test_default(self):
+        class MyComponent(Component):
+            pass
+        c1 = Component(None)
+        c2 = MyComponent(None)
+        c3 = Component(c2)
+        self.assertNotEquals(c1.name, c2.name)
+        self.assertNotEquals(c1.name, c3.name)
+
+    def test_manual(self):
+        class MyComponent(Component):
+            pass
+        c1 = Component(None, name='foo')
+        c2 = MyComponent(None, name='bar')
+        c3 = Component(c2, name='bah')
+        self.assertEquals(c1.name, 'foo')
+        self.assertEquals(c2.name, 'bar')
+        self.assertEquals(c3.name, 'bah')

IPython/core/tests/test_imports.py

@@ -0,0 +1,62 b''
+#!/usr/bin/env python
+# encoding: utf-8
+
+def test_import_completer():
+    from IPython.core import completer
+
+def test_import_crashhandler():
+    from IPython.core import crashhandler
+
+def test_import_debugger():
+    from IPython.core import debugger
+
+def test_import_fakemodule():
+    from IPython.core import fakemodule
+
+def test_import_excolors():
+    from IPython.core import excolors
+
+def test_import_history():
+    from IPython.core import history
+
+def test_import_hooks():
+    from IPython.core import hooks
+
+def test_import_ipapi():
+    from IPython.core import ipapi
+
+def test_import_iplib():
+    from IPython.core import iplib
+
+def test_import_logger():
+    from IPython.core import logger
+
+def test_import_macro():
+    from IPython.core import macro
+
+def test_import_magic():
+    from IPython.core import magic
+
+def test_import_oinspect():
+    from IPython.core import oinspect
+
+def test_import_outputtrap():
+    from IPython.core import outputtrap
+
+def test_import_prefilter():
+    from IPython.core import prefilter
+
+def test_import_prompts():
+    from IPython.core import prompts
+
+def test_import_release():
+    from IPython.core import release
+
+def test_import_shadowns():
+    from IPython.core import shadowns
+
+def test_import_ultratb():
+    from IPython.core import ultratb
+
+def test_import_usage():
+    from IPython.core import usage

IPython/Shell.py

@@ -1,1246 +1,42 b''
-# -*- coding: utf-8 -*-
-"""IPython Shell classes.
+#!/usr/bin/env python
+# encoding: utf-8
+"""
+A backwards compatibility layer for IPython.Shell.
 
-All the matplotlib support code was co-developed with John Hunter,
-matplotlib's author.
+Previously, IPython had an IPython.Shell module.  IPython.Shell has been moved
+to IPython.core.shell and is being refactored.  This new module is provided
+for backwards compatability.  We strongly encourage everyone to start using
+the new code in IPython.core.shell.
 """
 
-#*****************************************************************************
-#       Copyright (C) 2001-2006 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.
-#*****************************************************************************
-
-# Code begins
-# Stdlib imports
-import __builtin__
-import __main__
-import Queue
-import inspect
-import os
-import sys
-import thread
-import threading
-import time
-
-from signal import signal, SIGINT
-
-try:
-    import ctypes
-    HAS_CTYPES = True
-except ImportError:
-    HAS_CTYPES = False
-
-# IPython imports
-import IPython
-from IPython import ultraTB, ipapi
-from IPython.Magic import Magic
-from IPython.genutils import Term,warn,error,flag_calls, ask_yes_no
-from IPython.iplib import InteractiveShell
-from IPython.ipmaker import make_IPython
-from IPython.ipstruct import Struct
-from IPython.testing import decorators as testdec
-
-# Globals
-# global flag to pass around information about Ctrl-C without exceptions
-KBINT = False
-
-# global flag to turn on/off Tk support.
-USE_TK = False
-
-# ID for the main thread, used for cross-thread exceptions
-MAIN_THREAD_ID = thread.get_ident()
-
-# Tag when runcode() is active, for exception handling
-CODE_RUN = None
-
-# Default timeout for waiting for multithreaded shells (in seconds)
-GUI_TIMEOUT = 10
-
-#-----------------------------------------------------------------------------
-# This class is trivial now, but I want to have it in to publish a clean
-# interface. Later when the internals are reorganized, code that uses this
-# shouldn't have to change.
-
-class IPShell:
-    """Create an IPython instance."""
-    
-    def __init__(self,argv=None,user_ns=None,user_global_ns=None,
-                 debug=1,shell_class=InteractiveShell):
-        self.IP = make_IPython(argv,user_ns=user_ns,
-                               user_global_ns=user_global_ns,
-                               debug=debug,shell_class=shell_class)
-
-    def mainloop(self,sys_exit=0,banner=None):
-        self.IP.mainloop(banner)
-        if sys_exit:
-            sys.exit()
-
-#-----------------------------------------------------------------------------
-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.shell.embedded_active = False
-        print "This embedded IPython will not reactivate anymore once you exit."
-    
-class IPShellEmbed:
-    """Allow embedding an IPython shell into a running program.
-
-    Instances of this class are callable, with the __call__ method being an
-    alias to the embed() method of an InteractiveShell instance.
-
-    Usage (see also the example-embed.py file for a running example):
-
-    ipshell = IPShellEmbed([argv,banner,exit_msg,rc_override])
-
-    - argv: list containing valid command-line options for IPython, as they
-    would appear in sys.argv[1:].
-
-    For example, the following command-line options:
-
-      $ ipython -prompt_in1 'Input <\\#>' -colors LightBG
-
-    would be passed in the argv list as:
-
-      ['-prompt_in1','Input <\\#>','-colors','LightBG']
-
-    - banner: string which gets printed every time the interpreter starts.
-
-    - exit_msg: string which gets printed every time the interpreter exits.
-
-    - rc_override: a dict or Struct of configuration options such as those
-    used by IPython. These options are read from your ~/.ipython/ipythonrc
-    file when the Shell object is created. Passing an explicit rc_override
-    dict with any options you want allows you to override those values at
-    creation time without having to modify the file. This way you can create
-    embeddable instances configured in any way you want without editing any
-    global files (thus keeping your interactive IPython configuration
-    unchanged).
-
-    Then the ipshell instance can be called anywhere inside your code:
-    
-    ipshell(header='') -> Opens up an IPython shell.
-
-    - header: string printed by the IPython shell upon startup. This can let
-    you know where in your code you are when dropping into the shell. Note
-    that 'banner' gets prepended to all calls, so header is used for
-    location-specific information.
-
-    For more details, see the __call__ method below.
-
-    When the IPython shell is exited with Ctrl-D, normal program execution
-    resumes.
-
-    This functionality was inspired by a posting on comp.lang.python by cmkl
-    <[e-mail]> on Dec. 06/01 concerning similar uses of pyrepl, and
-    by the IDL stop/continue commands."""
-
-    def __init__(self,argv=None,banner='',exit_msg=None,rc_override=None,
-                 user_ns=None):
-        """Note that argv here is a string, NOT a list."""
-        self.set_banner(banner)
-        self.set_exit_msg(exit_msg)
-        self.set_dummy_mode(0)
-
-        # sys.displayhook is a global, we need to save the user's original
-        # Don't rely on __displayhook__, as the user may have changed that.
-        self.sys_displayhook_ori = sys.displayhook
-
-        # save readline completer status
-        try:
-            #print 'Save completer',sys.ipcompleter  # dbg
-            self.sys_ipcompleter_ori = sys.ipcompleter
-        except:
-            pass # not nested with IPython
-        
-        self.IP = make_IPython(argv,rc_override=rc_override,
-                               embedded=True,
-                               user_ns=user_ns)
-
-        ip = ipapi.IPApi(self.IP)
-        ip.expose_magic("kill_embedded",kill_embedded)
-
-        # copy our own displayhook also
-        self.sys_displayhook_embed = sys.displayhook
-        # and leave the system's display hook clean
-        sys.displayhook = self.sys_displayhook_ori
-        # don't use the ipython crash handler so that user exceptions aren't
-        # trapped
-        sys.excepthook = ultraTB.FormattedTB(color_scheme = self.IP.rc.colors,
-                                             mode = self.IP.rc.xmode,
-                                             call_pdb = self.IP.rc.pdb)
-        self.restore_system_completer()
-
-    def restore_system_completer(self):
-        """Restores the readline completer which was in place.
-
-        This allows embedded IPython within IPython not to disrupt the
-        parent's completion.
-        """
-        
-        try:
-            self.IP.readline.set_completer(self.sys_ipcompleter_ori)
-            sys.ipcompleter = self.sys_ipcompleter_ori
-        except:
-            pass
-
-    def __call__(self,header='',local_ns=None,global_ns=None,dummy=None):
-        """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.IP.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.IP.exit_now = False
-
-        # Allow the dummy parameter to override the global __dummy_mode
-        if dummy or (dummy != 0 and self.__dummy_mode):
-            return
-
-        # Set global subsystems (display,completions) to our values
-        sys.displayhook = self.sys_displayhook_embed
-        if self.IP.has_readline:
-            self.IP.set_completer()
-
-        if self.banner and header:
-            format = '%s\n%s\n'
-        else:
-            format = '%s%s\n'
-        banner =  format % (self.banner,header)
-
-        # 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.IP.embed_mainloop(banner,local_ns,global_ns,stack_depth=1)
-
-        if self.exit_msg:
-            print self.exit_msg
-            
-        # Restore global systems (display, completion)
-        sys.displayhook = self.sys_displayhook_ori
-        self.restore_system_completer()
-    
-    def set_dummy_mode(self,dummy):
-        """Sets the embeddable shell's dummy mode parameter.
-
-        set_dummy_mode(dummy): dummy = 0 or 1.
-
-        This parameter is persistent and makes calls to the embeddable shell
-        silently return without performing any action. This allows you to
-        globally activate or deactivate a shell you're using with a single call.
-
-        If you need to manually"""
-
-        if dummy not in [0,1,False,True]:
-            raise ValueError,'dummy parameter must be boolean'
-        self.__dummy_mode = dummy
-
-    def get_dummy_mode(self):
-        """Return the current value of the dummy mode parameter.
-        """
-        return self.__dummy_mode
-    
-    def set_banner(self,banner):
-        """Sets the global banner.
-
-        This banner gets prepended to every header printed when the shell
-        instance is called."""
-
-        self.banner = banner
-
-    def set_exit_msg(self,exit_msg):
-        """Sets the global exit_msg.
-
-        This exit message gets printed upon exiting every time the embedded
-        shell is called. It is None by default. """
-
-        self.exit_msg = exit_msg
-
-#-----------------------------------------------------------------------------
-if HAS_CTYPES:
-    #  Add async exception support.  Trick taken from:
-    # http://sebulba.wikispaces.com/recipe+thread2
-    def _async_raise(tid, exctype):
-        """raises the exception, performs cleanup if needed"""
-        if not inspect.isclass(exctype):
-            raise TypeError("Only types can be raised (not instances)")
-        # Explicit cast to c_long is necessary for 64-bit support:
-        # See https://bugs.launchpad.net/ipython/+bug/237073
-        res = ctypes.pythonapi.PyThreadState_SetAsyncExc(ctypes.c_long(tid),
-                                                         ctypes.py_object(exctype))
-        if res == 0:
-            raise ValueError("invalid thread id")
-        elif res != 1:
-            # If it returns a number greater than one, you're in trouble, 
-            # and you should call it again with exc=NULL to revert the effect
-            ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, 0)
-            raise SystemError("PyThreadState_SetAsyncExc failed")
-
-    def sigint_handler(signum,stack_frame):
-        """Sigint handler for threaded apps.
-
-        This is a horrible hack to pass information about SIGINT _without_
-        using exceptions, since I haven't been able to properly manage
-        cross-thread exceptions in GTK/WX.  In fact, I don't think it can be
-        done (or at least that's my understanding from a c.l.py thread where
-        this was discussed)."""
-
-        global KBINT
-
-        if CODE_RUN:
-            _async_raise(MAIN_THREAD_ID,KeyboardInterrupt)
-        else:
-            KBINT = True
-            print '\nKeyboardInterrupt - Press <Enter> to continue.',
-            Term.cout.flush()
-
-else:
-    def sigint_handler(signum,stack_frame):
-        """Sigint handler for threaded apps.
-
-        This is a horrible hack to pass information about SIGINT _without_
-        using exceptions, since I haven't been able to properly manage
-        cross-thread exceptions in GTK/WX.  In fact, I don't think it can be
-        done (or at least that's my understanding from a c.l.py thread where
-        this was discussed)."""
-
-        global KBINT
-
-        print '\nKeyboardInterrupt - Press <Enter> to continue.',
-        Term.cout.flush()
-        # Set global flag so that runsource can know that Ctrl-C was hit
-        KBINT = True
-
-
-class MTInteractiveShell(InteractiveShell):
-    """Simple multi-threaded shell."""
-
-    # Threading strategy taken from:
-    # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/65109, by Brian
-    # McErlean and John Finlay.  Modified with corrections by Antoon Pardon,
-    # from the pygtk mailing list, to avoid lockups with system calls.
-
-    # class attribute to indicate whether the class supports threads or not.
-    # Subclasses with thread support should override this as needed.
-    isthreaded = True
-
-    def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
-                 user_ns=None,user_global_ns=None,banner2='',
-                 gui_timeout=GUI_TIMEOUT,**kw):
-        """Similar to the normal InteractiveShell, but with threading control"""
-        
-        InteractiveShell.__init__(self,name,usage,rc,user_ns,
-                                  user_global_ns,banner2)
-
-        # Timeout we wait for GUI thread
-        self.gui_timeout = gui_timeout
-
-        # A queue to hold the code to be executed. 
-        self.code_queue = Queue.Queue()
-
-        # Stuff to do at closing time
-        self._kill = None
-        on_kill = kw.get('on_kill', [])
-        # Check that all things to kill are callable:
-        for t in on_kill:
-            if not callable(t):
-                raise TypeError,'on_kill must be a list of callables'
-        self.on_kill = on_kill
-        # thread identity of the "worker thread" (that may execute code directly)
-        self.worker_ident = None
-        
-    def runsource(self, source, filename="<input>", symbol="single"):
-        """Compile and run some source in the interpreter.
-
-        Modified version of code.py's runsource(), to handle threading issues.
-        See the original for full docstring details."""
-                
-        global KBINT
-        
-        # If Ctrl-C was typed, we reset the flag and return right away
-        if KBINT:
-            KBINT = False
-            return False
-
-        if self._kill:
-            # can't queue new code if we are being killed
-            return True
-        
-        try:
-            code = self.compile(source, filename, symbol)
-        except (OverflowError, SyntaxError, ValueError):
-            # Case 1
-            self.showsyntaxerror(filename)
-            return False
-
-        if code is None:
-            # Case 2
-            return True
-
-        # shortcut - if we are in worker thread, or the worker thread is not
-        # running, execute directly (to allow recursion and prevent deadlock if
-        # code is run early in IPython construction)
-        
-        if (self.worker_ident is None
-            or self.worker_ident == thread.get_ident() ):
-            InteractiveShell.runcode(self,code)
-            return False
-
-        # Case 3
-        # Store code in queue, so the execution thread can handle it.
-
-        completed_ev, received_ev = threading.Event(), threading.Event() 
-        
-        self.code_queue.put((code,completed_ev, received_ev))
-        # first make sure the message was received, with timeout
-        received_ev.wait(self.gui_timeout)
-        if not received_ev.isSet():
-            # the mainloop is dead, start executing code directly
-            print "Warning: Timeout for mainloop thread exceeded"
-            print "switching to nonthreaded mode (until mainloop wakes up again)"
-            self.worker_ident = None
-        else:
-            completed_ev.wait()
-        return False
-
-    def runcode(self):
-        """Execute a code object.
-
-        Multithreaded wrapper around IPython's runcode()."""
-        
-        global CODE_RUN
-        
-        # we are in worker thread, stash out the id for runsource() 
-        self.worker_ident = thread.get_ident()
-
-        if self._kill:
-            print >>Term.cout, 'Closing threads...',
-            Term.cout.flush()
-            for tokill in self.on_kill:
-                tokill()
-            print >>Term.cout, 'Done.'
-            # allow kill() to return
-            self._kill.set()
-            return True
-
-        # Install sigint handler.  We do it every time to ensure that if user
-        # code modifies it, we restore our own handling.
-        try:
-            signal(SIGINT,sigint_handler)
-        except SystemError:
-            # This happens under Windows, which seems to have all sorts
-            # of problems with signal handling.  Oh well...
-            pass
-
-        # Flush queue of pending code by calling the run methood of the parent
-        # class with all items which may be in the queue.
-        code_to_run = None
-        while 1:
-            try:
-                code_to_run, completed_ev, received_ev = self.code_queue.get_nowait()                
-            except Queue.Empty:
-                break
-            received_ev.set()
-            
-            # Exceptions need to be raised differently depending on which
-            # thread is active.  This convoluted try/except is only there to
-            # protect against asynchronous exceptions, to ensure that a KBINT
-            # at the wrong time doesn't deadlock everything.  The global
-            # CODE_TO_RUN is set to true/false as close as possible to the
-            # runcode() call, so that the KBINT handler is correctly informed.
-            try:
-                try:
-                   CODE_RUN = True
-                   InteractiveShell.runcode(self,code_to_run)
-                except KeyboardInterrupt:
-                   print "Keyboard interrupted in mainloop"
-                   while not self.code_queue.empty():
-                      code, ev1,ev2 = self.code_queue.get_nowait()
-                      ev1.set()
-                      ev2.set()                      
-                   break
-            finally:
-                CODE_RUN = False
-                # allow runsource() return from wait
-                completed_ev.set()
-                
-        
-        # This MUST return true for gtk threading to work
-        return True
-
-    def kill(self):
-        """Kill the thread, returning when it has been shut down."""
-        self._kill = threading.Event()
-        self._kill.wait()
-
-class MatplotlibShellBase:
-    """Mixin class to provide the necessary modifications to regular IPython
-    shell classes for matplotlib support.
-
-    Given Python's MRO, this should be used as the FIRST class in the
-    inheritance hierarchy, so that it overrides the relevant methods."""
-    
-    def _matplotlib_config(self,name,user_ns,user_global_ns=None):
-        """Return items needed to setup the user's shell with matplotlib"""
-
-        # Initialize matplotlib to interactive mode always
-        import matplotlib
-        from matplotlib import backends
-        matplotlib.interactive(True)
-
-        def use(arg):
-            """IPython wrapper for matplotlib's backend switcher.
-
-            In interactive use, we can not allow switching to a different
-            interactive backend, since thread conflicts will most likely crash
-            the python interpreter.  This routine does a safety check first,
-            and refuses to perform a dangerous switch.  It still allows
-            switching to non-interactive backends."""
-
-            if arg in backends.interactive_bk and arg != self.mpl_backend:
-                m=('invalid matplotlib backend switch.\n'
-                   'This script attempted to switch to the interactive '
-                   'backend: `%s`\n'
-                   'Your current choice of interactive backend is: `%s`\n\n'
-                   'Switching interactive matplotlib backends at runtime\n'
-                   'would crash the python interpreter, '
-                   'and IPython has blocked it.\n\n'
-                   'You need to either change your choice of matplotlib backend\n'
-                   'by editing your .matplotlibrc file, or run this script as a \n'
-                   'standalone file from the command line, not using IPython.\n' %
-                   (arg,self.mpl_backend) )
-                raise RuntimeError, m
-            else:
-                self.mpl_use(arg)
-                self.mpl_use._called = True
-        
-        self.matplotlib = matplotlib
-        self.mpl_backend = matplotlib.rcParams['backend']
-
-        # we also need to block switching of interactive backends by use()
-        self.mpl_use = matplotlib.use
-        self.mpl_use._called = False
-        # overwrite the original matplotlib.use with our wrapper
-        matplotlib.use = use
-
-        # This must be imported last in the matplotlib series, after
-        # backend/interactivity choices have been made
-        import matplotlib.pylab as pylab
-        self.pylab = pylab
-
-        self.pylab.show._needmain = False
-        # We need to detect at runtime whether show() is called by the user.
-        # For this, we wrap it into a decorator which adds a 'called' flag.
-        self.pylab.draw_if_interactive = flag_calls(self.pylab.draw_if_interactive)
-
-        # Build a user namespace initialized with matplotlib/matlab features.
-        user_ns, user_global_ns = IPython.ipapi.make_user_namespaces(user_ns,
-            user_global_ns)
-
-        # Import numpy as np/pyplot as plt are conventions we're trying to
-        # somewhat standardize on.  Making them available to users by default
-        # will greatly help this. 
-        exec ("import numpy\n"
-              "import numpy as np\n"
-              "import matplotlib\n"
-              "import matplotlib.pylab as pylab\n"
-              "try:\n"
-              "    import matplotlib.pyplot as plt\n"
-              "except ImportError:\n"
-              "    pass\n"
-              ) in user_ns
-        
-        # Build matplotlib info banner
-        b="""
-  Welcome to pylab, a matplotlib-based Python environment.
-  For more information, type 'help(pylab)'.
-"""
-        return user_ns,user_global_ns,b
-
-    def mplot_exec(self,fname,*where,**kw):
-        """Execute a matplotlib script.
-
-        This is a call to execfile(), but wrapped in safeties to properly
-        handle interactive rendering and backend switching."""
-
-        #print '*** Matplotlib runner ***' # dbg
-        # turn off rendering until end of script
-        isInteractive = self.matplotlib.rcParams['interactive']
-        self.matplotlib.interactive(False)
-        self.safe_execfile(fname,*where,**kw)
-        self.matplotlib.interactive(isInteractive)
-        # make rendering call now, if the user tried to do it
-        if self.pylab.draw_if_interactive.called:
-            self.pylab.draw()
-            self.pylab.draw_if_interactive.called = False
-                
-        # if a backend switch was performed, reverse it now
-        if self.mpl_use._called:
-            self.matplotlib.rcParams['backend'] = self.mpl_backend
-
-    @testdec.skip_doctest
-    def magic_run(self,parameter_s=''):
-        Magic.magic_run(self,parameter_s,runner=self.mplot_exec)
-
-    # Fix the docstring so users see the original as well
-    magic_run.__doc__ = "%s\n%s" % (Magic.magic_run.__doc__,
-                                    "\n        *** Modified %run for Matplotlib,"
-                                    " with proper interactive handling ***")
-
-# Now we provide 2 versions of a matplotlib-aware IPython base shells, single
-# and multithreaded.  Note that these are meant for internal use, the IPShell*
-# classes below are the ones meant for public consumption.
-
-class MatplotlibShell(MatplotlibShellBase,InteractiveShell):
-    """Single-threaded shell with matplotlib support."""
-
-    def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
-                 user_ns=None,user_global_ns=None,**kw):
-        user_ns,user_global_ns,b2 = self._matplotlib_config(name,user_ns,user_global_ns)
-        InteractiveShell.__init__(self,name,usage,rc,user_ns,user_global_ns,
-                                  banner2=b2,**kw)
-
-class MatplotlibMTShell(MatplotlibShellBase,MTInteractiveShell):
-    """Multi-threaded shell with matplotlib support."""
-
-    def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
-                 user_ns=None,user_global_ns=None, **kw):
-        user_ns,user_global_ns,b2 = self._matplotlib_config(name,user_ns,user_global_ns)
-        MTInteractiveShell.__init__(self,name,usage,rc,user_ns,user_global_ns,
-                                    banner2=b2,**kw)
-
-#-----------------------------------------------------------------------------
-# Utility functions for the different GUI enabled IPShell* classes.
-
-def get_tk():
-    """Tries to import Tkinter and returns a withdrawn Tkinter root
-    window.  If Tkinter is already imported or not available, this
-    returns None.  This function calls `hijack_tk` underneath.
-    """
-    if not USE_TK or sys.modules.has_key('Tkinter'):
-        return None
-    else:
-        try:
-            import Tkinter
-        except ImportError:
-            return None
-        else:
-            hijack_tk()
-            r = Tkinter.Tk()
-            r.withdraw()
-            return r
-
-def hijack_tk():
-    """Modifies Tkinter's mainloop with a dummy so when a module calls
-    mainloop, it does not block.
-
-    """
-    def misc_mainloop(self, n=0):
-        pass
-    def tkinter_mainloop(n=0):
-        pass
-    
-    import Tkinter
-    Tkinter.Misc.mainloop = misc_mainloop
-    Tkinter.mainloop = tkinter_mainloop
-
-def update_tk(tk):
-    """Updates the Tkinter event loop.  This is typically called from
-    the respective WX or GTK mainloops.
-    """    
-    if tk:
-        tk.update()
-
-def hijack_wx():
-    """Modifies wxPython's MainLoop with a dummy so user code does not
-    block IPython.  The hijacked mainloop function is returned.
-    """    
-    def dummy_mainloop(*args, **kw):
-        pass
-
-    try:
-        import wx
-    except ImportError:
-        # For very old versions of WX
-        import wxPython as wx
-        
-    ver = wx.__version__
-    orig_mainloop = None
-    if ver[:3] >= '2.5':
-        import wx
-        if hasattr(wx, '_core_'): core = getattr(wx, '_core_')
-        elif hasattr(wx, '_core'): core = getattr(wx, '_core')
-        else: raise AttributeError('Could not find wx core module')
-        orig_mainloop = core.PyApp_MainLoop
-        core.PyApp_MainLoop = dummy_mainloop
-    elif ver[:3] == '2.4':
-        orig_mainloop = wx.wxc.wxPyApp_MainLoop
-        wx.wxc.wxPyApp_MainLoop = dummy_mainloop
-    else:
-        warn("Unable to find either wxPython version 2.4 or >= 2.5.")
-    return orig_mainloop
-
-def hijack_gtk():
-    """Modifies pyGTK's mainloop with a dummy so user code does not
-    block IPython.  This function returns the original `gtk.mainloop`
-    function that has been hijacked.
-    """    
-    def dummy_mainloop(*args, **kw):
-        pass
-    import gtk
-    if gtk.pygtk_version >= (2,4,0): orig_mainloop = gtk.main
-    else:                            orig_mainloop = gtk.mainloop
-    gtk.mainloop = dummy_mainloop
-    gtk.main = dummy_mainloop
-    return orig_mainloop
-
-def hijack_qt():
-    """Modifies PyQt's mainloop with a dummy so user code does not 
-    block IPython.  This function returns the original 
-    `qt.qApp.exec_loop` function that has been hijacked.
-    """    
-    def dummy_mainloop(*args, **kw):
-        pass
-    import qt
-    orig_mainloop = qt.qApp.exec_loop
-    qt.qApp.exec_loop = dummy_mainloop
-    qt.QApplication.exec_loop = dummy_mainloop
-    return orig_mainloop
-
-def hijack_qt4():
-    """Modifies PyQt4's mainloop with a dummy so user code does not
-    block IPython.  This function returns the original 
-    `QtGui.qApp.exec_` function that has been hijacked.
-    """    
-    def dummy_mainloop(*args, **kw):
-        pass
-    from PyQt4 import QtGui, QtCore
-    orig_mainloop = QtGui.qApp.exec_
-    QtGui.qApp.exec_ = dummy_mainloop
-    QtGui.QApplication.exec_ = dummy_mainloop
-    QtCore.QCoreApplication.exec_ = dummy_mainloop
-    return orig_mainloop
-
 #-----------------------------------------------------------------------------
-# The IPShell* classes below are the ones meant to be run by external code as
-# IPython instances.  Note that unless a specific threading strategy is
-# desired, the factory function start() below should be used instead (it
-# selects the proper threaded class).
-
-class IPThread(threading.Thread):
-    def run(self):
-        self.IP.mainloop(self._banner)
-        self.IP.kill()
-
-class IPShellGTK(IPThread):
-    """Run a gtk mainloop() in a separate thread.
-    
-    Python commands can be passed to the thread where they will be executed.
-    This is implemented by periodically checking for passed code using a
-    GTK timeout callback."""
-    
-    TIMEOUT = 100 # Millisecond interval between timeouts.
-
-    def __init__(self,argv=None,user_ns=None,user_global_ns=None,
-                 debug=1,shell_class=MTInteractiveShell):
-
-        import gtk
-        # Check for set_interactive, coming up in new pygtk.
-        # Disable it so that this code works, but notify 
-        # the user that he has a better option as well.
-        # XXX TODO better support when set_interactive is released
-        try:
-            gtk.set_interactive(False)
-            print "Your PyGtk has set_interactive(), so you can use the"
-            print "more stable single-threaded Gtk mode."
-            print "See https://bugs.launchpad.net/ipython/+bug/270856"
-        except AttributeError:
-            pass
-        
-        self.gtk = gtk
-        self.gtk_mainloop = hijack_gtk()
-
-        # Allows us to use both Tk and GTK.
-        self.tk = get_tk()
-        
-        if gtk.pygtk_version >= (2,4,0): mainquit = self.gtk.main_quit
-        else:                            mainquit = self.gtk.mainquit
-
-        self.IP = make_IPython(argv,user_ns=user_ns,
-                               user_global_ns=user_global_ns,
-                               debug=debug,
-                               shell_class=shell_class,
-                               on_kill=[mainquit])
-
-        # HACK: slot for banner in self; it will be passed to the mainloop
-        # method only and .run() needs it.  The actual value will be set by
-        # .mainloop().
-        self._banner = None 
-
-        threading.Thread.__init__(self)
-
-    def mainloop(self,sys_exit=0,banner=None):
-
-        self._banner = banner
-        
-        if self.gtk.pygtk_version >= (2,4,0):
-            import gobject
-            gobject.idle_add(self.on_timer)
-        else:
-            self.gtk.idle_add(self.on_timer)
-
-        if sys.platform != 'win32':
-            try:
-                if self.gtk.gtk_version[0] >= 2:
-                    self.gtk.gdk.threads_init()
-            except AttributeError:
-                pass
-            except RuntimeError:
-                error('Your pyGTK likely has not been compiled with '
-                      'threading support.\n'
-                      'The exception printout is below.\n'
-                      'You can either rebuild pyGTK with threads, or '
-                      'try using \n'
-                      'matplotlib with a different backend (like Tk or WX).\n'
-                      'Note that matplotlib will most likely not work in its '
-                      'current state!')
-                self.IP.InteractiveTB()
-
-        self.start()
-        self.gtk.gdk.threads_enter()
-        self.gtk_mainloop()
-        self.gtk.gdk.threads_leave()
-        self.join()
-
-    def on_timer(self):
-        """Called when GTK is idle.
-
-        Must return True always, otherwise GTK stops calling it"""
-        
-        update_tk(self.tk)
-        self.IP.runcode()
-        time.sleep(0.01)
-        return True
-
-
-class IPShellWX(IPThread):
-    """Run a wx mainloop() in a separate thread.
-    
-    Python commands can be passed to the thread where they will be executed.
-    This is implemented by periodically checking for passed code using a
-    GTK timeout callback."""
-    
-    TIMEOUT = 100 # Millisecond interval between timeouts.
-
-    def __init__(self,argv=None,user_ns=None,user_global_ns=None,
-                 debug=1,shell_class=MTInteractiveShell):
-
-        self.IP = make_IPython(argv,user_ns=user_ns,
-                               user_global_ns=user_global_ns,
-                               debug=debug,
-                               shell_class=shell_class,
-                               on_kill=[self.wxexit])
-
-        wantedwxversion=self.IP.rc.wxversion
-        if wantedwxversion!="0":
-            try:
-                import wxversion
-            except ImportError:
-                error('The wxversion module is needed for WX version selection')
-            else:
-                try:
-                    wxversion.select(wantedwxversion)
-                except:
-                    self.IP.InteractiveTB()
-                    error('Requested wxPython version %s could not be loaded' %
-                                                               wantedwxversion)
-
-        import wx
-
-        threading.Thread.__init__(self)
-        self.wx = wx
-        self.wx_mainloop = hijack_wx()
-
-        # Allows us to use both Tk and GTK.
-        self.tk = get_tk()
-        
-        # HACK: slot for banner in self; it will be passed to the mainloop
-        # method only and .run() needs it.  The actual value will be set by
-        # .mainloop().
-        self._banner = None 
-
-        self.app = None
-
-    def wxexit(self, *args):
-        if self.app is not None:
-            self.app.agent.timer.Stop()
-            self.app.ExitMainLoop()
-
-    def mainloop(self,sys_exit=0,banner=None):
-
-        self._banner = banner
-        
-        self.start()
-
-        class TimerAgent(self.wx.MiniFrame):
-            wx = self.wx
-            IP = self.IP
-            tk = self.tk
-            def __init__(self, parent, interval):
-                style = self.wx.DEFAULT_FRAME_STYLE | self.wx.TINY_CAPTION_HORIZ
-                self.wx.MiniFrame.__init__(self, parent, -1, ' ', pos=(200, 200),
-                                             size=(100, 100),style=style)
-                self.Show(False)
-                self.interval = interval
-                self.timerId = self.wx.NewId()                                
-
-            def StartWork(self):
-                self.timer = self.wx.Timer(self, self.timerId)
-                self.wx.EVT_TIMER(self,  self.timerId, self.OnTimer)
-                self.timer.Start(self.interval)
-
-            def OnTimer(self, event):
-                update_tk(self.tk)
-                self.IP.runcode()
-
-        class App(self.wx.App):
-            wx = self.wx
-            TIMEOUT = self.TIMEOUT
-            def OnInit(self):
-                'Create the main window and insert the custom frame'
-                self.agent = TimerAgent(None, self.TIMEOUT)
-                self.agent.Show(False)
-                self.agent.StartWork()
-                return True
-
-        self.app = App(redirect=False)
-        self.wx_mainloop(self.app)
-        self.join()
-
 
-class IPShellQt(IPThread):
-    """Run a Qt event loop in a separate thread.
+from warnings import warn
     
-    Python commands can be passed to the thread where they will be executed.
-    This is implemented by periodically checking for passed code using a
-    Qt timer / slot."""
+msg = """
+This module (IPython.Shell) is deprecated.  The classes that were in this
+module have been replaced by:
     
-    TIMEOUT = 100 # Millisecond interval between timeouts.
+IPShell->IPython.core.iplib.InteractiveShell
+IPShellEmbed->IPython.core.embed.InteractiveShellEmbed
 
-    def __init__(self, argv=None, user_ns=None, user_global_ns=None,
-                 debug=0, shell_class=MTInteractiveShell):
-
-        import qt
-
-        self.exec_loop = hijack_qt()
-
-        # Allows us to use both Tk and QT.
-        self.tk = get_tk()
-
-        self.IP = make_IPython(argv,
-                               user_ns=user_ns,
-                               user_global_ns=user_global_ns,
-                               debug=debug,
-                               shell_class=shell_class,
-                               on_kill=[qt.qApp.exit])
-
-        # HACK: slot for banner in self; it will be passed to the mainloop
-        # method only and .run() needs it.  The actual value will be set by
-        # .mainloop().
-        self._banner = None 
-        
-        threading.Thread.__init__(self)
-
-    def mainloop(self, sys_exit=0, banner=None):
-
-        import qt
-
-        self._banner = banner
-
-        if qt.QApplication.startingUp():
-            a = qt.QApplication(sys.argv)
-
-        self.timer = qt.QTimer()
-        qt.QObject.connect(self.timer,
-                           qt.SIGNAL('timeout()'),
-                           self.on_timer)
-
-        self.start()
-        self.timer.start(self.TIMEOUT, True)
-        while True:
-            if self.IP._kill: break
-            self.exec_loop()
-        self.join()
-
-    def on_timer(self):
-        update_tk(self.tk)
-        result = self.IP.runcode()
-        self.timer.start(self.TIMEOUT, True)
-        return result
-
-
-class IPShellQt4(IPThread):
-    """Run a Qt event loop in a separate thread.
-
-    Python commands can be passed to the thread where they will be executed.
-    This is implemented by periodically checking for passed code using a
-    Qt timer / slot."""
-
-    TIMEOUT = 100 # Millisecond interval between timeouts.
-
-    def __init__(self, argv=None, user_ns=None, user_global_ns=None,
-                 debug=0, shell_class=MTInteractiveShell):
-
-        from PyQt4 import QtCore, QtGui
-
-        try:
-            # present in PyQt4-4.2.1 or later
-            QtCore.pyqtRemoveInputHook()
-        except AttributeError:
-            pass
-
-        if QtCore.PYQT_VERSION_STR == '4.3':
-            warn('''PyQt4 version 4.3 detected.
-If you experience repeated threading warnings, please update PyQt4.
-''')
-
-        self.exec_ = hijack_qt4()
-
-        # Allows us to use both Tk and QT.
-        self.tk = get_tk()
-
-        self.IP = make_IPython(argv,
-                               user_ns=user_ns,
-                               user_global_ns=user_global_ns,
-                               debug=debug,
-                               shell_class=shell_class,
-                               on_kill=[QtGui.qApp.exit])
-
-        # HACK: slot for banner in self; it will be passed to the mainloop
-        # method only and .run() needs it.  The actual value will be set by
-        # .mainloop().
-        self._banner = None
-
-        threading.Thread.__init__(self)
-
-    def mainloop(self, sys_exit=0, banner=None):
-
-        from PyQt4 import QtCore, QtGui
-
-        self._banner = banner
-
-        if QtGui.QApplication.startingUp():
-            a = QtGui.QApplication(sys.argv)
-
-        self.timer = QtCore.QTimer()
-        QtCore.QObject.connect(self.timer,
-                               QtCore.SIGNAL('timeout()'),
-                               self.on_timer)
-
-        self.start()
-        self.timer.start(self.TIMEOUT)
-        while True:
-            if self.IP._kill: break
-            self.exec_()
-        self.join()
-
-    def on_timer(self):
-        update_tk(self.tk)
-        result = self.IP.runcode()
-        self.timer.start(self.TIMEOUT)
-        return result
-
-
-# A set of matplotlib public IPython shell classes, for single-threaded (Tk*
-# and FLTK*) and multithreaded (GTK*, WX* and Qt*) backends to use.
-def _load_pylab(user_ns):
-    """Allow users to disable pulling all of pylab into the top-level
-    namespace.
-
-    This little utility must be called AFTER the actual ipython instance is
-    running, since only then will the options file have been fully parsed."""
-    
-    ip = IPython.ipapi.get()
-    if ip.options.pylab_import_all:
-        ip.ex("from matplotlib.pylab import *")
-        ip.IP.user_config_ns.update(ip.user_ns)
-        
-
-class IPShellMatplotlib(IPShell):
-    """Subclass IPShell with MatplotlibShell as the internal shell.
-
-    Single-threaded class, meant for the Tk* and FLTK* backends.
-
-    Having this on a separate class simplifies the external driver code."""
-    
-    def __init__(self,argv=None,user_ns=None,user_global_ns=None,debug=1):
-        IPShell.__init__(self,argv,user_ns,user_global_ns,debug,
-                         shell_class=MatplotlibShell)
-        _load_pylab(self.IP.user_ns)
-
-class IPShellMatplotlibGTK(IPShellGTK):
-    """Subclass IPShellGTK with MatplotlibMTShell as the internal shell.
-
-    Multi-threaded class, meant for the GTK* backends."""
-    
-    def __init__(self,argv=None,user_ns=None,user_global_ns=None,debug=1):
-        IPShellGTK.__init__(self,argv,user_ns,user_global_ns,debug,
-                            shell_class=MatplotlibMTShell)
-        _load_pylab(self.IP.user_ns)
-
-class IPShellMatplotlibWX(IPShellWX):
-    """Subclass IPShellWX with MatplotlibMTShell as the internal shell.
-
-    Multi-threaded class, meant for the WX* backends."""
-    
-    def __init__(self,argv=None,user_ns=None,user_global_ns=None,debug=1):
-        IPShellWX.__init__(self,argv,user_ns,user_global_ns,debug,
-                           shell_class=MatplotlibMTShell)
-        _load_pylab(self.IP.user_ns)
-
-class IPShellMatplotlibQt(IPShellQt):
-    """Subclass IPShellQt with MatplotlibMTShell as the internal shell.
-
-    Multi-threaded class, meant for the Qt* backends."""
-    
-    def __init__(self,argv=None,user_ns=None,user_global_ns=None,debug=1):
-        IPShellQt.__init__(self,argv,user_ns,user_global_ns,debug,
-                           shell_class=MatplotlibMTShell)
-        _load_pylab(self.IP.user_ns)
-
-class IPShellMatplotlibQt4(IPShellQt4):
-    """Subclass IPShellQt4 with MatplotlibMTShell as the internal shell.
-
-    Multi-threaded class, meant for the Qt4* backends."""
-
-    def __init__(self,argv=None,user_ns=None,user_global_ns=None,debug=1):
-        IPShellQt4.__init__(self,argv,user_ns,user_global_ns,debug,
-                           shell_class=MatplotlibMTShell)
-        _load_pylab(self.IP.user_ns)
-
-#-----------------------------------------------------------------------------
-# Factory functions to actually start the proper thread-aware shell
-
-def _select_shell(argv):
-    """Select a shell from the given argv vector.
-
-    This function implements the threading selection policy, allowing runtime
-    control of the threading mode, both for general users and for matplotlib.
-
-    Return:
-      Shell class to be instantiated for runtime operation.
+Please migrate your code to use these classes instead.
     """
     
-    global USE_TK
-
-    mpl_shell = {'gthread' : IPShellMatplotlibGTK,
-                 'wthread' : IPShellMatplotlibWX,
-                 'qthread' : IPShellMatplotlibQt,
-                 'q4thread' : IPShellMatplotlibQt4,
-                 'tkthread' : IPShellMatplotlib,  # Tk is built-in
-                 }
-
-    th_shell = {'gthread' : IPShellGTK,
-                'wthread' : IPShellWX,
-                'qthread' : IPShellQt,
-                'q4thread' : IPShellQt4,
-                'tkthread' : IPShell, # Tk is built-in
-                }
-
-    backends = {'gthread' : 'GTKAgg',
-                'wthread' : 'WXAgg',
-                'qthread' : 'QtAgg',
-                'q4thread' :'Qt4Agg',
-                'tkthread' :'TkAgg',
-                }
-
-    all_opts = set(['tk','pylab','gthread','qthread','q4thread','wthread',
-                    'tkthread'])
-    user_opts = set([s.replace('-','') for s in argv[:3]])
-    special_opts = user_opts & all_opts            
+warn(msg, category=DeprecationWarning, stacklevel=1)
 
-    if 'tk' in special_opts:
-        USE_TK = True
-        special_opts.remove('tk')
+from IPython.core.iplib import InteractiveShell as IPShell
+from IPython.core.embed import InteractiveShellEmbed as IPShellEmbed
 
-    if 'pylab' in special_opts:
-
-        try:
-            import matplotlib
-        except ImportError:
-            error('matplotlib could NOT be imported!  Starting normal IPython.')
-            return IPShell
-        
-        special_opts.remove('pylab')
-        # If there's any option left, it means the user wants to force the
-        # threading backend, else it's auto-selected from the rc file
-        if special_opts:
-            th_mode = special_opts.pop()
-            matplotlib.rcParams['backend'] = backends[th_mode]
-        else:
-            backend = matplotlib.rcParams['backend']
-            if backend.startswith('GTK'):
-                th_mode = 'gthread'
-            elif backend.startswith('WX'):
-                th_mode = 'wthread'
-            elif backend.startswith('Qt4'):
-                th_mode = 'q4thread'
-            elif backend.startswith('Qt'):
-                th_mode = 'qthread'
-            else:
-                # Any other backend, use plain Tk
-                th_mode = 'tkthread'
-                
-        return mpl_shell[th_mode]
+def start(user_ns=None, embedded=False):
+    """Return an instance of :class:`InteractiveShell`."""
+    if embedded:
+        return InteractiveShellEmbed(user_ns=user_ns)
     else:
-        # No pylab requested, just plain threads
-        try:
-            th_mode = special_opts.pop()
-        except KeyError:
-            th_mode = 'tkthread'
-        return th_shell[th_mode]
-
-
-# This is the one which should be called by external code.
-def start(user_ns = None):
-    """Return a running shell instance, dealing with threading options.
-
-    This is a factory function which will instantiate the proper IPython shell
-    based on the user's threading choice.  Such a selector is needed because
-    different GUI toolkits require different thread handling details."""
-
-    shell = _select_shell(sys.argv)
-    return shell(user_ns = user_ns)
+        return InteractiveShell(user_ns=user_ns)
 
-# Some aliases for backwards compatibility
-IPythonShell = IPShell
-IPythonShellEmbed = IPShellEmbed
-#************************ End of file <Shell.py> ***************************

IPython/__init__.py

@@ -1,72 +1,64 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]>
 #
 #  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.dirname(__file__) + "/Extensions")
+# Therefore, non-IPython modules can be added to extensions directory
+sys.path.append(os.path.join(os.path.dirname(__file__), "extensions"))
 
-# Define what gets imported with a 'from IPython import *'
-__all__ = ['ipapi','generics','ipstruct','Release','Shell']
+#-----------------------------------------------------------------------------
+# Setup the top level names
+#-----------------------------------------------------------------------------
 
-# 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,[])
+# 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
 
-import Shell
+from IPython.lib import (
+    enable_wx, disable_wx,
+    enable_gtk, disable_gtk,
+    enable_qt4, disable_qt4,
+    enable_tk, disable_tk,
+    set_inputhook, clear_inputhook,
+    current_gui, spin,
+    appstart_qt4, appstart_wx,
+    appstart_gtk, appstart_tk
+)
 
 # Release data
-from IPython 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'] )
-__license__  = Release.license
-__version__  = Release.version
-__revision__ = Release.revision
+__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/core/completer.py

@@ -65,25 +65,28 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.rlineimpl as readline    
-import itertools
-from IPython.ipstruct import Struct
-from IPython import ipapi
-from IPython import generics
 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.utils import generics
+
 # Python 2.4 offers sets as a builtin
 try:
     set()
 except NameError:
     from sets import Set as set
 
-from IPython.genutils import debugx, dir2
+from IPython.utils.genutils import debugx, dir2
 
 __all__ = ['Completer','IPCompleter']
 
@@ -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
@@ -632,7 +635,7 b' class IPCompleter(Completer):'
             except IndexError:
                 return None
         except:
-            #from IPython.ultraTB import AutoFormattedTB; # dbg
+            #from IPython.core.ultratb import AutoFormattedTB; # dbg
             #tb=AutoFormattedTB('Verbose');tb() #dbg
             
             # If completion fails, don't annoy the user.

IPython/core/crashhandler.py

@@ -21,15 +21,14 b' Authors'
 # From the standard library
 import os
 import sys
-from pprint import pprint,pformat
+from pprint import pformat
 
 # Our own
-from IPython import Release
-from IPython import ultraTB
-from IPython.ColorANSI import ColorScheme,ColorSchemeTable  # too long names
-from IPython.Itpl import Itpl,itpl,printpl
+from IPython.core import release
+from IPython.core import ultratb
+from IPython.external.Itpl import itpl
 
-from IPython.genutils import *
+from IPython.utils.genutils import *
 
 #****************************************************************************
 class CrashHandler:
@@ -125,7 +124,7 b' $self.bug_tracker'
         #color_scheme = 'Linux'   # dbg
         
         try:
-            rptdir = self.IP.rc.ipythondir
+            rptdir = self.IP.ipython_dir
         except:
             rptdir = os.getcwd()
         if not os.path.isdir(rptdir):
@@ -134,7 +133,7 b' $self.bug_tracker'
         # write the report filename into the instance dict so it can get
         # properly expanded out in the user message template
         self.crash_report_fname = report_name
-        TBhandler = ultraTB.VerboseTB(color_scheme=color_scheme,
+        TBhandler = ultratb.VerboseTB(color_scheme=color_scheme,
                                            long_header=1)
         traceback = TBhandler.text(etype,evalue,etb,context=31)
 
@@ -167,12 +166,12 b' $self.bug_tracker'
         rpt_add = report.append
         
         rpt_add('*'*75+'\n\n'+'IPython post-mortem report\n\n')
-        rpt_add('IPython version: %s \n\n' % Release.version)
-        rpt_add('BZR revision   : %s \n\n' % Release.revision)
+        rpt_add('IPython version: %s \n\n' % release.version)
+        rpt_add('BZR revision   : %s \n\n' % release.revision)
         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:")
@@ -191,12 +190,12 b' class IPythonCrashHandler(CrashHandler):'
     def __init__(self,IP):
 
         # Set here which of the IPython authors should be listed as contact
-        AUTHOR_CONTACT = 'Ville'
+        AUTHOR_CONTACT = 'Fernando'
         
         # Set argument defaults
         app_name = 'IPython'
         bug_tracker = 'https://bugs.launchpad.net/ipython/+filebug'
-        contact_name,contact_email = Release.authors[AUTHOR_CONTACT][:2]
+        contact_name,contact_email = release.authors[AUTHOR_CONTACT][:2]
         crash_report_fname = 'IPython_crash_report.txt'
         # Call parent constructor
         CrashHandler.__init__(self,IP,app_name,contact_name,contact_email,
@@ -211,12 +210,12 b' class IPythonCrashHandler(CrashHandler):'
         rpt_add = report.append
         
         rpt_add('*'*75+'\n\n'+'IPython post-mortem report\n\n')
-        rpt_add('IPython version: %s \n\n' % Release.version)
-        rpt_add('BZR revision   : %s \n\n' % Release.revision)
+        rpt_add('IPython version: %s \n\n' % release.version)
+        rpt_add('BZR revision   : %s \n\n' % release.revision)
         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

@@ -31,9 +31,11 b' import linecache'
 import os
 import sys
 
-from IPython import PyColorize, ColorANSI, ipapi
-from IPython.genutils import Term
-from IPython.excolors import exception_colors
+from IPython.utils import PyColorize
+from IPython.core import ipapi
+from IPython.utils import coloransi
+from IPython.utils.genutils import Term
+from IPython.core.excolors import exception_colors
 
 # See if we can use pydb.
 has_pydb = False
@@ -68,6 +70,7 b' def BdbQuit_excepthook(et,ev,tb):'
 def BdbQuit_IPython_excepthook(self,et,ev,tb):
     print 'Exiting Debugger.'
 
+
 class Tracer(object):
     """Class for local debugging, similar to pdb.set_trace.
 
@@ -93,7 +96,7 b' class Tracer(object):'
 
         Usage example:
 
-        from IPython.Debugger import Tracer; debug_here = Tracer()
+        from IPython.core.debugger import Tracer; debug_here = Tracer()
 
         ... later in your code
         debug_here()  # -> will open up the debugger at that point.
@@ -103,25 +106,22 b' class Tracer(object):'
         from the Python standard library for usage details.
         """
 
-        global __IPYTHON__
         try:
-            __IPYTHON__
-        except NameError:
+            ip = ipapi.get()
+        except:
             # Outside of ipython, we set our own exception hook manually
-            __IPYTHON__ = ipapi.get(True,False)
             BdbQuit_excepthook.excepthook_ori = sys.excepthook
             sys.excepthook = BdbQuit_excepthook
             def_colors = 'NoColor'
             try:
                 # Limited tab completion support
-                import rlcompleter,readline
+                import readline
                 readline.parse_and_bind('tab: complete')
             except ImportError:
                 pass
         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:
@@ -136,6 +136,7 b' class Tracer(object):'
         
         self.debugger.set_trace(sys._getframe().f_back)
 
+
 def decorate_fn_with_doc(new_fn, old_fn, additional_text=""):
     """Make new_fn have old_fn's doc string. This is particularly useful
     for the do_... commands that hook into the help system.
@@ -147,6 +148,7 b' def decorate_fn_with_doc(new_fn, old_fn, additional_text=""):'
         wrapper.__doc__ = old_fn.__doc__ + additional_text
     return wrapper
 
+
 def _file_lines(fname):
     """Return the contents of a named file as a list of lines.
 
@@ -162,10 +164,10 b' def _file_lines(fname):'
         outfile.close()
         return out
 
+
 class Pdb(OldPdb):
     """Modified Pdb class, does not load readline."""
 
-    if sys.version[:3] >= '2.5' or has_pydb:
         def __init__(self,color_scheme='NoColor',completekey=None,
                      stdin=None, stdout=None):
 
@@ -180,6 +182,8 b' class Pdb(OldPdb):'
             # IPython changes...
             self.is_pydb = has_pydb
 
+        self.shell = ipapi.get()
+
             if self.is_pydb:
 
                 # iplib.py's ipalias seems to want pdb's checkline
@@ -191,8 +195,8 b' class Pdb(OldPdb):'
                 self.curframe = None
                 self.do_restart = self.new_do_restart
 
-                self.old_all_completions = __IPYTHON__.Completer.all_completions
-                __IPYTHON__.Completer.all_completions=self.all_completions
+            self.old_all_completions = self.shell.Completer.all_completions
+            self.shell.Completer.all_completions=self.all_completions
 
                 self.do_list = decorate_fn_with_doc(self.list_command_pydb,
                                                     OldPdb.do_list)
@@ -207,54 +211,7 b' class Pdb(OldPdb):'
             self.color_scheme_table = exception_colors()
 
             # shorthands 
-            C = ColorANSI.TermColors
-            cst = self.color_scheme_table
-
-            cst['NoColor'].colors.breakpoint_enabled = C.NoColor
-            cst['NoColor'].colors.breakpoint_disabled = C.NoColor
-
-            cst['Linux'].colors.breakpoint_enabled = C.LightRed
-            cst['Linux'].colors.breakpoint_disabled = C.Red
-
-            cst['LightBG'].colors.breakpoint_enabled = C.LightRed
-            cst['LightBG'].colors.breakpoint_disabled = C.Red
-
-            self.set_colors(color_scheme)
-
-            # Add a python parser so we can syntax highlight source while
-            # debugging.
-            self.parser = PyColorize.Parser()
-
-
-    else:
-        # Ugly hack: for Python 2.3-2.4, we can't call the parent constructor,
-        # because it binds readline and breaks tab-completion.  This means we
-        # have to COPY the constructor here.
-        def __init__(self,color_scheme='NoColor'):
-            bdb.Bdb.__init__(self)
-            cmd.Cmd.__init__(self,completekey=None) # don't load readline
-            self.prompt = 'ipdb> ' # The default prompt is '(Pdb)'
-            self.aliases = {}
-
-            # These two lines are part of the py2.4 constructor, let's put them
-            # unconditionally here as they won't cause any problems in 2.3.
-            self.mainpyfile = ''
-            self._wait_for_mainpyfile = 0
-
-            # Read $HOME/.pdbrc and ./.pdbrc
-            try:
-                self.rcLines = _file_lines(os.path.join(os.environ['HOME'],
-                                                        ".pdbrc"))
-            except KeyError:
-                self.rcLines = []
-            self.rcLines.extend(_file_lines(".pdbrc"))
-
-            # Create color table: we copy the default one from the traceback
-            # module and add a few attributes needed for debugging
-            self.color_scheme_table = exception_colors()
-
-            # shorthands 
-            C = ColorANSI.TermColors
+        C = coloransi.TermColors
             cst = self.color_scheme_table
 
             cst['NoColor'].colors.breakpoint_enabled = C.NoColor
@@ -277,28 +234,28 b' class Pdb(OldPdb):'
         self.color_scheme_table.set_active_scheme(scheme)
 
     def interaction(self, frame, traceback):
-        __IPYTHON__.set_completer_frame(frame)
+        self.shell.set_completer_frame(frame)
         OldPdb.interaction(self, frame, traceback)
 
     def new_do_up(self, arg):
         OldPdb.do_up(self, arg)
-        __IPYTHON__.set_completer_frame(self.curframe)
+        self.shell.set_completer_frame(self.curframe)
     do_u = do_up = decorate_fn_with_doc(new_do_up, OldPdb.do_up)
 
     def new_do_down(self, arg):
         OldPdb.do_down(self, arg)
-        __IPYTHON__.set_completer_frame(self.curframe)
+        self.shell.set_completer_frame(self.curframe)
 
     do_d = do_down = decorate_fn_with_doc(new_do_down, OldPdb.do_down)
 
     def new_do_frame(self, arg):
         OldPdb.do_frame(self, arg)
-        __IPYTHON__.set_completer_frame(self.curframe)
+        self.shell.set_completer_frame(self.curframe)
 
     def new_do_quit(self, arg):
         
         if hasattr(self, 'old_all_completions'):
-            __IPYTHON__.Completer.all_completions=self.old_all_completions
+            self.shell.Completer.all_completions=self.old_all_completions
         
         
         return OldPdb.do_quit(self, arg)
@@ -312,7 +269,7 b' class Pdb(OldPdb):'
         return self.do_quit(arg)
 
     def postloop(self):
-        __IPYTHON__.set_completer_frame(None)
+        self.shell.set_completer_frame(None)
 
     def print_stack_trace(self):
         try:
@@ -329,7 +286,7 b' class Pdb(OldPdb):'
         # vds: >>
         frame, lineno = frame_lineno
         filename = frame.f_code.co_filename
-        __IPYTHON__.hooks.synchronize_with_editor(filename, lineno, 0)
+        self.shell.hooks.synchronize_with_editor(filename, lineno, 0)
         # vds: <<
 
     def format_stack_entry(self, frame_lineno, lprefix=': ', context = 3):
@@ -498,7 +455,7 b' class Pdb(OldPdb):'
         # vds: >>
         lineno = first
         filename = self.curframe.f_code.co_filename
-        __IPYTHON__.hooks.synchronize_with_editor(filename, lineno, 0)
+        self.shell.hooks.synchronize_with_editor(filename, lineno, 0)
         # vds: <<
 
     do_l = do_list
@@ -507,16 +464,16 b' class Pdb(OldPdb):'
         """The debugger interface to magic_pdef"""
         namespaces = [('Locals', self.curframe.f_locals),
                       ('Globals', self.curframe.f_globals)]
-        __IPYTHON__.magic_pdef(arg, namespaces=namespaces)
+        self.shell.magic_pdef(arg, namespaces=namespaces)
 
     def do_pdoc(self, arg):
         """The debugger interface to magic_pdoc"""
         namespaces = [('Locals', self.curframe.f_locals),
                       ('Globals', self.curframe.f_globals)]
-        __IPYTHON__.magic_pdoc(arg, namespaces=namespaces)
+        self.shell.magic_pdoc(arg, namespaces=namespaces)
 
     def do_pinfo(self, arg):
         """The debugger equivalant of ?obj"""
         namespaces = [('Locals', self.curframe.f_locals),
                       ('Globals', self.curframe.f_globals)]
-        __IPYTHON__.magic_pinfo("pinfo %s" % arg, namespaces=namespaces)
+        self.shell.magic_pinfo("pinfo %s" % arg, namespaces=namespaces)

IPython/core/excolors.py

@@ -12,7 +12,7 b' Color schemes for exception handling code in IPython.'
 
 #****************************************************************************
 # Required modules
-from IPython.ColorANSI import ColorSchemeTable, TermColors, ColorScheme
+from IPython.utils.coloransi import ColorSchemeTable, TermColors, ColorScheme
 
 def exception_colors():
     """Return a color table with fields for exception reporting.
@@ -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

@@ -5,9 +5,8 b''
 import fnmatch
 import os
 
-# IPython imports
-from IPython.genutils import Term, ask_yes_no, warn
-import IPython.ipapi
+from IPython.utils.genutils import Term, ask_yes_no, warn
+from IPython.core import ipapi
 
 def magic_history(self, parameter_s = ''):
     """Print input history (_i<n> variables), with most recent last.
@@ -48,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')
@@ -72,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
@@ -106,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)
@@ -169,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]:
@@ -180,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
@@ -229,7 +225,7 b' class ShadowHist:'
             #print "new",newidx # dbg
             self.db.hset('shadowhist',ent, newidx)
         except:
-            IPython.ipapi.get().IP.showtraceback()
+            ipapi.get().showtraceback()
             print "WARNING: disabling shadow history"
             self.disabled = True
     
@@ -251,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

@@ -19,14 +19,14 b" For example, suppose that you have a module called 'myiphooks' in your"
 PYTHONPATH, which contains the following definition:
 
 import os
-import IPython.ipapi
-ip = IPython.ipapi.get()
+from IPython.core import ipapi
+ip = ipapi.get()
 
 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 import ipapi
-
 import os,bisect
 import sys
-from genutils import Term,shell
+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)
@@ -161,13 +160,14 b' class CommandChainDispatcher:'
         """
         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,15 +248,19 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.
     """
-    from IPython.clipboard import (osx_clipboard_get, tkinter_clipboard_get, 
-        win32_clipboard_get)
+    from IPython.lib.clipboard import (
+        osx_clipboard_get, tkinter_clipboard_get, 
+        win32_clipboard_get
+    )
     if sys.platform == 'win32':
         chain = [win32_clipboard_get, tkinter_clipboard_get]
     elif sys.platform == 'darwin':

IPython/core/macro.py

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

IPython/core/magic.py

@@ -21,6 +21,7 b' import os'
 import pdb
 import pydoc
 import sys
+import shutil
 import re
 import tempfile
 import time
@@ -43,17 +44,20 b' except ImportError:'
 
 # Homebrewed
 import IPython
-from IPython import Debugger, OInspect, wildcard
-from IPython.FakeModule import FakeModule
-from IPython.Itpl import Itpl, itpl, printpl,itplns
-from IPython.PyColorize import Parser
-from IPython.ipstruct import Struct
-from IPython.macro import Macro
-from IPython.genutils import *
-from IPython import platutils
-import IPython.generics
-import IPython.ipapi
-from IPython.ipapi import UsageError
+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.error import UsageError
 from IPython.testing import decorators as testdec
 
 #***************************************************************************
@@ -203,9 +207,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;
@@ -242,7 +246,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:
@@ -270,10 +274,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)
@@ -374,10 +378,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 = ''):
@@ -422,11 +426,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)
@@ -469,22 +473,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 = ''):
@@ -511,15 +515,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 = ''):
@@ -565,8 +568,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:
@@ -577,18 +578,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,9 +601,12 b' Currently the magic system has the following functions:\\n"""'
         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=''):
@@ -632,8 +636,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.'
 
@@ -717,9 +721,9 b' Currently the magic system has the following functions:\\n"""'
         
         if info.found:
             try:
-                IPython.generics.inspect_object(info.obj)
+                IPython.utils.generics.inspect_object(info.obj)
                 return
-            except IPython.ipapi.TryNext:
+            except TryNext:
                 pass
             # Get the docstring of the class property if it exists.
             path = oname.split('.')
@@ -847,7 +851,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',[]))
@@ -972,7 +976,7 b' Currently the magic system has the following functions:\\n"""'
             return self.shell.user_ns[i]
         
         # some types are well known and can be shorter
-        abbrevs = {'IPython.macro.Macro' : 'Macro'}
+        abbrevs = {'IPython.core.macro.Macro' : 'Macro'}
         def type_name(v):
             tn = type(v).__name__
             return abbrevs.get(tn,tn)
@@ -1131,7 +1135,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
@@ -1148,11 +1151,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)
@@ -1265,7 +1269,6 b' Currently the magic system has the following functions:\\n"""'
         If you want IPython to automatically do this on every exception, see
         the %pdb magic for more details.
         """
-        
         self.shell.debugger(force=True)
 
     @testdec.skip_doctest
@@ -1420,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]
@@ -1561,14 +1564,14 b' Currently the magic system has the following functions:\\n"""'
             filename = file_finder(arg_lst[0])
         except IndexError:
             warn('you must provide at least a filename.')
-            print '\n%run:\n',OInspect.getdoc(self.magic_run)
+            print '\n%run:\n',oinspect.getdoc(self.magic_run)
             return
         except IOError,msg:
             error(msg)
             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
@@ -1621,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
@@ -1706,7 +1709,12 b' Currently the magic system has the following functions:\\n"""'
                     # (leaving dangling references).
                     self.shell.cache_main_mod(prog_ns,filename)
                     # update IPython interactive namespace
-                    del prog_ns['__name__']
+
+                    # Some forms of read errors on the file may mean the
+                    # __name__ key was never set; using pop we don't have to
+                    # worry about a possible KeyError.
+                    prog_ns.pop('__name__', None)
+
                     self.shell.user_ns.update(prog_ns)
         finally:
             # It's a bit of a mystery why, but __builtins__ can change from
@@ -1733,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
@@ -2055,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,
@@ -2252,7 +2241,7 b' Currently the magic system has the following functions:\\n"""'
 
         If you wish to write your own editor hook, you can put it in a
         configuration file which you load at startup time.  The default hook
-        is defined in the IPython.hooks module, and you can use that as a
+        is defined in the IPython.core.hooks module, and you can use that as a
         starting example for further modifications.  That file also has
         general instructions on how to set a new hook for use once you've
         defined it."""
@@ -2385,7 +2374,7 b' Currently the magic system has the following functions:\\n"""'
         sys.stdout.flush()
         try:
             self.shell.hooks.editor(filename,lineno)
-        except IPython.ipapi.TryNext:
+        except TryNext:
             warn('Could not open editor')
             return
         
@@ -2461,7 +2450,7 b' Currently the magic system has the following functions:\\n"""'
         # local shortcut
         shell = self.shell
 
-        import IPython.rlineimpl as readline
+        import IPython.utils.rlineimpl as readline
 
         if not readline.have_readline and sys.platform == "win32":
             msg = """\
@@ -2486,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:
@@ -2503,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:
@@ -2522,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.
@@ -2611,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)
+            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 res
+            return aliases
+        
+        # Now try to define a new one
         try:
             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)
+            print oinspect.getdoc(self.magic_alias)
+        else:
+            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
@@ -2677,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:
@@ -2704,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
@@ -2711,13 +2674,15 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)
+                        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:
@@ -2727,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)
+                                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)
-            # 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
+            db = self.db
             db['syscmdlist'] = syscmdlist
         finally:
             os.chdir(savedir)
@@ -2847,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:
@@ -2861,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']
             
@@ -3162,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
@@ -3259,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.
@@ -3273,7 +3235,7 b' Defaulting color scheme to \'NoColor\'"""'
     def _get_pasted_lines(self, sentinel):
         """ Yield pasted lines until the user enters the given sentinel value.
         """
-        from IPython import iplib
+        from IPython.core import iplib
         print "Pasting code; enter '%s' alone on the line to stop." % sentinel
         while True:
             l = iplib.raw_input_original(':')
@@ -3344,7 +3306,7 b' Defaulting color scheme to \'NoColor\'"""'
 
         See also
         --------
-        %paste: automatically pull code from clipboard.
+        paste: automatically pull code from clipboard.
         """
         
         opts,args = self.parse_options(parameter_s,'rs:',mode='string')
@@ -3364,7 +3326,8 b' Defaulting color scheme to \'NoColor\'"""'
         """Allows you to paste & execute a pre-formatted code block from clipboard.
         
         The text is pulled directly from the clipboard without user
-        intervention.
+        intervention and printed back on the screen before execution (unless
+        the -q flag is given to force quiet mode).
 
         The block is dedented prior to execution to enable execution of method
         definitions. '>' and '+' characters at the beginning of a line are
@@ -3377,15 +3340,20 b' Defaulting color scheme to \'NoColor\'"""'
         This assigns the pasted block to variable 'foo' as string, without 
         dedenting or executing it (preceding >>> and + is still stripped)
         
-        '%paste -r' re-executes the block previously entered by cpaste.
+        Options
+        -------
+        
+          -r: re-executes the block previously entered by cpaste.
+
+          -q: quiet mode: do not echo the pasted text back to the terminal.
         
         IPython statements (magics, shell escapes) are not supported (yet).
 
         See also
         --------
-        %cpaste: manually paste code into terminal until you mark its end.
+        cpaste: manually paste code into terminal until you mark its end.
         """
-        opts,args = self.parse_options(parameter_s,'r:',mode='string')
+        opts,args = self.parse_options(parameter_s,'rq',mode='string')
         par = args.strip()
         if opts.has_key('r'):
             self._rerun_pasted()
@@ -3393,43 +3361,24 b' Defaulting color scheme to \'NoColor\'"""'
 
         text = self.shell.hooks.clipboard_get()
         block = self._strip_pasted_lines_for_code(text.splitlines())
+
+        # By default, echo back to terminal unless quiet mode is requested
+        if not opts.has_key('q'):
+            write = self.shell.write
+            write(self.shell.pycolorize(block))
+            if not block.endswith('\n'):
+                write('\n')
+            write("## -- End pasted text --\n")
+            
         self._execute_block(block, par)
 
     def magic_quickref(self,arg):
         """ Show a quick reference sheet """
-        import IPython.usage
-        qr = IPython.usage.quick_reference + self.magic_magic('-brief')
+        import IPython.core.usage
+        qr = IPython.core.usage.quick_reference + self.magic_magic('-brief')
         
         page(qr)
         
-    def magic_upgrade(self,arg):
-        """ Upgrade your IPython installation
-        
-        This will copy the config files that don't yet exist in your 
-        ipython dir from the system config dir. Use this after upgrading 
-        IPython if you don't wish to delete your .ipython dir.
-
-        Call with -nolegacy to get rid of ipythonrc* files (recommended for
-        new users)
-
-        """
-        ip = self.getapi()
-        ipinstallation = path(IPython.__file__).dirname()
-        upgrade_script = '%s "%s"' % (sys.executable,ipinstallation / 'upgrade_dir.py')
-        src_config = ipinstallation / 'UserConfig'
-        userdir = path(ip.options.ipythondir)
-        cmd = '%s "%s" "%s"' % (upgrade_script, src_config, userdir)
-        print ">",cmd
-        shell(cmd)
-        if arg == '-nolegacy':
-            legacy = userdir.files('ipythonrc*')
-            print "Nuking legacy files:",legacy
-            
-            [p.remove() for p in legacy]
-            suffix = (sys.platform == 'win32' and '.ini' or '')
-            (userdir / ('ipythonrc' + suffix)).write_text('# Empty, see ipy_user_conf.py\n')
-
-
     def magic_doctest_mode(self,parameter_s=''):
         """Toggle doctest mode on and off.
 
@@ -3451,13 +3400,12 b' Defaulting color scheme to \'NoColor\'"""'
         """
 
         # XXX - Fix this to have cleaner activate/deactivate calls.
-        from IPython.Extensions import InterpreterPasteInput as ipaste
-        from IPython.ipstruct import Struct
+        from IPython.extensions import InterpreterPasteInput as ipaste
+        from IPython.utils.ipstruct import Struct
 
         # 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.
@@ -3466,12 +3414,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
@@ -3489,7 +3437,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')
 
@@ -3497,9 +3445,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
 
@@ -3518,4 +3466,115 b' Defaulting color scheme to \'NoColor\'"""'
         print 'Doctest mode is:',
         print ['OFF','ON'][dstore.mode]
 
+    def magic_gui(self, parameter_s=''):
+        """Enable or disable IPython GUI event loop integration.
+
+        %gui [-a] [GUINAME]
+
+        This magic replaces IPython's threaded shells that were activated
+        using the (pylab/wthread/etc.) command line flags.  GUI toolkits
+        can now be enabled, disabled and swtiched at runtime and keyboard
+        interrupts should work without any problems.  The following toolkits
+        are supports:  wxPython, PyQt4, PyGTK, and Tk::
+
+            %gui wx      # enable wxPython event loop integration
+            %gui qt4|qt  # enable PyQt4 event loop integration
+            %gui gtk     # enable PyGTK event loop integration
+            %gui tk      # enable Tk event loop integration
+            %gui         # disable all event loop integration
+
+        WARNING:  after any of these has been called you can simply create
+        an application object, but DO NOT start the event loop yourself, as
+        we have already handled that.
+
+        If you want us to create an appropriate application object add the
+        "-a" flag to your command::
+
+            %gui -a wx
+
+        This is highly recommended for most users.
+        """
+        from IPython.lib import inputhook
+        if "-a" in parameter_s:
+            app = True
+        else:
+            app = False
+        if not parameter_s:
+            inputhook.clear_inputhook()
+        elif 'wx' in parameter_s:
+            return inputhook.enable_wx(app)
+        elif ('qt4' in parameter_s) or ('qt' in parameter_s):
+            return inputhook.enable_qt4(app)
+        elif 'gtk' in parameter_s:
+            return inputhook.enable_gtk(app)
+        elif 'tk' in parameter_s:
+            return inputhook.enable_tk(app)
+
+    def magic_load_ext(self, module_str):
+        """Load an IPython extension by its module name."""
+        self.load_extension(module_str)
+
+    def magic_unload_ext(self, module_str):
+        """Unload an IPython extension by its module name."""
+        self.unload_extension(module_str)
+
+    def magic_reload_ext(self, module_str):
+        """Reload an IPython extension by its module name."""
+        self.reload_extension(module_str)
+
+    def magic_install_profiles(self, s):
+        """Install the default IPython profiles into the .ipython dir.
+
+        If the default profiles have already been installed, they will not
+        be overwritten. You can force overwriting them by using the ``-o``
+        option::
+
+            In [1]: %install_profiles -o
+        """
+        if '-o' in s:
+            overwrite = True
+        else:
+            overwrite = False
+        from IPython.config import profile
+        profile_dir = os.path.split(profile.__file__)[0]
+        ipython_dir = self.ipython_dir
+        files = os.listdir(profile_dir)
+
+        to_install = []
+        for f in files:
+            if f.startswith('ipython_config'):
+                src = os.path.join(profile_dir, f)
+                dst = os.path.join(ipython_dir, f)
+                if (not os.path.isfile(dst)) or overwrite:
+                    to_install.append((f, src, dst))
+        if len(to_install)>0:
+            print "Installing profiles to: ", ipython_dir
+            for (f, src, dst) in to_install:
+                shutil.copy(src, dst)
+                print "    %s" % f
+
+    def magic_install_default_config(self, s):
+        """Install IPython's default config file into the .ipython dir.
+
+        If the default config file (:file:`ipython_config.py`) is already
+        installed, it will not be overwritten. You can force overwriting
+        by using the ``-o`` option::
+
+            In [1]: %install_default_config
+        """
+        if '-o' in s:
+            overwrite = True
+        else:
+            overwrite = False
+        from IPython.config import default
+        config_dir = os.path.split(default.__file__)[0]
+        ipython_dir = self.ipython_dir
+        default_config_file_name = 'ipython_config.py'
+        src = os.path.join(config_dir, default_config_file_name)
+        dst = os.path.join(ipython_dir, default_config_file_name)
+        if (not os.path.isfile(dst)) or overwrite:
+            shutil.copy(src, dst)
+            print "Installing default config file: %s" % dst
+
+
 # end Magic

IPython/core/oinspect.py

@@ -27,11 +27,12 b' import sys'
 import types
 
 # IPython's own
-from IPython import PyColorize
-from IPython.genutils import page,indent,Term
-from IPython.Itpl import itpl
-from IPython.wildcard import list_namespace
-from IPython.ColorANSI import *
+from IPython.utils import PyColorize
+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 *
 
 #****************************************************************************
 # HACK!!! This is a crude fix for bugs in python 2.3's inspect module.  We

IPython/core/prompts.py

@@ -20,23 +20,24 b' import sys'
 import time
 
 # IPython's own
-from IPython import ColorANSI
-from IPython import Release
+from IPython.utils import coloransi
+from IPython.core import release
 from IPython.external.Itpl import ItplNS
-from IPython.ipapi import TryNext
-from IPython.ipstruct import Struct
-from IPython.macro import Macro
+from IPython.core.error import TryNext
+from IPython.utils.ipstruct import Struct
+from IPython.core.macro import Macro
+import IPython.utils.generics
 
-from IPython.genutils import *
+from IPython.utils.genutils import *
 
 #****************************************************************************
 #Color schemes for Prompts.
 
-PromptColors = ColorANSI.ColorSchemeTable()
-InputColors = ColorANSI.InputTermColors  # just a shorthand
-Colors = ColorANSI.TermColors  # just a shorthand
+PromptColors = coloransi.ColorSchemeTable()
+InputColors = coloransi.InputTermColors  # just a shorthand
+Colors = coloransi.TermColors  # just a shorthand
 
-PromptColors.add_scheme(ColorANSI.ColorScheme(
+PromptColors.add_scheme(coloransi.ColorScheme(
     'NoColor',
     in_prompt  = InputColors.NoColor,  # Input prompt
     in_number  = InputColors.NoColor,  # Input prompt number
@@ -50,7 +51,7 b' PromptColors.add_scheme(ColorANSI.ColorScheme('
     ))
 
 # make some schemes as instances so we can copy them for modification easily:
-__PColLinux =  ColorANSI.ColorScheme(
+__PColLinux =  coloransi.ColorScheme(
     'Linux',
     in_prompt  = InputColors.Green,
     in_number  = InputColors.LightGreen,
@@ -169,7 +170,7 b' prompt_specials_color = {'
     # Carriage return
     r'\r': '\r',
     # Release version
-    r'\v': Release.version,
+    r'\v': release.version,
     # Root symbol ($ or #)
     r'\$': ROOT_SYMBOL,
     }
@@ -185,7 +186,7 b" prompt_specials_nocolor[r'\\#'] = '${self.cache.prompt_count}'"
 # with a color name which may begin with a letter used by any other of the
 # allowed specials.  This of course means that \\C will never be allowed for
 # anything else.
-input_colors = ColorANSI.InputTermColors
+input_colors = coloransi.InputTermColors
 for _color in dir(input_colors):
     if _color[0] != '_':
         c_name = r'\C_'+_color
@@ -545,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)
@@ -573,7 +577,7 b' class CachedOutput:'
         display, e.g. when your own objects need special formatting.
         """
         try:
-            return IPython.generics.result_display(arg)
+            return IPython.utils.generics.result_display(arg)
         except TryNext:            
             return self.shell.hooks.result_display(arg)
 

IPython/core/release.py

@@ -2,8 +2,8 b''
 """Release data for the IPython project."""
 
 #*****************************************************************************
-#       Copyright (C) 2001-2006 Fernando Perez <[e-mail]>
-#
+#       Copyright (C) 2008-2009  The IPython Development Team
+#       Copyright (C) 2001-2008 Fernando Perez <[e-mail]>
 #       Copyright (c) 2001 Janko Hauser <[e-mail]> and Nathaniel Gray
 #       <[e-mail]>
 #
@@ -21,9 +21,9 b" name = 'ipython'"
 # bdist_deb does not accept underscores (a Debian convention).
 
 development = True    # change this to False to do a release
-version_base = '0.10'
+version_base = '0.11'
 branch = 'ipython'
-revision = '1163'
+revision = '1205'
 
 if development:
     if branch == 'ipython':
@@ -100,7 +100,7 b' site <http://launchpad.net/ipython>`_.'
 
 license = 'BSD'
 
-authors = {'Fernando' : ('Fernando Perez','[e-mail]'),
+authors = {'Fernando' : ('Fernando Perez','[e-mail]'),
            'Janko'    : ('Janko Hauser','[e-mail]'),
            'Nathan'   : ('Nathaniel Gray','[e-mail]'),
            'Ville'    : ('Ville Vainio','[e-mail]'),

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()

IPython/core/tests/refbug.py

@@ -18,7 +18,7 b' test_magic.py calls it.'
 #-----------------------------------------------------------------------------
 import sys
 
-from IPython import ipapi
+from IPython.core import ipapi
 
 #-----------------------------------------------------------------------------
 # Globals

IPython/core/tests/test_fakemodule.py

@@ -3,7 +3,7 b''
 
 import nose.tools as nt
 
-from IPython.FakeModule import FakeModule, init_fakemod_dict
+from IPython.core.fakemodule import FakeModule, init_fakemod_dict
 
 # Make a fakemod and check a few properties
 def test_mk_fakemod():

IPython/core/tests/test_iplib.py

@@ -13,7 +13,9 b' import tempfile'
 import nose.tools as nt
 
 # our own packages
-from IPython import ipapi, iplib
+from IPython.core import iplib
+from IPython.core import ipapi
+
 
 #-----------------------------------------------------------------------------
 # Globals
@@ -37,44 +39,19 b' if ip is None:'
     from IPython.testing.plugin import ipdoctest
     ip = ipapi.get()
     
-IP = ip.IP  # This is the actual IPython shell 'raw' object.
-
 #-----------------------------------------------------------------------------
 # Test functions
 #-----------------------------------------------------------------------------
 
 def test_reset():
     """reset must clear most namespaces."""
-    IP.reset()  # first, it should run without error
+    ip.reset()  # first, it should run without error
     # Then, check that most namespaces end up empty
-    for ns in IP.ns_refs_table:
-        if ns is IP.user_ns:
+    for ns in ip.ns_refs_table:
+        if ns is ip.user_ns:
             # The user namespace is reset with some data, so we can't check for
             # it being empty
             continue
         nt.assert_equals(len(ns),0)
 
 
  No newline at end of file
-# make sure that user_setup can be run re-entrantly in 'install' mode.
-def test_user_setup():
-    # use a lambda to pass kwargs to the generator
-    user_setup = lambda a,k: iplib.user_setup(*a,**k)
-    kw = dict(mode='install', interactive=False)
-
-    # Call the user setup and verify that the directory exists
-    yield user_setup, (ip.options.ipythondir,''), kw
-    yield os.path.isdir, ip.options.ipythondir
-
-    # Now repeat the operation with a non-existent directory. Check both that
-    # the call succeeds and that the directory is created.
-    tmpdir = tempfile.mktemp(prefix='ipython-test-')
-    # Use a try with an empty except because try/finally doesn't work with a 
-    # yield in Python 2.4.
-    try:
-        yield user_setup, (tmpdir,''), kw
-        yield os.path.isdir, tmpdir
-    except:
-        pass
-    # Clean up the temp dir once done
-    shutil.rmtree(tmpdir)
-    
  No newline at end of file

IPython/core/tests/test_magic.py

@@ -7,10 +7,11 b' import os'
 import sys
 import tempfile
 import types
+from cStringIO import StringIO
 
 import nose.tools as nt
 
-from IPython.platutils import find_cmd, get_long_path_name
+from IPython.utils.platutils import find_cmd, get_long_path_name
 from IPython.testing import decorators as dec
 from IPython.testing import tools as tt
 
@@ -19,14 +20,15 b' from IPython.testing import tools as tt'
 
 def test_rehashx():
     # clear up everything
-    _ip.IP.alias_table.clear()
+    _ip = get_ipython()
+    _ip.alias_manager.alias_table.clear()
     del _ip.db['syscmdlist']
     
     _ip.magic('rehashx')
     # Practically ALL ipython development systems will have more than 10 aliases
 
-    yield (nt.assert_true, len(_ip.IP.alias_table) > 10)
-    for key, val in _ip.IP.alias_table.items():
+    yield (nt.assert_true, len(_ip.alias_manager.alias_table) > 10)
+    for key, val in _ip.alias_manager.alias_table.items():
         # we must strip dots from alias names
         nt.assert_true('.' not in key)
 
@@ -43,7 +45,6 b' def doctest_hist_f():'
     In [10]: tfile = tempfile.mktemp('.py','tmp-ipython-')
 
     In [11]: %hist -n -f $tfile 3
-
     """
 
 
@@ -52,7 +53,7 b' def doctest_hist_r():'
 
     XXX - This test is not recording the output correctly.  Not sure why...
 
-    In [20]: 'hist' in _ip.IP.lsmagic()
+    In [20]: 'hist' in _ip.lsmagic()
     Out[20]: True
 
     In [6]: x=1
@@ -65,11 +66,12 b' def doctest_hist_r():'
 # This test is known to fail on win32.
 # See ticket https://bugs.launchpad.net/bugs/366334
 def test_obj_del():
+    _ip = get_ipython()
     """Test that object's __del__ methods are called on exit."""
     test_dir = os.path.dirname(__file__)
     del_file = os.path.join(test_dir,'obj_del.py')
     ipython_cmd = find_cmd('ipython')
-    out = _ip.IP.getoutput('%s %s' % (ipython_cmd, del_file))
+    out = _ip.getoutput('%s %s' % (ipython_cmd, del_file))
     nt.assert_equals(out,'obj_del.py: object A deleted')
 
 
@@ -77,8 +79,8 b' def test_shist():'
     # Simple tests of ShadowHist class - test generator.
     import os, shutil, tempfile
 
-    from IPython.Extensions import pickleshare
-    from IPython.history import ShadowHist
+    from IPython.utils import pickleshare
+    from IPython.core.history import ShadowHist
     
     tfile = tempfile.mktemp('','tmp-ipython-')
     
@@ -98,7 +100,7 b' def test_shist():'
     
 @dec.skipif_not_numpy
 def test_numpy_clear_array_undec():
-    from IPython.Extensions import clearcmd
+    from IPython.extensions import clearcmd
 
     _ip.ex('import numpy as np')
     _ip.ex('a = np.empty(2)')
@@ -124,7 +126,7 b' def doctest_refbug():'
     """Very nasty problem with references held by multiple runs of a script.
     See: https://bugs.launchpad.net/ipython/+bug/269966
 
-    In [1]: _ip.IP.clear_main_mod_cache()
+    In [1]: _ip.clear_main_mod_cache()
     
     In [2]: run refbug
 
@@ -164,7 +166,6 b' def doctest_run_ns2():'
     tclass.py: deleting object: C-first_pass
     """
 
[e-mail]_win32
 def doctest_run_builtins():
     """Check that %run doesn't damage __builtins__ via a doctest.
 
@@ -177,24 +178,34 b' def doctest_run_builtins():'
 
     In [2]: bid1 = id(__builtins__)
 
-    In [3]: f = tempfile.NamedTemporaryFile()
+    In [3]: fname = tempfile.mkstemp()[1]
+
+    In [3]: f = open(fname,'w')
 
     In [4]: f.write('pass\\n')
 
     In [5]: f.flush()
 
-    In [6]: print 'B1:',type(__builtins__)
-    B1: <type 'module'>
+    In [6]: print type(__builtins__)
+    <type 'module'>
 
-    In [7]: %run $f.name
+    In [7]: %run "$fname"
+
+    In [7]: f.close()
 
     In [8]: bid2 = id(__builtins__)
 
-    In [9]: print 'B2:',type(__builtins__)
-    B2: <type 'module'>
+    In [9]: print type(__builtins__)
+    <type 'module'>
 
     In [10]: bid1 == bid2
     Out[10]: True
+
+    In [12]: try:
+       ....:     os.unlink(fname)
+       ....: except:
+       ....:     pass
+       ....: 
     """
 
 # For some tests, it will be handy to organize them in a class with a common
@@ -204,34 +215,28 b' class TestMagicRun(object):'
 
     def setup(self):
         """Make a valid python temp file."""
-        f = tempfile.NamedTemporaryFile()
+        fname = tempfile.mkstemp()[1]
+        f = open(fname,'w')
         f.write('pass\n')
         f.flush()
         self.tmpfile = f
+        self.fname = fname
 
     def run_tmpfile(self):
+        _ip = get_ipython()
         # This fails on Windows if self.tmpfile.name has spaces or "~" in it.
         # See below and ticket https://bugs.launchpad.net/bugs/366353
-        _ip.magic('run %s' % self.tmpfile.name)
+        _ip.magic('run "%s"' % self.fname)
 
-    # See https://bugs.launchpad.net/bugs/366353
-    @dec.skip_if_not_win32
-    def test_run_tempfile_path(self):
-        tt.assert_equals(True,False,"%run doesn't work with tempfile paths on win32.")
-
-    # See https://bugs.launchpad.net/bugs/366353
-    @dec.skip_win32
     def test_builtins_id(self):
         """Check that %run doesn't damage __builtins__ """
-
+        _ip = get_ipython()
         # Test that the id of __builtins__ is not modified by %run
         bid1 = id(_ip.user_ns['__builtins__'])
         self.run_tmpfile()
         bid2 = id(_ip.user_ns['__builtins__'])
         tt.assert_equals(bid1, bid2)
 
-    # See https://bugs.launchpad.net/bugs/366353
-    @dec.skip_win32
     def test_builtins_type(self):
         """Check that the type of __builtins__ doesn't change with %run.
         
@@ -239,33 +244,45 b' class TestMagicRun(object):'
         be a dict (it should be a module) by a previous use of %run.  So we
         also check explicitly that it really is a module:
         """
+        _ip = get_ipython()
         self.run_tmpfile()
         tt.assert_equals(type(_ip.user_ns['__builtins__']),type(sys))
 
-    # See https://bugs.launchpad.net/bugs/366353
-    @dec.skip_win32
     def test_prompts(self):
         """Test that prompts correctly generate after %run"""
         self.run_tmpfile()
-        p2 = str(_ip.IP.outputcache.prompt2).strip()
+        _ip = get_ipython()
+        p2 = str(_ip.outputcache.prompt2).strip()
         nt.assert_equals(p2[:3], '...')
 
     def teardown(self):
         self.tmpfile.close()
+        try:
+            os.unlink(self.fname)
+        except:
+            # On Windows, even though we close the file, we still can't delete
+            # it.  I have no clue why
+            pass
 
 # Multiple tests for clipboard pasting
 def test_paste():
-
-    def paste(txt):
+    _ip = get_ipython()
+    def paste(txt, flags='-q'):
+        """Paste input text, by default in quiet mode"""
         hooks.clipboard_get = lambda : txt
-        _ip.magic('paste')
+        _ip.magic('paste '+flags)
 
     # Inject fake clipboard hook but save original so we can restore it later
-    hooks = _ip.IP.hooks
+    hooks = _ip.hooks
     user_ns = _ip.user_ns
     original_clip = hooks.clipboard_get
 
     try:
+        # This try/except with an emtpy except clause is here only because
+        # try/yield/finally is invalid syntax in Python 2.4.  This will be
+        # removed when we drop 2.4-compatibility, and the emtpy except below
+        # will be changed to a finally.
+
         # Run tests with fake clipboard function
         user_ns.pop('x', None)
         paste('x=1')
@@ -285,6 +302,30 b' def test_paste():'
         yield (nt.assert_equal, user_ns['x'], [1,2,3])
         yield (nt.assert_equal, user_ns['y'], [1,4,9])
 
+        # Now, test that paste -r works
+        user_ns.pop('x', None)
+        yield (nt.assert_false, 'x' in user_ns)
+        _ip.magic('paste -r')
+        yield (nt.assert_equal, user_ns['x'], [1,2,3])
+
+        # Also test paste echoing, by temporarily faking the writer
+        w = StringIO()
+        writer = _ip.write
+        _ip.write = w.write
+        code = """
+        a = 100
+        b = 200"""
+        try:
+            paste(code,'')
+            out = w.getvalue()
+        finally:
+            _ip.write = writer
+        yield (nt.assert_equal, user_ns['a'], 100)
+        yield (nt.assert_equal, user_ns['b'], 200)
+        yield (nt.assert_equal, out, code+"\n## -- End pasted text --\n")
+        
     finally:
+        # This should be in a finally clause, instead of the bare except above.
         # Restore original hook
         hooks.clipboard_get = original_clip
+

IPython/core/ultratb.py

@@ -1,6 +1,6 b''
 # -*- coding: utf-8 -*-
 """
-ultraTB.py -- Spice up your tracebacks!
+ultratb.py -- Spice up your tracebacks!
 
 * ColorTB
 I've always found it a bit hard to visually parse tracebacks in Python.  The
@@ -9,8 +9,8 b' traceback in a manner similar to what you would expect from a syntax-highlightin'
 text editor.
 
 Installation instructions for ColorTB:
-    import sys,ultraTB
-    sys.excepthook = ultraTB.ColorTB()
+    import sys,ultratb
+    sys.excepthook = ultratb.ColorTB()
 
 * VerboseTB  
 I've also included a port of Ka-Ping Yee's "cgitb.py" that produces all kinds
@@ -37,8 +37,8 b' Note:'
   
 
 Installation instructions for ColorTB:
-    import sys,ultraTB
-    sys.excepthook = ultraTB.VerboseTB()
+    import sys,ultratb
+    sys.excepthook = ultratb.VerboseTB()
 
 Note:  Much of the code in this module was lifted verbatim from the standard
 library module 'traceback.py' and Ka-Ping Yee's 'cgitb.py'.
@@ -69,7 +69,8 b' possible inclusion in future releases.'
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
-# Required modules
+from __future__ import with_statement
+
 import inspect
 import keyword
 import linecache
@@ -90,10 +91,12 b' from inspect import getsourcefile, getfile, getmodule,\\'
 
 # IPython's own modules
 # Modified pdb which doesn't damage IPython's readline handling
-from IPython import Debugger, PyColorize, ipapi
-from IPython.ipstruct import Struct
-from IPython.excolors import exception_colors
-from IPython.genutils import Term,uniq_stable,error,info
+from IPython.utils import PyColorize
+from IPython.core import debugger, ipapi
+from IPython.core.display_trap import DisplayTrap
+from IPython.utils.ipstruct import Struct
+from IPython.core.excolors import exception_colors
+from IPython.utils.genutils import Term, uniq_stable, error, info
 
 # Globals
 # amount of space to put line numbers before verbose tracebacks
@@ -102,7 +105,7 b' INDENT_SIZE = 8'
 # Default color scheme.  This is used, for example, by the traceback
 # formatter.  When running in an actual IPython instance, the user's rc.colors
 # value is used, but havinga module global makes this functionality available
-# to users of ultraTB who are NOT running inside ipython.
+# to users of ultratb who are NOT running inside ipython.
 DEFAULT_SCHEME = 'NoColor'
 
 #---------------------------------------------------------------------------
@@ -267,10 +270,12 b' def _formatTracebackLines(lnum, index, lines, Colors, lvals=None,scheme=None):'
 
     # This lets us get fully syntax-highlighted tracebacks.
     if scheme is None:
-        try:
-            scheme = ipapi.get().IP.rc.colors
-        except:
+        ipinst = ipapi.get()
+        if ipinst is not None:
+            scheme = ipinst.colors
+        else:
             scheme = DEFAULT_SCHEME
+
     _line_format = _parser.format2
 
     for line in lines:
@@ -320,7 +325,7 b' class TBTools:'
         self.old_scheme = color_scheme  # save initial value for toggles
 
         if call_pdb:
-            self.pdb = Debugger.Pdb(self.color_scheme_table.active_scheme_name)
+            self.pdb = debugger.Pdb(self.color_scheme_table.active_scheme_name)
         else:
             self.pdb = None
 
@@ -489,7 +494,9 b' class ListTB(TBTools):'
 
         # vds:>>
         if have_filedata:
-            ipapi.get().IP.hooks.synchronize_with_editor(filename, lineno, 0)
+            ipinst = ipapi.get()
+            if ipinst is not None:
+                ipinst.hooks.synchronize_with_editor(filename, lineno, 0)
         # vds:<<
 
         return list
@@ -809,7 +816,9 b' class VerboseTB(TBTools):'
              filepath, lnum = records[-1][1:3]
              #print "file:", str(file), "linenb", str(lnum) # dbg
              filepath = os.path.abspath(filepath)
-             ipapi.get().IP.hooks.synchronize_with_editor(filepath, lnum, 0)
+             ipinst = ipapi.get()
+             if ipinst is not None:
+                 ipinst.hooks.synchronize_with_editor(filepath, lnum, 0)
         # vds: <<
                 
         # return all our info assembled as a single string
@@ -837,12 +846,12 b' class VerboseTB(TBTools):'
 
         if force or self.call_pdb:
             if self.pdb is None:
-                self.pdb = Debugger.Pdb(
+                self.pdb = debugger.Pdb(
                     self.color_scheme_table.active_scheme_name)
             # the system displayhook may have changed, restore the original
             # for pdb
-            dhook = sys.displayhook
-            sys.displayhook = sys.__displayhook__
+            display_trap = DisplayTrap(None, sys.__displayhook__)
+            with display_trap:
             self.pdb.reset()
             # Find the right frame so we don't pop up inside ipython itself
             if hasattr(self,'tb'):
@@ -851,13 +860,10 b' class VerboseTB(TBTools):'
                 etb = self.tb = sys.last_traceback
             while self.tb.tb_next is not None:
                 self.tb = self.tb.tb_next
-            try:
                 if etb and etb.tb_next:
                     etb = etb.tb_next
                 self.pdb.botframe = etb.tb_frame
                 self.pdb.interaction(self.tb.tb_frame, self.tb)
-            finally:
-                sys.displayhook = dhook
             
         if hasattr(self,'tb'):
             del self.tb

IPython/core/usage.py

@@ -6,6 +6,9 b''
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
+import sys
+from IPython.core import release
+
 __doc__ = """
 IPython -- An enhanced Interactive Python
 =========================================
@@ -37,84 +40,7 b' USAGE'
        in directories.
 
        In the rest of this text, we will refer to this directory as
-       IPYTHONDIR.
-
-
-SPECIAL THREADING OPTIONS
-       The following special options are ONLY valid at the  beginning  of  the
-       command line, and not later.  This is because they control the initial-
-       ization of ipython itself, before the normal option-handling  mechanism
-       is active.
-
-       -gthread, -qthread, -q4thread, -wthread, -pylab
-
-              Only ONE of these can be given, and it can only be given as the
-              first option passed to IPython (it will have no effect in any
-              other position).  They provide threading support for the GTK, QT
-              and WXWidgets toolkits, and for the matplotlib library.
-
-              With any of the first four options, IPython starts running a
-              separate thread for the graphical toolkit's operation, so that
-              you can open and control graphical elements from within an
-              IPython command line, without blocking.  All four provide
-              essentially the same functionality, respectively for GTK, QT3,
-              QT4 and WXWidgets (via their Python interfaces).
-
-              Note that with -wthread, you can additionally use the -wxversion
-              option to request a specific version of wx to be used.  This
-              requires that you have the 'wxversion' Python module installed,
-              which is part of recent wxPython distributions.
-
-              If -pylab is given, IPython loads special support for the mat-
-              plotlib library (http://matplotlib.sourceforge.net), allowing
-              interactive usage of any of its backends as defined in the
-              user's .matplotlibrc file.  It automatically activates GTK, QT
-              or WX threading for IPyhton if the choice of matplotlib backend
-              requires it.  It also modifies the %run command to correctly
-              execute (without blocking) any matplotlib-based script which
-              calls show() at the end.
-
-       -tk    The -g/q/q4/wthread options, and -pylab (if matplotlib is
-              configured to use GTK, QT or WX), will normally block Tk
-              graphical interfaces.  This means that when GTK, QT or WX
-              threading is active, any attempt to open a Tk GUI will result in
-              a dead window, and possibly cause the Python interpreter to
-              crash.  An extra option, -tk, is available to address this
-              issue.  It can ONLY be given as a SECOND option after any of the
-              above (-gthread, -qthread, q4thread, -wthread or -pylab).
-
-              If -tk is given, IPython will try to coordinate Tk threading
-              with GTK, QT or WX.  This is however potentially unreliable, and
-              you will have to test on your platform and Python configuration
-              to determine whether it works for you.  Debian users have
-              reported success, apparently due to the fact that Debian builds
-              all of Tcl, Tk, Tkinter and Python with pthreads support.  Under
-              other Linux environments (such as Fedora Core 2/3), this option
-              has caused random crashes and lockups of the Python interpreter.
-              Under other operating systems (Mac OSX and Windows), you'll need
-              to try it to find out, since currently no user reports are
-              available.
-
-              There is unfortunately no way for IPython to determine  at  run-
-              time  whether -tk will work reliably or not, so you will need to
-              do some experiments before relying on it for regular work.
-
-A WARNING ABOUT SIGNALS AND THREADS
-
-       When any of the thread systems (GTK, QT or WX) are active, either
-       directly or via -pylab with a threaded backend, it is impossible to
-       interrupt long-running Python code via Ctrl-C.  IPython can not pass
-       the KeyboardInterrupt exception (or the underlying SIGINT) across
-       threads, so any long-running process started from IPython will run to
-       completion, or will have to be killed via an external (OS-based)
-       mechanism.
-
-       To the best of my knowledge, this limitation is imposed by the Python
-       interpreter itself, and it comes from the difficulty of writing
-       portable signal/threaded code.  If any user is an expert on this topic
-       and can suggest a better solution, I would love to hear about it.  In
-       the IPython sources, look at the Shell.py module, and in particular at
-       the runcode() method.
+       IPYTHON_DIR.
 
 REGULAR OPTIONS
        After the above threading options have been given, regular options  can
@@ -132,16 +58,6 b' REGULAR OPTIONS'
        -h, --help
               Show summary of options.
 
-       -pylab This can only be given as the first option passed to IPython (it
-              will have no effect in any other position). It adds special sup-
-              port   for  the  matplotlib  library  (http://matplotlib.source-
-              forge.net), allowing interactive usage of any of its backends as
-              defined  in  the  user's  .matplotlibrc  file.  It automatically
-              activates GTK or WX threading for IPyhton if the choice of  mat-
-              plotlib  backend requires it.  It also modifies the @run command
-              to correctly execute  (without  blocking)  any  matplotlib-based
-              script which calls show() at the end.
-
        -autocall <val>
               Make IPython automatically call any callable object even if you
               didn't type explicit parentheses. For example, 'str 43' becomes
@@ -234,9 +150,9 b' REGULAR OPTIONS'
               here (in case your default EDITOR is something like Emacs).
 
        -ipythondir <name>
-              The  name  of  your  IPython configuration directory IPYTHONDIR.
+              The  name  of  your  IPython configuration directory IPYTHON_DIR.
               This can also be  specified  through  the  environment  variable
-              IPYTHONDIR.
+              IPYTHON_DIR.
 
        -log|l Generate  a log file of all input. The file is named
               ipython_log.py in your current directory (which prevents logs
@@ -285,10 +201,10 b' REGULAR OPTIONS'
 
        -profile|p <name>
               Assume that your config file is ipythonrc-<name> (looks in  cur-
-              rent dir first, then in IPYTHONDIR). This is a quick way to keep
+              rent dir first, then in IPYTHON_DIR). This is a quick way to keep
               and load multiple config files for different  tasks,  especially
               if  you  use  the include option of config files. You can keep a
-              basic IPYTHONDIR/ipythonrc file and then have  other  'profiles'
+              basic IPYTHON_DIR/ipythonrc file and then have  other  'profiles'
               which  include  this  one  and  load extra things for particular
               tasks. For example:
 
@@ -329,7 +245,7 b' REGULAR OPTIONS'
        -rcfile <name>
               Name of your  IPython  resource  configuration  file.   normally
               IPython    loads   ipythonrc   (from   current   directory)   or
-              IPYTHONDIR/ipythonrc.  If the loading of your config file fails,
+              IPYTHON_DIR/ipythonrc.  If the loading of your config file fails,
               IPython  starts  with  a  bare  bones  configuration (no modules
               loaded at all).
 
@@ -368,7 +284,7 b' REGULAR OPTIONS'
               Simply removes all input/output separators.
 
        -upgrade
-              Allows you to upgrade your  IPYTHONDIR  configuration  when  you
+              Allows you to upgrade your  IPYTHON_DIR  configuration  when  you
               install  a  new  version  of  IPython.   Since  new versions may
               include new command lines options or example files, this  copies
               updated ipythonrc-type files.  However, it backs up (with a .old
@@ -591,6 +507,18 b' MAIN FEATURES'
             >>> x = ,my_function /home/me    # syntax error
 """
 
+interactive_usage_min =  """\
+An enhanced console for Python.
+Some of its features are:
+- Readline support if the readline library is present.
+- Tab completion in the local namespace.
+- Logging of input, see command-line options.
+- System shell escape via ! , eg !ls.
+- Magic commands, starting with a % (like %ls, %pwd, %cd, etc.)
+- Keeps track of locally defined variables via %who, %whos.
+- Show object information with a ? eg ?x or x? (use ?? for more info).
+"""
+
 quick_reference = r"""
 IPython -- An enhanced Interactive Python - Quick Reference Card
 ================================================================
@@ -643,3 +571,18 b' or python names.'
 The following magic functions are currently available:
 
 """
+
+quick_guide = """\
+?         -> Introduction and overview of IPython's features.
+%quickref -> Quick reference.
+help      -> Python's own help system.
+object?   -> Details about 'object'. ?object also works, ?? prints more."""
+
+default_banner_parts = [
+    'Python %s' % (sys.version.split('\n')[0],),
+    'Type "copyright", "credits" or "license" for more information.\n',
+    'IPython %s -- An enhanced Interactive Python.' % (release.version,),
+    quick_guide
+]
+
+default_banner = '\n'.join(default_banner_parts)

IPython/deathrow/Gnuplot2.py

@@ -25,7 +25,7 b' import types'
 import Gnuplot as Gnuplot_ori
 import Numeric
 
-from IPython.genutils import popkey,xsys
+from IPython.utils.genutils import popkey,xsys
 
 # needed by hardcopy():
 gp = Gnuplot_ori.gp

IPython/deathrow/GnuplotInteractive.py

@@ -16,7 +16,8 b" __all__ = ['Gnuplot','gp','gp_new','plot','plot2','splot','replot',"
            'gphelp']
 
 import IPython.GnuplotRuntime as GRun
-from IPython.genutils import page,warn
+from IPython.utils.genutils import warn
+from IPython.core.page import page
 
 # Set global names for interactive use
 Gnuplot  = GRun.Gnuplot
@@ -140,7 +141,7 b' else:'
     print """*** Type `gphelp` for help on the Gnuplot integration features."""
 
     # Add the new magic functions to the class dict
-    from IPython.iplib import InteractiveShell
+    from IPython.core.iplib import InteractiveShell
     InteractiveShell.magic_gpc = magic_gpc
     InteractiveShell.magic_gp_set_default = magic_gp_set_default
 

IPython/deathrow/GnuplotRuntime.py

@@ -53,7 +53,7 b" __all__ = ['Gnuplot','gp','gp_new','Data','File','Func','GridData',"
            'pm3d_config','eps_fix_bbox']
 
 import os,tempfile,sys
-from IPython.genutils import getoutput
+from IPython.utils.genutils import getoutput
 
 #---------------------------------------------------------------------------
 # Notes on mouse support for Gnuplot.py

IPython/deathrow/PhysicalQInput.py

@@ -52,7 +52,7 b' def prefilter_PQ(self,line,continuation):'
     imported."""
 
     from re import match
-    from IPython.iplib import InteractiveShell
+    from IPython.core.iplib import InteractiveShell
 
     # This regexp is what does the real work
     unit_split = match(r'\s*(\w+)\s*=\s*(-?\d*\.?\d*[eE]?-?\d*)\s+([a-zA-Z].*)',
@@ -74,7 +74,7 b' def prefilter_PQ(self,line,continuation):'
     return InteractiveShell._prefilter(self,line,continuation)
 
 # Rebind this to be the new IPython prefilter:
-from IPython.iplib import InteractiveShell
+from IPython.core.iplib import InteractiveShell
 InteractiveShell.prefilter = prefilter_PQ
 
 # Clean up the namespace.

IPython/deathrow/dtutils.py

@@ -10,8 +10,8 b' See the idoctest docstring below for usage details.'
 import doctest
 import sys
 
-import IPython.ipapi
-ip = IPython.ipapi.get()
+from IPython.core import ipapi
+ip = ipapi.get()
 
 def rundoctest(text,ns=None,eraise=False):
     """Run a the input source as a doctest, in the caller's namespace.
@@ -77,7 +77,7 b' def idoctest(ns=None,eraise=False):'
     if ns is None:
         ns = ip.user_ns
 
-    ip.IP.savehist()
+    ip.savehist()
     try:
         while True:
             line = raw_input()
@@ -96,7 +96,7 b' def idoctest(ns=None,eraise=False):'
         print "KeyboardInterrupt - Discarding input."
         run_test = False
     
-    ip.IP.reloadhist()
+    ip.reloadhist()
 
     if run_test:
         # Extra blank line at the end to ensure that the final docstring has a

IPython/deathrow/ibrowse.py

@@ -2,7 +2,7 b''
 
 import curses, fcntl, signal, struct, tty, textwrap, inspect
 
-from IPython import ipapi
+from IPython.core import ipapi
 
 import astyle, ipipe
 

IPython/deathrow/igrid.py

@@ -1,7 +1,7 b''
 # -*- coding: iso-8859-1 -*-
 
 import ipipe, os, webbrowser, urllib
-from IPython import ipapi
+from IPython.core import ipapi
 import wx
 import wx.grid, wx.html
 

IPython/deathrow/ipipe.py

@@ -133,12 +133,13 b' from IPython.external import simplegeneric'
 from IPython.external import path
 
 try:
-    from IPython import genutils, generics
+    from IPython.utils import genutils
+    from IPython.utils import generics
 except ImportError:
     genutils = None
     generics = None
 
-from IPython import ipapi
+from IPython.core import ipapi
 
 
 __all__ = [
@@ -1216,11 +1217,11 b' class ils(Table):'
     Examples::
 
         >>> ils
-        <class 'IPython.Extensions.ipipe.ils'>
+        <class 'IPython.extensions.ipipe.ils'>
         >>> ils("/usr/local/lib/python2.4")
-        IPython.Extensions.ipipe.ils('/usr/local/lib/python2.4')
+        IPython.extensions.ipipe.ils('/usr/local/lib/python2.4')
         >>> ils("~")
-        IPython.Extensions.ipipe.ils('/home/fperez')
+        IPython.extensions.ipipe.ils('/home/fperez')
         # all-random
     """
     def __init__(self, base=os.curdir, dirs=True, files=True):
@@ -1258,7 +1259,7 b' class iglob(Table):'
     Examples::
 
         >>> iglob("*.py")
-        IPython.Extensions.ipipe.iglob('*.py')
+        IPython.extensions.ipipe.iglob('*.py')
     """
     def __init__(self, glob):
         self.glob = glob
@@ -1284,11 +1285,11 b' class iwalk(Table):'
     List all files and directories in a directory and it's subdirectory::
 
         >>> iwalk
-        <class 'IPython.Extensions.ipipe.iwalk'>
+        <class 'IPython.extensions.ipipe.iwalk'>
         >>> iwalk("/usr/lib")
-        IPython.Extensions.ipipe.iwalk('/usr/lib')
+        IPython.extensions.ipipe.iwalk('/usr/lib')
         >>> iwalk("~")
-        IPython.Extensions.ipipe.iwalk('/home/fperez')  # random
+        IPython.extensions.ipipe.iwalk('/home/fperez')  # random
         
     """
     def __init__(self, base=os.curdir, dirs=True, files=True):
@@ -1393,7 +1394,7 b' class ipwd(Table):'
     Example::
 
         >>> ipwd | isort("uid")
-        <IPython.Extensions.ipipe.isort key='uid' reverse=False at 0x849efec>
+        <IPython.extensions.ipipe.isort key='uid' reverse=False at 0x849efec>
         # random
     """
     def __iter__(self):
@@ -1579,7 +1580,7 b' class ienv(Table):'
     Example::
 
         >>> ienv
-        <class 'IPython.Extensions.ipipe.ienv'>
+        <class 'IPython.extensions.ipipe.ienv'>
     """
 
     def __iter__(self):
@@ -1601,9 +1602,9 b' class ihist(Table):'
     Example::
 
         >>> ihist
-        <class 'IPython.Extensions.ipipe.ihist'>
+        <class 'IPython.extensions.ipipe.ihist'>
         >>> ihist(True) # raw mode
-        <IPython.Extensions.ipipe.ihist object at 0x849602c>  # random
+        <IPython.extensions.ipipe.ihist object at 0x849602c>  # random
     """
     def __init__(self, raw=True):
         self.raw = raw
@@ -1611,10 +1612,10 b' class ihist(Table):'
     def __iter__(self):
         api = ipapi.get()
         if self.raw:
-            for line in api.IP.input_hist_raw:
+            for line in api.input_hist_raw:
                 yield line.rstrip("\n")
         else:
-            for line in api.IP.input_hist:
+            for line in api.input_hist:
                 yield line.rstrip("\n")
 
 
@@ -1638,12 +1639,12 b' class ialias(Table):'
     Example::
 
         >>> ialias
-        <class 'IPython.Extensions.ipipe.ialias'>
+        <class 'IPython.extensions.ipipe.ialias'>
     """
     def __iter__(self):
         api = ipapi.get()
 
-        for (name, (args, command)) in api.IP.alias_table.iteritems():
+        for (name, (args, command)) in api.alias_manager.alias_table.iteritems():
             yield Alias(name, args, command)
 
 
@@ -1701,10 +1702,10 b' class ix(Table):'
     Examples::
 
         >>> ix("ps x")
-        IPython.Extensions.ipipe.ix('ps x')
+        IPython.extensions.ipipe.ix('ps x')
 
         >>> ix("find .") | ifile
-        <IPython.Extensions.ipipe.ieval expr=<class 'IPython.Extensions.ipipe.ifile'> at 0x8509d2c>
+        <IPython.extensions.ipipe.ieval expr=<class 'IPython.extensions.ipipe.ifile'> at 0x8509d2c>
         # random
     """
     def __init__(self, cmd):
@@ -1927,9 +1928,9 b' class isort(Pipe):'
     Examples::
 
         >>> ils | isort("size")
-        <IPython.Extensions.ipipe.isort key='size' reverse=False at 0x849ec2c>
+        <IPython.extensions.ipipe.isort key='size' reverse=False at 0x849ec2c>
         >>> ils | isort("_.isdir(), _.lower()", reverse=True)
-        <IPython.Extensions.ipipe.isort key='_.isdir(), _.lower()' reverse=True at 0x849eacc>
+        <IPython.extensions.ipipe.isort key='_.isdir(), _.lower()' reverse=True at 0x849eacc>
         # all-random
     """
 

IPython/deathrow/ipy_constants.py

@@ -15,7 +15,7 b' Website: physics.nist.gov/constants'
 # inspired by maxima's physconst.mac by Cliff Yapp
 
 #from math import * # math MUST be imported BEFORE PhysicalQInteractive 
-from IPython.Extensions.PhysicalQInteractive import PhysicalQuantityInteractive
+from IPython.extensions.PhysicalQInteractive import PhysicalQuantityInteractive
 
 # Math constants:
 

IPython/deathrow/ipy_defaults.py

@@ -12,9 +12,9 b' ipy_profile_PROFILENAME etc.'
 
 """
 
-import IPython.rlineimpl as readline
-import IPython.ipapi
-ip = IPython.ipapi.get()
+import IPython.utils.rlineimpl as readline
+from IPython.core import ipapi
+ip = ipapi.get()
 
 o = ip.options
 

IPython/deathrow/ipy_kitcfg.py

@@ -16,7 +16,7 b' def pylaunchers():'
     for f in fs:
         l = PyLauncher(f)
         n = os.path.splitext(f)[0]
-        ip.defalias(n, l)
+        ip.define_alias(n, l)
         ip.magic('store '+n)
 
 
@@ -39,7 +39,7 b' def main():'
         return
         
     os.environ["PATH"] = os.environ["PATH"] + ";" + kitroot() + "\\bin;"
-    ip.to_user_ns("pylaunchers")
+    ip.push("pylaunchers")
     cmds = ip.db.get('syscmdlist', None)
     if cmds is None:
         ip.magic('rehashx')
@@ -63,8 +63,8 b' def ipython_firstrun(ip):'
 
     print "First run of ipykit - configuring"
 
-    ip.defalias('py',selflaunch)
-    ip.defalias('d','dir /w /og /on')
+    ip.define_alias('py',selflaunch)
+    ip.define_alias('d','dir /w /og /on')
     ip.magic('store py')
     ip.magic('store d')
     

IPython/deathrow/ipy_legacy.py

@@ -9,12 +9,12 b' Stuff that is considered obsolete / redundant is gradually moved here.'
 
 """
 
-import IPython.ipapi
-ip = IPython.ipapi.get()
+from IPython.core import ipapi
+ip = ipapi.get()
 
 import os,sys
 
-from IPython.genutils import *
+from IPython.utils.genutils import *
 
 # use rehashx
 
@@ -43,7 +43,7 b" def magic_rehash(self, parameter_s = ''):"
     # aliases since %rehash will probably clobber them
     self.shell.init_auto_alias()
 
-ip.expose_magic("rehash", magic_rehash)
+ip.define_magic("rehash", magic_rehash)
 
 # Exit
 def magic_Quit(self, parameter_s=''):
@@ -51,7 +51,7 b" def magic_Quit(self, parameter_s=''):"
 
     self.shell.ask_exit()
 
-ip.expose_magic("Quit", magic_Quit)
+ip.define_magic("Quit", magic_Quit)
 
 
 # make it autocallable fn if you really need it
@@ -59,4 +59,4 b" def magic_p(self, parameter_s=''):"
     """Just a short alias for Python's 'print'."""
     exec 'print ' + parameter_s in self.shell.user_ns
 
-ip.expose_magic("p", magic_p)
+ip.define_magic("p", magic_p)

IPython/deathrow/ipy_p4.py

@@ -3,8 +3,8 b''
 Add %p4 magic for pythonic p4 (Perforce) usage.
 """
 
-import IPython.ipapi
-ip = IPython.ipapi.get()
+from IPython.core import ipapi
+ip = ipapi.get()
 
 import os,sys,marshal
 
@@ -25,9 +25,9 b" def p4_f(self, parameter_s=''):"
 def p4d(fname):
     return os.popen('p4 where ' + fname).read().split()[0]
     
-ip.to_user_ns("p4d")
+ip.push("p4d")
 
-ip.expose_magic('p4', p4_f)
+ip.define_magic('p4', p4_f)
 
 p4_commands = """\
 add admin annotate branch branches change changes changelist

IPython/deathrow/ipy_profile_numpy.py

@@ -5,11 +5,11 b' This profile loads the math/cmath modules as well as all of numpy.'
 It exposes numpy via the 'np' shorthand as well for convenience.
 """
 
-import IPython.ipapi
+from IPython.core import ipapi
 import ipy_defaults
 
 def main():
-    ip = IPython.ipapi.get()
+    ip = ipapi.get()
 
     try:
         ip.ex("import math,cmath")

IPython/deathrow/ipy_profile_scipy.py

@@ -6,11 +6,11 b" It exposes numpy and scipy via the 'np' and 'sp' shorthands as well for"
 convenience.
 """
 
-import IPython.ipapi
+from IPython.core import ipapi
 import ipy_defaults
 
 def main():
-    ip = IPython.ipapi.get()
+    ip = ipapi.get()
 
     try:
         ip.ex("import math,cmath")