Merging from 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/loader.py

@@ -0,0 +1,370 b''
+# coding: utf-8
+"""A simple configuration system.
+
+Authors
+-------
+* Brian Granger
+* Fernando Perez
+"""
+
+#-----------------------------------------------------------------------------
+#  Copyright (C) 2008-2009  The IPython Development Team
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
+import __builtin__
+import os
+import sys
+
+from IPython.external import argparse
+from IPython.utils.path import filefind
+
+#-----------------------------------------------------------------------------
+# Exceptions
+#-----------------------------------------------------------------------------
+
+
+class ConfigError(Exception):
+    pass
+
+
+class ConfigLoaderError(ConfigError):
+    pass
+
+#-----------------------------------------------------------------------------
+# Argparse fix
+#-----------------------------------------------------------------------------
+
+# Unfortunately argparse by default prints help messages to stderr instead of
+# stdout.  This makes it annoying to capture long help screens at the command
+# line, since one must know how to pipe stderr, which many users don't know how
+# to do.  So we override the print_help method with one that defaults to
+# stdout and use our class instead.
+
+class ArgumentParser(argparse.ArgumentParser):
+    """Simple argparse subclass that prints help to stdout by default."""
+    
+    def print_help(self, file=None):
+        if file is None:
+            file = sys.stdout
+        return super(ArgumentParser, self).print_help(file)
+    
+    print_help.__doc__ = argparse.ArgumentParser.print_help.__doc__
+    
+#-----------------------------------------------------------------------------
+# Config class for holding config information
+#-----------------------------------------------------------------------------
+
+
+class Config(dict):
+    """An attribute based dict that can do smart merges."""
+
+    def __init__(self, *args, **kwds):
+        dict.__init__(self, *args, **kwds)
+        # This sets self.__dict__ = self, but it has to be done this way
+        # because we are also overriding __setattr__.
+        dict.__setattr__(self, '__dict__', self)
+
+    def _merge(self, other):
+        to_update = {}
+        for k, v in other.items():
+            if not self.has_key(k):
+                to_update[k] = v
+            else: # I have this key
+                if isinstance(v, Config):
+                    # Recursively merge common sub Configs
+                    self[k]._merge(v)
+                else:
+                    # Plain updates for non-Configs
+                    to_update[k] = v
+
+        self.update(to_update)
+
+    def _is_section_key(self, key):
+        if key[0].upper()==key[0] and not key.startswith('_'):
+            return True
+        else:
+            return False
+
+    def has_key(self, key):
+        if self._is_section_key(key):
+            return True
+        else:
+            return dict.has_key(self, key)
+
+    def _has_section(self, key):
+        if self._is_section_key(key):
+            if dict.has_key(self, key):
+                return True
+        return False
+
+    def copy(self):
+        return type(self)(dict.copy(self))
+
+    def __copy__(self):
+        return self.copy()
+
+    def __deepcopy__(self, memo):
+        import copy
+        return type(self)(copy.deepcopy(self.items()))
+
+    def __getitem__(self, key):
+        # Because we use this for an exec namespace, we need to delegate
+        # the lookup of names in __builtin__ to itself.  This means
+        # that you can't have section or attribute names that are 
+        # builtins.
+        try:
+            return getattr(__builtin__, key)
+        except AttributeError:
+            pass
+        if self._is_section_key(key):
+            try:
+                return dict.__getitem__(self, key)
+            except KeyError:
+                c = Config()
+                dict.__setitem__(self, key, c)
+                return c
+        else:
+            return dict.__getitem__(self, key)
+
+    def __setitem__(self, key, value):
+        # Don't allow names in __builtin__ to be modified.
+        if hasattr(__builtin__, key):
+            raise ConfigError('Config variable names cannot have the same name '
+                              'as a Python builtin: %s' % key)
+        if self._is_section_key(key):
+            if not isinstance(value, Config):
+                raise ValueError('values whose keys begin with an uppercase '
+                                 'char must be Config instances: %r, %r' % (key, value))
+        else:
+            dict.__setitem__(self, key, value)
+
+    def __getattr__(self, key):
+        try:
+            return self.__getitem__(key)
+        except KeyError, e:
+            raise AttributeError(e)
+
+    def __setattr__(self, key, value):
+        try:
+            self.__setitem__(key, value)
+        except KeyError, e:
+            raise AttributeError(e)
+
+    def __delattr__(self, key):
+        try:
+            dict.__delitem__(self, key)
+        except KeyError, e:
+            raise AttributeError(e)
+
+
+#-----------------------------------------------------------------------------
+# Config loading classes
+#-----------------------------------------------------------------------------
+
+
+class ConfigLoader(object):
+    """A object for loading configurations from just about anywhere.
+    
+    The resulting configuration is packaged as a :class:`Struct`.
+    
+    Notes
+    -----
+    A :class:`ConfigLoader` does one thing: load a config from a source 
+    (file, command line arguments) and returns the data as a :class:`Struct`.
+    There are lots of things that :class:`ConfigLoader` does not do.  It does
+    not implement complex logic for finding config files.  It does not handle
+    default values or merge multiple configs.  These things need to be 
+    handled elsewhere.
+    """
+
+    def __init__(self):
+        """A base class for config loaders.
+        
+        Examples
+        --------
+        
+        >>> cl = ConfigLoader()
+        >>> config = cl.load_config()
+        >>> config
+        {}
+        """
+        self.clear()
+
+    def clear(self):
+        self.config = Config()
+
+    def load_config(self):
+        """Load a config from somewhere, return a :class:`Config` instance.
+        
+        Usually, this will cause self.config to be set and then returned.
+        However, in most cases, :meth:`ConfigLoader.clear` should be called
+        to erase any previous state.
+        """
+        self.clear()
+        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.clear()
+        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 ArgParseConfigLoader(CommandLineConfigLoader):
+
+    def __init__(self, argv=None, *parser_args, **parser_kw):
+        """Create a config loader for use with argparse.
+
+        Parameters
+        ----------
+
+        argv : optional, list
+          If given, used to read command-line arguments from, otherwise
+          sys.argv[1:] is used.
+
+        parser_args : tuple
+          A tuple of positional arguments that will be passed to the
+          constructor of :class:`argparse.ArgumentParser`.
+
+        parser_kw : dict
+          A tuple of keyword arguments that will be passed to the
+          constructor of :class:`argparse.ArgumentParser`.
+        """
+        super(CommandLineConfigLoader, self).__init__()
+        if argv == None:
+            argv = sys.argv[1:]
+        self.argv = argv
+        self.parser_args = parser_args
+        kwargs = dict(argument_default=argparse.SUPPRESS)
+        kwargs.update(parser_kw)
+        self.parser_kw = kwargs
+
+    def load_config(self, args=None):
+        """Parse command line arguments and return as a Struct.
+
+        Parameters
+        ----------
+
+        args : optional, list
+          If given, a list with the structure of sys.argv[1:] to parse
+          arguments from. If not given, the instance's self.argv attribute
+          (given at construction time) is used."""
+        self.clear()
+        if args is None:
+            args = self.argv
+        self._create_parser()
+        self._parse_args(args)
+        self._convert_to_config()
+        return self.config
+
+    def get_extra_args(self):
+        if hasattr(self, 'extra_args'):
+            return self.extra_args
+        else:
+            return []
+
+    def _create_parser(self):
+        self.parser = ArgumentParser(*self.parser_args, **self.parser_kw)
+        self._add_arguments()
+
+    def _add_arguments(self):
+        raise NotImplementedError("subclasses must implement _add_arguments")
+
+    def _parse_args(self, args):
+        """self.parser->self.parsed_data""" 
+        self.parsed_data, self.extra_args = self.parser.parse_known_args(args)
+
+    def _convert_to_config(self):
+        """self.parsed_data->self.config"""
+        for k, v in vars(self.parsed_data).items():
+            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,174 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 = """
+c = get_config()
+c.a = 10
+c.b = 20
+c.Foo.Bar.value = 10
+c.Foo.Bam.value = range(10)
+c.D.C.value = 'hi there'
+"""
+
+class TestPyFileCL(TestCase):
+
+    def test_basic(self):
+        fd, fname = mkstemp('.py')
+        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 MyLoader1(ArgParseConfigLoader):
+    def _add_arguments(self):
+        p = self.parser
+        p.add_argument('-f', '--foo', dest='Global.foo', type=str)
+        p.add_argument('-b', dest='MyClass.bar', type=int)
+        p.add_argument('-n', dest='n', action='store_true')
+        p.add_argument('Global.bam', type=str)
+
+class MyLoader2(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')
+
+class TestArgParseCL(TestCase):
+
+    def test_basic(self):
+        cl = MyLoader1()
+        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')
+        config = cl.load_config(['wow'])
+        self.assertEquals(config.keys(), ['Global'])
+        self.assertEquals(config.Global.keys(), ['bam'])
+        self.assertEquals(config.Global.bam, 'wow')
+
+    def test_add_arguments(self):
+        cl = MyLoader2()
+        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')
+
+    def test_argv(self):
+        cl = MyLoader1(argv='-f hi -b 10 -n wow'.split())
+        config = cl.load_config()
+        self.assertEquals(config.Global.foo, 'hi')
+        self.assertEquals(config.MyClass.bar, 10)
+        self.assertEquals(config.n, True)
+        self.assertEquals(config.Global.bam, 'wow')
+
+
+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 List
+from IPython.utils.autoattr import auto_attr
+from IPython.utils.warn import warn, error
+
+#-----------------------------------------------------------------------------
+# 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,453 b''
+# encoding: utf-8
+"""
+An application for IPython.
+
+All top-level applications should use the classes in this module for
+handling configuration and creating componenets.
+
+The job of an :class:`Application` is to create the master configuration 
+object and then create the components, passing the config to them.
+
+Authors:
+
+* Brian Granger
+* Fernando Perez
+
+Notes
+-----
+"""
+
+#-----------------------------------------------------------------------------
+#  Copyright (C) 2008-2009  The IPython Development Team
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
+import logging
+import os
+import sys
+
+from IPython.core import release, crashhandler
+from IPython.utils.path import get_ipython_dir, get_ipython_package_dir
+from IPython.config.loader import (
+    PyFileConfigLoader,
+    ArgParseConfigLoader,
+    Config,
+)
+
+#-----------------------------------------------------------------------------
+# Classes and functions
+#-----------------------------------------------------------------------------
+
+class ApplicationError(Exception):
+    pass
+
+
+class BaseAppConfigLoader(ArgParseConfigLoader):
+    """Default command line options for IPython based applications."""
+
+    def _add_ipython_dir(self, parser):
+        """Add the --ipython-dir option to the parser."""
+        paa = parser.add_argument
+        paa('--ipython-dir', 
+            dest='Global.ipython_dir',type=unicode,
+            help=
+            """Set to override default location of the IPython directory
+            IPYTHON_DIR, stored as Global.ipython_dir.  This can also be 
+            specified through the environment variable IPYTHON_DIR.""",
+            metavar='Global.ipython_dir')
+
+    def _add_log_level(self, parser):
+        """Add the --log-level option to the parser."""
+        paa = parser.add_argument
+        paa('--log-level',
+            dest="Global.log_level",type=int,
+            help='Set the log level (0,10,20,30,40,50).  Default is 30.',
+            metavar='Global.log_level')
+
+    def _add_arguments(self):
+        self._add_ipython_dir(self.parser)
+        self._add_log_level(self.parser)
+
+
+class Application(object):
+    """Load a config, construct components and set them running.
+
+    The configuration of an application can be done via three different Config
+    objects, which are loaded and ultimately merged into a single one used
+    from that point on by the app. These are:
+
+    1. default_config: internal defaults, implemented in code.
+    2. file_config: read from the filesystem.
+    3. command_line_config: read from the system's command line flags.
+
+    During initialization, 3 is actually read before 2, since at the
+    command-line one may override the location of the file to be read.  But the
+    above is the order in which the merge is made.
+    """
+
+    name = u'ipython'
+    description = 'IPython: an enhanced interactive Python shell.'
+    #: Usage message printed by argparse. If None, auto-generate
+    usage = None
+    #: The command line config loader.  Subclass of ArgParseConfigLoader.
+    command_line_loader = BaseAppConfigLoader
+    #: The name of the config file to load, determined at runtime
+    config_file_name = None
+    #: The name of the default config file. Track separately from the actual
+    #: name because some logic happens only if we aren't using the default.
+    default_config_file_name = u'ipython_config.py'
+    default_log_level = logging.WARN
+    #: Set by --profile option
+    profile_name = None
+    #: User's ipython directory, typically ~/.ipython/
+    ipython_dir = None
+    #: Internal defaults, implemented in code.
+    default_config = None
+    #: Read from the filesystem.
+    file_config = None
+    #: Read from the system's command line flags.
+    command_line_config = None
+    #: The final config that will be passed to the component.
+    master_config = None
+    #: A reference to the argv to be used (typically ends up being sys.argv[1:])
+    argv = None
+    #: extra arguments computed by the command-line loader
+    extra_args = None
+    #: The class to use as the crash handler.
+    crash_handler_class = crashhandler.CrashHandler
+
+    # Private attributes
+    _exiting = False
+    _initialized = False
+
+    def __init__(self, argv=None):
+        self.argv = sys.argv[1:] if argv is None else argv
+        self.init_logger()
+
+    def init_logger(self):
+        self.log = logging.getLogger(self.__class__.__name__)
+        # This is used as the default until the command line arguments are read.
+        self.log.setLevel(self.default_log_level)
+        self._log_handler = logging.StreamHandler()
+        self._log_formatter = logging.Formatter("[%(name)s] %(message)s")
+        self._log_handler.setFormatter(self._log_formatter)
+        self.log.addHandler(self._log_handler)
+
+    def _set_log_level(self, level):
+        self.log.setLevel(level)
+
+    def _get_log_level(self):
+        return self.log.level
+
+    log_level = property(_get_log_level, _set_log_level)
+
+    def initialize(self):
+        """Initialize the application.
+
+        Loads all configuration information and sets all application state, but
+        does not start any relevant processing (typically some kind of event
+        loop).
+
+        Once this method has been called, the application is flagged as
+        initialized and the method becomes a no-op."""
+        
+        if self._initialized:
+            return
+
+        # The first part is protected with an 'attempt' wrapper, that will log
+        # failures with the basic system traceback machinery.  Once our crash
+        # handler is in place, we can let any subsequent exception propagate,
+        # as our handler will log it with much better detail than the default.
+        self.attempt(self.create_crash_handler)
+
+        # Configuration phase
+        # Default config (internally hardwired in application code)
+        self.create_default_config()
+        self.log_default_config()
+        self.set_default_config_log_level()
+
+        # Command-line config
+        self.pre_load_command_line_config()
+        self.load_command_line_config()
+        self.set_command_line_config_log_level()
+        self.post_load_command_line_config()
+        self.log_command_line_config()
+
+        # Find resources needed for filesystem access, using information from
+        # the above two
+        self.find_ipython_dir()
+        self.find_resources()
+        self.find_config_file_name()
+        self.find_config_file_paths()
+
+        # File-based config
+        self.pre_load_file_config()
+        self.load_file_config()
+        self.set_file_config_log_level()
+        self.post_load_file_config()
+        self.log_file_config()
+
+        # Merge all config objects into a single one the app can then use
+        self.merge_configs()
+        self.log_master_config()
+
+        # Construction phase
+        self.pre_construct()
+        self.construct()
+        self.post_construct()
+
+        # Done, flag as such and
+        self._initialized = True
+
+    def start(self):
+        """Start the application."""
+        self.initialize()
+        self.start_app()
+
+    #-------------------------------------------------------------------------
+    # Various stages of Application creation
+    #-------------------------------------------------------------------------
+
+    def create_crash_handler(self):
+        """Create a crash handler, typically setting sys.excepthook to it."""
+        self.crash_handler = self.crash_handler_class(self)
+        sys.excepthook = self.crash_handler
+
+    def create_default_config(self):
+        """Create defaults that can't be set elsewhere.
+
+        For the most part, we try to set default in the class attributes
+        of Components.  But, defaults the top-level Application (which is
+        not a HasTraitlets or Component) are not set in this way.  Instead
+        we set them here.  The Global section is for variables like this that
+        don't belong to a particular component.
+        """
+        c = Config()
+        c.Global.ipython_dir = get_ipython_dir()
+        c.Global.log_level = self.log_level
+        self.default_config = c
+
+    def log_default_config(self):
+        self.log.debug('Default config loaded:')
+        self.log.debug(repr(self.default_config))
+
+    def set_default_config_log_level(self):
+        try:
+            self.log_level = self.default_config.Global.log_level
+        except AttributeError:
+            # Fallback to the default_log_level class attribute
+            pass
+
+    def create_command_line_config(self):
+        """Create and return a command line config loader."""
+        return self.command_line_loader(
+            self.argv,
+            description=self.description, 
+            version=release.version,
+            usage=self.usage
+        )
+
+    def pre_load_command_line_config(self):
+        """Do actions just before loading the command line config."""
+        pass
+
+    def load_command_line_config(self):
+        """Load the command line config."""
+        loader = self.create_command_line_config()
+        self.command_line_config = loader.load_config()
+        self.extra_args = loader.get_extra_args()
+
+    def set_command_line_config_log_level(self):
+        try:
+            self.log_level = self.command_line_config.Global.log_level
+        except AttributeError:
+            pass
+
+    def post_load_command_line_config(self):
+        """Do actions just after loading the command line config."""
+        pass
+
+    def log_command_line_config(self):
+        self.log.debug("Command line config loaded:")
+        self.log.debug(repr(self.command_line_config))
+
+    def find_ipython_dir(self):
+        """Set the IPython directory.
+
+        This sets ``self.ipython_dir``, but the actual value that is passed to
+        the application is kept in either ``self.default_config`` or
+        ``self.command_line_config``.  This also adds ``self.ipython_dir`` to
+        ``sys.path`` so config files there can be referenced by other config
+        files.
+        """
+
+        try:
+            self.ipython_dir = self.command_line_config.Global.ipython_dir
+        except AttributeError:
+            self.ipython_dir = self.default_config.Global.ipython_dir
+        sys.path.append(os.path.abspath(self.ipython_dir))
+        if not os.path.isdir(self.ipython_dir):
+            os.makedirs(self.ipython_dir, mode=0777)
+        self.log.debug("IPYTHON_DIR set to: %s" % self.ipython_dir)
+
+    def find_resources(self):
+        """Find other resources that need to be in place.
+
+        Things like cluster directories need to be in place to find the
+        config file.  These happen right after the IPython directory has
+        been set.
+        """
+        pass
+
+    def find_config_file_name(self):
+        """Find the config file name for this application.
+
+        This must set ``self.config_file_name`` to the filename of the
+        config file to use (just the filename). The search paths for the
+        config file are set in :meth:`find_config_file_paths` and then passed
+        to the config file loader where they are resolved to an absolute path.
+
+        If a profile has been set at the command line, this will resolve it.
+        """
+        try:
+            self.config_file_name = self.command_line_config.Global.config_file
+        except AttributeError:
+            pass
+        else:
+            return
+
+        try:
+            self.profile_name = self.command_line_config.Global.profile
+        except AttributeError:
+            # Just use the default as there is no profile
+            self.config_file_name = self.default_config_file_name
+        else:
+            # Use the default config file name and profile name if set
+            # to determine the used config file name.
+            name_parts = self.default_config_file_name.split('.')
+            name_parts.insert(1, u'_' + self.profile_name + u'.')
+            self.config_file_name = ''.join(name_parts)
+
+    def find_config_file_paths(self):
+        """Set the search paths for resolving the config file.
+
+        This must set ``self.config_file_paths`` to a sequence of search
+        paths to pass to the config file loader.
+        """
+        # Include our own profiles directory last, so that users can still find
+        # our shipped copies of builtin profiles even if they don't have them
+        # in their local ipython directory.
+        prof_dir = os.path.join(get_ipython_package_dir(), 'config', 'profile')
+        self.config_file_paths = (os.getcwd(), self.ipython_dir, prof_dir)
+
+    def pre_load_file_config(self):
+        """Do actions before the config file is loaded."""
+        pass
+
+    def load_file_config(self):
+        """Load the config file.
+        
+        This tries to load the config file from disk.  If successful, the
+        ``CONFIG_FILE`` config variable is set to the resolved config file
+        location.  If not successful, an empty config is used.
+        """
+        self.log.debug("Attempting to load config file: %s" %
+                       self.config_file_name)
+        loader = PyFileConfigLoader(self.config_file_name,
+                                    path=self.config_file_paths)
+        try:
+            self.file_config = loader.load_config()
+            self.file_config.Global.config_file = loader.full_filename
+        except IOError:
+            # Only warn if the default config file was NOT being used.
+            if not self.config_file_name==self.default_config_file_name:
+                self.log.warn("Config file not found, skipping: %s" %
+                               self.config_file_name, exc_info=True)
+            self.file_config = Config()
+        except:
+            self.log.warn("Error loading config file: %s" %
+                          self.config_file_name, exc_info=True)
+            self.file_config = Config()
+
+    def set_file_config_log_level(self):
+        # We need to keeep self.log_level updated.  But we only use the value
+        # of the file_config if a value was not specified at the command
+        # line, because the command line overrides everything.
+        if not hasattr(self.command_line_config.Global, 'log_level'):
+            try:
+                self.log_level = self.file_config.Global.log_level
+            except AttributeError:
+                pass # Use existing value
+
+    def post_load_file_config(self):
+        """Do actions after the config file is loaded."""
+        pass
+
+    def log_file_config(self):
+        if hasattr(self.file_config.Global, 'config_file'):
+            self.log.debug("Config file loaded: %s" %
+                           self.file_config.Global.config_file)
+            self.log.debug(repr(self.file_config))
+
+    def merge_configs(self):
+        """Merge the default, command line and file config objects."""
+        config = Config()
+        config._merge(self.default_config)
+        config._merge(self.file_config)
+        config._merge(self.command_line_config)
+
+        # XXX fperez - propose to Brian we rename master_config to simply
+        # config, I think this is going to be heavily used in examples and
+        # application code and the name is shorter/easier to find/remember.
+        # For now, just alias it...
+        self.master_config = config
+        self.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 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):
+        try:
+            func()
+        except SystemExit:
+            raise
+        except:
+            self.log.critical("Aborting application: %s" % self.name,
+                              exc_info=True)
+            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, 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/crashhandler.py

@@ -0,0 +1,180 b''
+# encoding: utf-8
+"""sys.excepthook for IPython itself, leaves a detailed report on disk.
+
+Authors:
+
+* Fernando Perez
+* Brian E. Granger
+"""
+
+#-----------------------------------------------------------------------------
+#  Copyright (C) 2001-2007 Fernando Perez. <[e-mail]>
+#  Copyright (C) 2008-2010  The IPython Development Team
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
+import os
+import sys
+from pprint import pformat
+
+from IPython.core import ultratb
+from IPython.external.Itpl import itpl
+from IPython.utils.sysinfo import sys_info
+
+#-----------------------------------------------------------------------------
+# Code
+#-----------------------------------------------------------------------------
+
+# Template for the user message.
+_default_message_template = """\
+Oops, $self.app_name crashed. We do our best to make it stable, but...
+
+A crash report was automatically generated with the following information:
+  - A verbatim copy of the crash traceback.
+  - A copy of your input history during this session.
+  - Data on your current $self.app_name configuration.
+
+It was left in the file named:
+\t'$self.crash_report_fname'
+If you can email this file to the developers, the information in it will help
+them in understanding and correcting the problem.
+
+You can mail it to: $self.contact_name at $self.contact_email
+with the subject '$self.app_name Crash Report'.
+
+If you want to do it now, the following command will work (under Unix):
+mail -s '$self.app_name Crash Report' $self.contact_email < $self.crash_report_fname
+
+To ensure accurate tracking of this issue, please file a report about it at:
+$self.bug_tracker
+"""
+
+
+class CrashHandler(object):
+    """Customizable crash handlers for IPython applications.
+
+    Instances of this class provide a :meth:`__call__` method which can be
+    used as a ``sys.excepthook``.  The :meth:`__call__` signature is::
+
+        def __call__(self, etype, evalue, etb)
+    """
+
+    message_template = _default_message_template
+
+    def __init__(self, app, contact_name=None, contact_email=None, 
+                 bug_tracker=None, show_crash_traceback=True, call_pdb=False):
+        """Create a new crash handler
+
+        Parameters
+        ----------
+        app :  Application
+            A running :class:`Application` instance, which will be queried at 
+            crash time for internal information.
+
+        contact_name : str
+            A string with the name of the person to contact.
+
+        contact_email : str
+            A string with the email address of the contact.
+
+        bug_tracker : str
+            A string with the URL for your project's bug tracker.
+
+        show_crash_traceback : bool
+            If false, don't print the crash traceback on stderr, only generate
+            the on-disk report
+
+        Non-argument instance attributes:
+
+        These instances contain some non-argument attributes which allow for
+        further customization of the crash handler's behavior. Please see the
+        source for further details.
+        """
+        self.app = app
+        self.app_name = self.app.name
+        self.contact_name = contact_name
+        self.contact_email = contact_email
+        self.bug_tracker = bug_tracker
+        self.crash_report_fname = "Crash_report_%s.txt" % self.app_name
+        self.show_crash_traceback = show_crash_traceback
+        self.section_sep = '\n\n'+'*'*75+'\n\n'
+        self.call_pdb = call_pdb
+        #self.call_pdb = True # dbg
+
+    def __call__(self, etype, evalue, etb):
+        """Handle an exception, call for compatible with sys.excepthook"""
+
+        # Report tracebacks shouldn't use color in general (safer for users)
+        color_scheme = 'NoColor'
+
+        # Use this ONLY for developer debugging (keep commented out for release)
+        #color_scheme = 'Linux'   # dbg
+        
+        try:
+            rptdir = self.app.ipython_dir
+        except:
+            rptdir = os.getcwd()
+        if not os.path.isdir(rptdir):
+            rptdir = os.getcwd()
+        report_name = os.path.join(rptdir,self.crash_report_fname)
+        # 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,
+            long_header=1,
+            call_pdb=self.call_pdb,
+        )
+        if self.call_pdb:
+            TBhandler(etype,evalue,etb)
+            return
+        else:
+            traceback = TBhandler.text(etype,evalue,etb,context=31)
+
+        # print traceback to screen
+        if self.show_crash_traceback:
+            print >> sys.stderr, traceback
+
+        # and generate a complete report on disk
+        try:
+            report = open(report_name,'w')
+        except:
+            print >> sys.stderr, 'Could not create crash report on disk.'
+            return
+
+        # Inform user on stderr of what happened
+        msg = itpl('\n'+'*'*70+'\n'+self.message_template)
+        print >> sys.stderr, msg
+
+        # Construct report on disk
+        report.write(self.make_report(traceback))
+        report.close()
+        raw_input("Hit <Enter> to quit this message (your terminal may close):")
+
+    def make_report(self,traceback):
+        """Return a string containing a crash report."""
+        
+        sec_sep = self.section_sep
+        
+        report = ['*'*75+'\n\n'+'IPython post-mortem report\n\n']
+        rpt_add = report.append
+        rpt_add(sys_info())
+        
+        try:
+            config = pformat(self.app.config)
+            rpt_add(sec_sep)
+            rpt_add('Application name: %s\n\n' % self.app_name)
+            rpt_add('Current user configuration structure:\n\n')
+            rpt_add(config)
+        except:
+            pass
+        rpt_add(sec_sep+'Crash traceback:\n\n' + traceback)
+
+        return ''.join(report)
+

IPython/core/display_trap.py

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

IPython/core/iplib.py

@@ -0,0 +1,2561 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
+from __future__ import absolute_import
+
+import __builtin__
+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 debugger, oinspect
+from IPython.core import history as ipcorehist
+from IPython.core import prefilter
+from IPython.core import shadowns
+from IPython.core import ultratb
+from IPython.core.alias import AliasManager
+from IPython.core.builtin_trap import BuiltinTrap
+from IPython.core.component import Component
+from IPython.core.display_trap import DisplayTrap
+from IPython.core.error import TryNext, UsageError
+from IPython.core.fakemodule import FakeModule, init_fakemod_dict
+from IPython.core.logger import Logger
+from IPython.core.magic import Magic
+from IPython.core.prefilter import PrefilterManager
+from IPython.core.prompts import CachedOutput
+from IPython.core.usage import interactive_usage, default_banner
+import IPython.core.hooks
+from IPython.external.Itpl import ItplNS
+from IPython.lib.inputhook import enable_gui
+from IPython.lib.backgroundjobs import BackgroundJobManager
+from IPython.lib.pylabtools import pylab_activate
+from IPython.utils import PyColorize
+from IPython.utils import pickleshare
+from IPython.utils.doctestreload import doctest_reload
+from IPython.utils.ipstruct import Struct
+from IPython.utils.io import Term, ask_yes_no
+from IPython.utils.path import get_home_dir, get_ipython_dir, HomeDirError
+from IPython.utils.process import (
+    abbrev_cwd,
+    getoutput,
+    getoutputerror
+)
+# import IPython.utils.rlineimpl as readline
+from IPython.utils.strdispatch import StrDispatch
+from IPython.utils.syspathcontext import prepended_to_syspath
+from IPython.utils.terminal import toggle_set_term_title, set_term_title
+from IPython.utils.warn import warn, error, fatal
+from IPython.utils.traitlets import (
+    Int, Str, CBool, CaselessStrEnum, Enum, List, Unicode
+)
+
+# from IPython.utils import growl
+# growl.start("IPython")
+
+#-----------------------------------------------------------------------------
+# 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
+
+
+def no_op(*a, **kw): pass
+
+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 the currently running IPython instance."""
+        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.
+        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 separately tracked in the ns_table.
+        self.user_ns_hidden = {}
+
+        # 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_ns_hidden,
+                               self.internal_ns, self._main_ns_cache ]
+
+    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 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.
+        """
+
+
+        # We must ensure that __builtin__ (without the final 's') is always
+        # available and pointing to the __builtin__ *module*.  For more details:
+        # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
+
+        if user_ns is None:
+            # Set __name__ to __main__ to better match the behavior of the
+            # normal interpreter.
+            user_ns = {'__name__'     :'__main__',
+                       '__builtin__' : __builtin__,
+                       '__builtins__' : __builtin__,
+                      }
+        else:
+            user_ns.setdefault('__name__','__main__')
+            user_ns.setdefault('__builtin__',__builtin__)
+            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_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 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.
+        """
+        # This function works in two parts: first we put a few things in
+        # user_ns, and we sync that contents into user_ns_hidden so that these
+        # initial variables aren't shown by %who.  After the sync, we add the
+        # rest of what we *do* want the user to see with %who even on a new
+        # session (probably nothing, so theye really only see their own stuff)
+
+        # The user dict must *always* have a __builtin__ reference to the
+        # Python standard __builtin__ namespace,  which must be imported.
+        # This is so that certain operations in prompt evaluation can be
+        # reliably executed with builtins.  Note that we can NOT use
+        # __builtins__ (note the 's'),  because that can either be a dict or a
+        # module, and can even mutate at runtime, depending on the context
+        # (Python makes no guarantees on it).  In contrast, __builtin__ is
+        # always a module object, though it must be explicitly imported.
+        
+        # For more details:
+        # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
+        ns = dict(__builtin__ = __builtin__)
+        
+        # Put 'help' in the user namespace
+        try:
+            from site import _Helper
+            ns['help'] = _Helper()
+        except ImportError:
+            warn('help() not available - check site.py')
+
+        # make global variables for user access to the histories
+        ns['_ih'] = self.input_hist
+        ns['_oh'] = self.output_hist
+        ns['_dh'] = self.dir_hist
+
+        ns['_sh'] = shadowns
+
+        # user aliases to input and output histories.  These shouldn't show up
+        # in %who, as they can have very large reprs.
+        ns['In']  = self.input_hist
+        ns['Out'] = self.output_hist
+
+        # Store myself as the public api!!!
+        ns['get_ipython'] = self.get_ipython
+
+        # Sync what we've added so far to user_ns_hidden so these aren't seen
+        # by %who
+        self.user_ns_hidden.update(ns)
+
+        # Anything put into ns now would show up in %who.  Think twice before
+        # putting anything here, as we really want %who to show the user their
+        # stuff, not our variables.
+        
+        # Finally, update the real user's namespace
+        self.user_ns.update(ns)
+
+
+    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_ns_hidden
+        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)."""
+
+        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."""
+
+        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 self.has_readline:
+            from IPython.utils import rlineimpl as readline
+        else:
+            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)
+
+        # The instance will store a pointer to the system-wide exception hook,
+        # so that runtime code (such as magics) can access it.  This is because
+        # during the read-eval loop, it may get temporarily overwritten.
+        self.sys_excepthook = sys.excepthook
+
+        # and add any custom exception handlers the user may have specified
+        self.set_custom_exc(*custom_exceptions)
+
+        # Set the exception mode
+        self.InteractiveTB.set_mode(mode=self.xmode)
+
+    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,
+                      exception_only=False):
+        """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."""
+        
+        try:
+            if exc_tuple is None:
+                etype, value, tb = sys.exc_info()
+            else:
+                etype, value, tb = exc_tuple
+
+            if etype is None:
+                if hasattr(sys, 'last_type'):
+                    etype, value, tb = sys.last_type, sys.last_value, \
+                                       sys.last_traceback
+                else:
+                    self.write('No traceback available to show.\n')
+                    return
+    
+            if etype is SyntaxError:
+                # Though this won't be called by syntax errors in the input
+                # line, there may be SyntaxError cases whith imported code.
+                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:
+                    if exception_only:
+                        m = ('An exception has occurred, use %tb to see the '
+                             'full traceback.')
+                        print m
+                        self.InteractiveTB.show_exception_only(etype, value)
+                    else:
+                        self.InteractiveTB(etype,value,tb,tb_offset=tb_offset)
+                        if self.InteractiveTB.call_pdb:
+                            # 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() above
+        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."""
+
+        if self.readline_use:
+            import IPython.utils.rlineimpl as readline
+                  
+        self.rl_next_input = None
+        self.rl_do_indent = False
+
+        if not self.readline_use or not readline.have_readline:
+            self.has_readline = False
+            self.readline = None
+            # Set a number of methods that depend on readline to be no-op
+            self.savehist = no_op
+            self.reloadhist = no_op
+            self.set_completer = no_op
+            self.set_custom_completer = no_op
+            self.set_completer_frame = no_op
+            warn('Readline services not available or not loaded.')
+        else:
+            self.has_readline = True
+            self.readline = readline
+            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)
+            
+            # 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)
+        # History was moved to a separate module
+        from . import history
+        history.init_ipython(self)
+
+    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
+                    if self.has_readline:
+                        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
+
+        # Turn off the exit flag, so the mainloop can be restarted if desired
+        self.exit_now = False
+
+    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 silence SystemExit for non-zero status (it is always
+            silenced for zero status, as it is so common).
+        """
+        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:
+                execfile(fname,*where)
+            except SystemExit, status:
+                # If the call was made with 0 or None exit status (sys.exit(0)
+                # or sys.exit() ), don't bother showing a traceback, as both of
+                # these are considered normal by the OS:
+                # > python -c'import sys;sys.exit(0)'; echo $?
+                # 0
+                # > python -c'import sys;sys.exit()'; echo $?
+                # 0
+                # For other exit status, we show the exception unless
+                # explicitly silenced, but only in short form.
+                if status.code not in (0, None) and not kw['exit_ignore']:
+                    self.showtraceback(exception_only=True)
+            except:
+                self.showtraceback()
+
+    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(exception_only=True)
+            warn("To exit: use any of 'exit', 'quit', %Exit or Ctrl-D.", 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.
+
+        If :func:`load_ipython_extension` returns anything, this function
+        will return that object.
+        """
+        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]
+        return 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'):
+            return mod.load_ipython_extension(self)
+
+    def _call_unload_ipython_extension(self, mod):
+        if hasattr(mod, 'unload_ipython_extension'):
+            return mod.unload_ipython_extension(self)
+
+    #-------------------------------------------------------------------------
+    # Things related to the prefilter
+    #-------------------------------------------------------------------------
+
+    def init_prefilter(self):
+        self.prefilter_manager = PrefilterManager(self, config=self.config)
+        # Ultimately this will be refactored in the new interpreter code, but
+        # for now, we should expose the main prefilter method (there's legacy
+        # code out there that may rely on this).
+        self.prefilter = self.prefilter_manager.prefilter_lines
+
+    #-------------------------------------------------------------------------
+    # 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 GUI support and pylab
+    #-------------------------------------------------------------------------
+
+    def enable_pylab(self, gui=None):
+        """Activate pylab support at runtime.
+
+        This turns on support for matplotlib, preloads into the interactive
+        namespace all of numpy and pylab, and configures IPython to correcdtly
+        interact with the GUI event loop.  The GUI backend to be used can be
+        optionally selected with the optional :param:`gui` argument.
+
+        Parameters
+        ----------
+        gui : optional, string
+
+          If given, dictates the choice of matplotlib GUI backend to use
+          (should be one of IPython's supported backends, 'tk', 'qt', 'wx' or
+          'gtk'), otherwise we use the default chosen by matplotlib (as
+          dictated by the matplotlib build-time options plus the user's
+          matplotlibrc configuration file).
+        """
+        # We want to prevent the loading of pylab to pollute the user's
+        # namespace as shown by the %who* magics, so we execute the activation
+        # code in an empty namespace, and we update *both* user_ns and
+        # user_ns_hidden with this information.
+        ns = {}
+        gui = pylab_activate(ns, gui)
+        self.user_ns.update(ns)
+        self.user_ns_hidden.update(ns)
+        # Now we must activate the gui pylab wants to use, and fix %run to take
+        # plot updates into account
+        enable_gui(gui)
+        self.magic_run = self._pylab_magic_run
+
+    #-------------------------------------------------------------------------
+    # Things related to IPython exiting
+    #-------------------------------------------------------------------------
+
+    def ask_exit(self):
+        """ Ask the shell to exit. 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/Shell.py

@@ -1,1244 +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
+from warnings import warn
 
-    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.
+msg = """
+This module (IPython.Shell) is deprecated.  The classes that were in this
+module have been replaced by:
 
-        This banner gets prepended to every header printed when the shell
-        instance is called."""
+IPShell->IPython.core.iplib.InteractiveShell
+IPShellEmbed->IPython.core.embed.InteractiveShellEmbed
 
-        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)")
-        res = ctypes.pythonapi.PyThreadState_SetAsyncExc(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)'.
+Please migrate your code to use these classes instead.
 """
-        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.
+warn(msg, category=DeprecationWarning, stacklevel=1)
 
-    """
-    def misc_mainloop(self, n=0):
-        pass
-    def tkinter_mainloop(n=0):
-        pass
-    
-    import Tkinter
-    Tkinter.Misc.mainloop = misc_mainloop
-    Tkinter.mainloop = tkinter_mainloop
+from IPython.core.iplib import InteractiveShell as IPShell
+from IPython.core.embed import InteractiveShellEmbed as IPShellEmbed
 
-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
+def start(user_ns=None, embedded=False):
+    """Return an instance of :class:`InteractiveShell`."""
+    if embedded:
+        return InteractiveShellEmbed(user_ns=user_ns)
     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.
-    
-    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):
-
-        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.
-    """
-    
-    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            
-
-    if 'tk' in special_opts:
-        USE_TK = True
-        special_opts.remove('tk')
-
-    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]
-    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,67 b''
-# -*- coding: utf-8 -*-
+#!/usr/bin/env python
+# encoding: utf-8
 """
-IPython -- An enhanced Interactive Python
+IPython.
 
-One of Python's nicest features is its interactive interpreter. This allows
-very fast testing of ideas without the overhead of creating test files as is
-typical in most programming languages. However, the interpreter supplied with
-the standard Python distribution is fairly primitive (and IDLE isn't really
-much better).
-
-IPython tries to:
-
-  i - provide an efficient environment for interactive work in Python
-  programming. It tries to address what we see as shortcomings of the standard
-  Python prompt, and adds many features to make interactive work much more
-  efficient.
-
-  ii - offer a flexible framework so that it can be used as the base
-  environment for other projects and problems where Python can be the
-  underlying language. Specifically scientific environments like Mathematica,
-  IDL and Mathcad inspired its design, but similar ideas can be useful in many
-  fields. Python is a fabulous language for implementing this kind of system
-  (due to its dynamic and introspective features), and with suitable libraries
-  entire systems could be built leveraging Python's power.
-
-  iii - serve as an embeddable, ready to go interpreter for your own programs.
-
-IPython requires Python 2.4 or newer.
+IPython is a set of tools for interactive and exploratory computing in Python.
 """
 
-#*****************************************************************************
-#       Copyright (C) 2008-2009 The IPython Development Team
-#       Copyright (C) 2001-2007 Fernando Perez. <[e-mail]>
+#-----------------------------------------------------------------------------
+#  Copyright (C) 2008-2009  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
-#*****************************************************************************
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+from __future__ import absolute_import
 
-# Enforce proper version requirements
+import os
 import sys
 
-if sys.version[0:3] < '2.4':
-    raise ImportError('Python Version 2.4 or above is required for IPython.')
+#-----------------------------------------------------------------------------
+# Setup everything
+#-----------------------------------------------------------------------------
+
+if sys.version[0:3] < '2.5':
+    raise ImportError('Python Version 2.5 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.
+# This should probably be in ipapp.py.
+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,[])
+from .config.loader import Config
+from .core import release
+from .core.application import Application
+from .core.ipapp import IPythonApp
+from .core.embed import embed
+from .core.error import TryNext
+from .core.iplib import InteractiveShell
+from .testing import test
 
-import Shell
+from .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
-
-# Namespace cleanup
-del name,glob,loc
+__author__ = ''
+for author, email in release.authors.values():
+    __author__ += author + ' <' + email + '>\n'
+__license__  = release.license
+__version__  = release.version
+__revision__ = release.revision

IPython/core/completer.py

@@ -1,639 +1,658 b''
 """Word completion for IPython.
 
 This module is a fork of the rlcompleter module in the Python standard
 library.  The original enhancements made to rlcompleter have been sent
 upstream and were accepted as of Python 2.3, but we need a lot more
 functionality specific to IPython, so this module will continue to live as an
 IPython-specific utility.
 
 Original rlcompleter documentation:
 
 This requires the latest extension to the readline module (the
 completes keywords, built-ins and globals in __main__; when completing
 NAME.NAME..., it evaluates (!) the expression up to the last dot and
 completes its attributes.
 
 It's very cool to do "import string" type "string.", hit the
 completion key (twice), and see the list of names defined by the
 string module!
 
 Tip: to use the tab key as the completion key, call
 
     readline.parse_and_bind("tab: complete")
 
 Notes:
 
 - Exceptions raised by the completer function are *ignored* (and
 generally cause the completion to fail).  This is a feature -- since
 readline sets the tty device in raw (or cbreak) mode, printing a
 traceback wouldn't work well without some complicated hoopla to save,
 reset and restore the tty state.
 
 - The evaluation of the NAME.NAME... form may cause arbitrary
 application defined code to be executed if an object with a
 __getattr__ hook is found.  Since it is the responsibility of the
 application (or the user) to enable this feature, I consider this an
 acceptable risk.  More complicated expressions (e.g. function calls or
 indexing operations) are *not* evaluated.
 
 - GNU readline is also used by the built-in functions input() and
 raw_input(), and thus these also benefit/suffer from the completer
 features.  Clearly an interactive application can benefit by
 specifying its own completer function and using raw_input() for all
 its input.
 
 - When the original stdin is not a tty device, GNU readline is never
 used, and this module (and the readline module) are silently inactive.
-
 """
 
 #*****************************************************************************
 #
 # Since this file is essentially a minimally modified copy of the rlcompleter
 # module which is part of the standard Python distribution, I assume that the
 # proper procedure is to maintain its copyright as belonging to the Python
 # Software Foundation (in addition to my own, for all new code).
 #
+#       Copyright (C) 2008-2010 IPython Development Team
+#       Copyright (C) 2001-2007 Fernando Perez. <[e-mail]>
 #       Copyright (C) 2001 Python Software Foundation, www.python.org
-#       Copyright (C) 2001-2006 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
+#-----------------------------------------------------------------------------
+
 import __builtin__
 import __main__
 import glob
+import inspect
+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
 
-# Python 2.4 offers sets as a builtin
-try:
-    set()
-except NameError:
-    from sets import Set as set
+from IPython.core.error import TryNext
+from IPython.core.prefilter import ESC_MAGIC
+from IPython.utils import generics
+from IPython.utils.frame import debugx
+from IPython.utils.dir2 import dir2
+import IPython.utils.rlineimpl as readline
 
-from IPython.genutils import debugx, dir2
+#-----------------------------------------------------------------------------
+# Globals
+#-----------------------------------------------------------------------------
 
+# Public API
 __all__ = ['Completer','IPCompleter']
 
+if sys.platform == 'win32':
+    PROTECTABLES = ' '
+else:
+    PROTECTABLES = ' ()'
+
+#-----------------------------------------------------------------------------
+# Main functions and classes
+#-----------------------------------------------------------------------------
+
+def protect_filename(s):
+    """Escape a string to protect certain characters."""
+    
+    return "".join([(ch in PROTECTABLES and '\\' + ch or ch)
+                    for ch in s])
+
+
+def single_dir_expand(matches):
+    "Recursively expand match lists containing a single dir."
+
+    if len(matches) == 1 and os.path.isdir(matches[0]):
+        # Takes care of links to directories also.  Use '/'
+        # explicitly, even under Windows, so that name completions
+        # don't end up escaped.
+        d = matches[0]
+        if d[-1] in ['/','\\']:
+            d = d[:-1]
+
+        subdirs = os.listdir(d)
+        if subdirs:
+            matches = [ (d + '/' + p) for p in subdirs]
+            return single_dir_expand(matches)
+        else:
+            return matches
+    else:
+        return matches
+
+class Bunch: pass
+
 class Completer:
     def __init__(self,namespace=None,global_namespace=None):
         """Create a new completer for the command line.
 
         Completer([namespace,global_namespace]) -> completer instance.
 
         If unspecified, the default namespace where completions are performed
         is __main__ (technically, __main__.__dict__). Namespaces should be
         given as dictionaries.
 
         An optional second namespace can be given.  This allows the completer
         to handle cases where both the local and global scopes need to be
         distinguished.
 
         Completer instances should be used as the completion mechanism of
         readline via the set_completer() call:
 
         readline.set_completer(Completer(my_namespace).complete)
         """
 
         # Don't bind to namespace quite yet, but flag whether the user wants a
         # specific namespace or to use __main__.__dict__. This will allow us
         # to bind to __main__.__dict__ at completion time, not now.
         if namespace is None:
             self.use_main_ns = 1
         else:
             self.use_main_ns = 0
             self.namespace = namespace
 
         # The global namespace, if given, can be bound directly
         if global_namespace is None:
             self.global_namespace = {}
         else:
             self.global_namespace = global_namespace
 
     def complete(self, text, state):
         """Return the next possible completion for 'text'.
 
         This is called successively with state == 0, 1, 2, ... until it
         returns None.  The completion should begin with 'text'.
 
         """
         if self.use_main_ns:
             self.namespace = __main__.__dict__
             
         if state == 0:
             if "." in text:
                 self.matches = self.attr_matches(text)
             else:
                 self.matches = self.global_matches(text)
         try:
             return self.matches[state]
         except IndexError:
             return None
 
     def global_matches(self, text):
         """Compute matches when text is a simple name.
 
         Return a list of all keywords, built-in functions and names currently
         defined in self.namespace or self.global_namespace that match.
 
         """
+        #print 'Completer->global_matches, txt=%r' % text # dbg
         matches = []
         match_append = matches.append
         n = len(text)
         for lst in [keyword.kwlist,
                     __builtin__.__dict__.keys(),
                     self.namespace.keys(),
                     self.global_namespace.keys()]:
             for word in lst:
                 if word[:n] == text and word != "__builtins__":
                     match_append(word)
         return matches
 
     def attr_matches(self, text):
         """Compute matches when text contains a dot.
 
         Assuming the text is of the form NAME.NAME....[NAME], and is
         evaluatable in self.namespace or self.global_namespace, it will be
         evaluated and its attributes (as revealed by dir()) are used as
         possible completions.  (For class instances, class members are are
         also considered.)
 
         WARNING: this can still invoke arbitrary C code, if an object
         with a __getattr__ hook is evaluated.
 
         """
-        import re
 
+        #print 'Completer->attr_matches, txt=%r' % text # dbg
         # Another option, seems to work great. Catches things like ''.<tab>
         m = re.match(r"(\S+(\.\w+)*)\.(\w*)$", text)
 
         if not m:
             return []
         
         expr, attr = m.group(1, 3)
         try:
             obj = eval(expr, self.namespace)
         except:
             try:
                 obj = eval(expr, self.global_namespace)
             except:
                 return []
 
         words = dir2(obj)
         
         try:
             words = generics.complete_object(obj, words)
-        except ipapi.TryNext:
+        except TryNext:
             pass
         # Build match list to return
         n = len(attr)
         res = ["%s.%s" % (expr, w) for w in words if w[:n] == attr ]
         return res
 
+
 class IPCompleter(Completer):
     """Extension of the completer class with IPython-specific features"""
 
     def __init__(self,shell,namespace=None,global_namespace=None,
                  omit__names=0,alias_table=None):
         """IPCompleter() -> completer
 
         Return a completer object suitable for use by the readline library
         via readline.set_completer().
 
         Inputs:
 
         - shell: a pointer to the ipython shell itself.  This is needed
         because this completer knows about magic functions, and those can
         only be accessed via the ipython instance.
 
         - namespace: an optional dict where completions are performed.
 
         - global_namespace: secondary optional dict for completions, to
         handle cases (such as IPython embedded inside functions) where
         both Python scopes are visible.
 
         - The optional omit__names parameter sets the completer to omit the
         'magic' names (__magicname__) for python objects unless the text
         to be completed explicitly starts with one or more underscores.
 
         - If alias_table is supplied, it should be a dictionary of aliases
         to complete. """
 
         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,'')
         self.readline.set_completer_delims(delims)
         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
+        self.shell = shell.shell
         if alias_table is None:
             alias_table = {}
         self.alias_table = alias_table
         # Regexp to split filenames with spaces in them
         self.space_name_re = re.compile(r'([^\\] )')
         # Hold a local ref. to glob.glob for speed
         self.glob = glob.glob
 
         # Determine if we are running on 'dumb' terminals, like (X)Emacs
         # buffers, to avoid completion problems.
         term = os.environ.get('TERM','xterm')
         self.dumb_terminal = term in ['dumb','emacs']
         
         # Special handling of backslashes needed in win32 platforms
         if sys.platform == "win32":
             self.clean_glob = self._clean_glob_win32
         else:
             self.clean_glob = self._clean_glob
+
+        # All active matcher routines for completion
         self.matchers = [self.python_matches,
                          self.file_matches,
+                         self.magic_matches,
                          self.alias_matches,
                          self.python_func_kw_matches]
-
     
     # Code contributed by Alex Schmolck, for ipython/emacs integration
     def all_completions(self, text):
         """Return all possible completions for the benefit of emacs."""
 
         completions = []
         comp_append = completions.append
         try:
             for i in xrange(sys.maxint):
                 res = self.complete(text, i)
-
-                if not res: break
-
+                if not res:
+                    break
                 comp_append(res)
         #XXX workaround for ``notDefined.<tab>``
         except NameError:
             pass
         return completions
     # /end Alex Schmolck code.
 
     def _clean_glob(self,text):
         return self.glob("%s*" % text)
 
     def _clean_glob_win32(self,text):
         return [f.replace("\\","/")
                 for f in self.glob("%s*" % text)]            
 
     def file_matches(self, text):
         """Match filenames, expanding ~USER type strings.
 
         Most of the seemingly convoluted logic in this completer is an
         attempt to handle filenames with spaces in them.  And yet it's not
         quite perfect, because Python's readline doesn't expose all of the
         GNU readline details needed for this to be done correctly.
 
         For a filename with a space in it, the printed completions will be
         only the parts after what's already been typed (instead of the
         full completions, as is normally done).  I don't think with the
         current (as of Python 2.3) Python readline it's possible to do
         better."""
 
         #print 'Completer->file_matches: <%s>' % text # dbg
 
         # chars that require escaping with backslash - i.e. chars
         # that readline treats incorrectly as delimiters, but we
         # don't want to treat as delimiters in filename matching
         # when escaped with backslash
 
-        if sys.platform == 'win32':
-            protectables = ' '
-        else:
-            protectables = ' ()'
-
         if text.startswith('!'):
             text = text[1:]
             text_prefix = '!'
         else:
             text_prefix = ''
             
-        def protect_filename(s):
-            return "".join([(ch in protectables and '\\' + ch or ch)
-                            for ch in s])
-
-        def single_dir_expand(matches):
-            "Recursively expand match lists containing a single dir."
-            
-            if len(matches) == 1 and os.path.isdir(matches[0]):
-                # Takes care of links to directories also.  Use '/'
-                # explicitly, even under Windows, so that name completions
-                # don't end up escaped.
-                d = matches[0]
-                if d[-1] in ['/','\\']:
-                    d = d[:-1]
-
-                subdirs = os.listdir(d)
-                if subdirs:
-                    matches = [ (d + '/' + p) for p in subdirs]
-                    return single_dir_expand(matches)
-                else:
-                    return matches
-            else:
-                return matches
-        
         lbuf = self.lbuf
         open_quotes = 0  # track strings with open quotes
         try:
             lsplit = shlex.split(lbuf)[-1]
         except ValueError:
             # typically an unmatched ", or backslash without escaped char.
             if lbuf.count('"')==1:
                 open_quotes = 1
                 lsplit = lbuf.split('"')[-1]
             elif lbuf.count("'")==1:
                 open_quotes = 1
                 lsplit = lbuf.split("'")[-1]
             else:
                 return []
         except IndexError:
             # tab pressed on empty line
             lsplit = ""
 
         if lsplit != protect_filename(lsplit):
             # if protectables are found, do matching on the whole escaped
             # name
             has_protectables = 1
             text0,text = text,lsplit
         else:
             has_protectables = 0
             text = os.path.expanduser(text)
 
         if text == "":
             return [text_prefix + protect_filename(f) for f in self.glob("*")]
 
         m0 = self.clean_glob(text.replace('\\',''))
         if has_protectables:
             # If we had protectables, we need to revert our changes to the
             # beginning of filename so that we don't double-write the part
             # of the filename we have so far
             len_lsplit = len(lsplit)
             matches = [text_prefix + text0 + 
                        protect_filename(f[len_lsplit:]) for f in m0]
         else:
             if open_quotes:
                 # if we have a string with an open quote, we don't need to
                 # protect the names at all (and we _shouldn't_, as it
                 # would cause bugs when the filesystem call is made).
                 matches = m0
             else:
                 matches = [text_prefix + 
                            protect_filename(f) for f in m0]
 
         #print 'mm',matches  # dbg
         return single_dir_expand(matches)
 
+    def magic_matches(self, text):
+        """Match magics"""
+        #print 'Completer->magic_matches:',text,'lb',self.lbuf # dbg
+        # Get all shell magics now rather than statically, so magics loaded at
+        # runtime show up too
+        magics = self.shell.lsmagic()
+        pre = self.magic_escape
+        baretext = text.lstrip(pre)
+        return [ pre+m for m in magics if m.startswith(baretext)]
+
     def alias_matches(self, text):
         """Match internal system aliases"""        
         #print 'Completer->alias_matches:',text,'lb',self.lbuf # dbg
         
         # if we are not in the first 'item', alias matching 
         # doesn't make sense - unless we are starting with 'sudo' command.
-        if ' ' in self.lbuf.lstrip() and not self.lbuf.lstrip().startswith('sudo'):
+        if ' ' in self.lbuf.lstrip() and \
+               not self.lbuf.lstrip().startswith('sudo'):
             return []
         text = os.path.expanduser(text)
         aliases =  self.alias_table.keys()
         if text == "":
             return aliases
         else:
             return [alias for alias in aliases if alias.startswith(text)]
 
     def python_matches(self,text):
         """Match attributes or global python names"""
 
-        #print 'Completer->python_matches, txt=<%s>' % text # dbg
+        #print 'Completer->python_matches, txt=%r' % text # dbg
         if "." in text:
             try:
                 matches = self.attr_matches(text)
                 if text.endswith('.') and self.omit__names:
                     if self.omit__names == 1:
                         # true if txt is _not_ a __ name, false otherwise:
                         no__name = (lambda txt:
                                     re.match(r'.*\.__.*?__',txt) is None)
                     else:
                         # true if txt is _not_ a _ name, false otherwise:
                         no__name = (lambda txt:
                                     re.match(r'.*\._.*?',txt) is None)
                     matches = filter(no__name, matches)
             except NameError:
                 # catches <undefined attributes>.<tab>
                 matches = []
         else:
             matches = self.global_matches(text)
-            # this is so completion finds magics when automagic is on:
-            if (matches == [] and 
-                 not text.startswith(os.sep) and
-                 not ' ' in self.lbuf):
-                matches = self.attr_matches(self.magic_prefix+text)
+
         return matches
 
     def _default_arguments(self, obj):
         """Return the list of default arguments of obj if it is callable,
         or empty list otherwise."""
 
         if not (inspect.isfunction(obj) or inspect.ismethod(obj)):
             # for classes, check for __init__,__new__
             if inspect.isclass(obj):
                 obj = (getattr(obj,'__init__',None) or
                        getattr(obj,'__new__',None))
             # for all others, check if they are __call__able
             elif hasattr(obj, '__call__'):
                 obj = obj.__call__
             # XXX: is there a way to handle the builtins ?
         try:
             args,_,_1,defaults = inspect.getargspec(obj)
             if defaults:
                 return args[-len(defaults):]
         except TypeError: pass
         return []
 
     def python_func_kw_matches(self,text):
         """Match named parameters (kwargs) of the last open function"""
 
         if "." in text: # a parameter cannot be dotted
             return []
         try: regexp = self.__funcParamsRegex
         except AttributeError:
             regexp = self.__funcParamsRegex = re.compile(r'''
                 '.*?' |    # single quoted strings or
                 ".*?" |    # double quoted strings or
                 \w+   |    # identifier
                 \S         # other characters
                 ''', re.VERBOSE | re.DOTALL)
         # 1. find the nearest identifier that comes before an unclosed
         # parenthesis e.g. for "foo (1+bar(x), pa", the candidate is "foo"
         tokens = regexp.findall(self.get_line_buffer())
         tokens.reverse()
         iterTokens = iter(tokens); openPar = 0
         for token in iterTokens:
             if token == ')':
                 openPar -= 1
             elif token == '(':
                 openPar += 1
                 if openPar > 0:
                     # found the last unclosed parenthesis
                     break
         else:
             return []
         # 2. Concatenate dotted names ("foo.bar" for "foo.bar(x, pa" )
         ids = []
         isId = re.compile(r'\w+$').match
         while True:
             try:
                 ids.append(iterTokens.next())
                 if not isId(ids[-1]):
                     ids.pop(); break
                 if not iterTokens.next() == '.':
                     break
             except StopIteration:
                 break
         # lookup the candidate callable matches either using global_matches
         # or attr_matches for dotted names
         if len(ids) == 1:
             callableMatches = self.global_matches(ids[0])
         else:
             callableMatches = self.attr_matches('.'.join(ids[::-1]))
         argMatches = []
         for callableMatch in callableMatches:
-            try: namedArgs = self._default_arguments(eval(callableMatch,
+            try:
+                namedArgs = self._default_arguments(eval(callableMatch,
                                                          self.namespace))
-            except: continue
+            except:
+                continue
             for namedArg in namedArgs:
                 if namedArg.startswith(text):
                     argMatches.append("%s=" %namedArg)
         return argMatches
 
     def dispatch_custom_completer(self,text):
         #print "Custom! '%s' %s" % (text, self.custom_completers) # dbg
         line = self.full_lbuf        
         if not line.strip():
             return None
 
-        event = Struct()
+        event = Bunch()
         event.line = line
         event.symbol = text
         cmd = line.split(None,1)[0]
         event.command = cmd
         #print "\ncustom:{%s]\n" % event # dbg
         
         # for foo etc, try also to find completer for %foo
         if not cmd.startswith(self.magic_escape):
             try_magic = self.custom_completers.s_matches(
               self.magic_escape + cmd)            
         else:
-            try_magic = []
-        
+            try_magic = []        
         
-        for c in itertools.chain(
-                                 self.custom_completers.s_matches(cmd),
+        for c in itertools.chain(self.custom_completers.s_matches(cmd),
                                  try_magic,
                                  self.custom_completers.flat_matches(self.lbuf)):
             #print "try",c # dbg
             try:
                 res = c(event)
                 # first, try case sensitive match
                 withcase = [r for r in res if r.startswith(text)]
                 if withcase:
                     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:
+                text_low = text.lower()
+                return [r for r in res if r.lower().startswith(text_low)]
+            except TryNext:
                 pass
             
         return None
                
     def complete(self, text, state,line_buffer=None):
         """Return the next possible completion for 'text'.
 
         This is called successively with state == 0, 1, 2, ... until it
         returns None.  The completion should begin with 'text'.
 
         :Keywords:
         - line_buffer: string
         If not given, the completer attempts to obtain the current line buffer
         via readline.  This keyword allows clients which are requesting for
         text completions in non-readline contexts to inform the completer of
         the entire text.
         """
 
         #print '\n*** COMPLETE: <%s> (%s)' % (text,state)  # dbg
 
         # if there is only a tab on a line with only whitespace, instead
         # of the mostly useless 'do you want to see all million
         # completions' message, just do the right thing and give the user
         # his tab!  Incidentally, this enables pasting of tabbed text from
         # an editor (as long as autoindent is off).
 
         # It should be noted that at least pyreadline still shows
         # file completions - is there a way around it?
         
         # don't apply this on 'dumb' terminals, such as emacs buffers, so we
         # don't interfere with their own tab-completion mechanism.
         if line_buffer is None:
             self.full_lbuf = self.get_line_buffer()
         else:
             self.full_lbuf = line_buffer
             
         if not (self.dumb_terminal or self.full_lbuf.strip()):
             self.readline.insert_text('\t')
             return None
         
         magic_escape = self.magic_escape
-        magic_prefix = self.magic_prefix
 
         self.lbuf = self.full_lbuf[:self.get_endidx()]
 
         try:
-            if text.startswith(magic_escape):
-                text = text.replace(magic_escape,magic_prefix)
-            elif text.startswith('~'):
+            if text.startswith('~'):
                 text = os.path.expanduser(text)
             if state == 0:
                 custom_res = self.dispatch_custom_completer(text)
                 if custom_res is not None:
                     # did custom completers produce something?
                     self.matches = custom_res
                 else:
                     # Extend the list of completions with the results of each
                     # matcher, so we return results to the user from all
                     # namespaces.
                     if self.merge_completions:
                         self.matches = []
                         for matcher in self.matchers:
                             self.matches.extend(matcher(text))
                     else:
                         for matcher in self.matchers:
                             self.matches = matcher(text)
                             if self.matches:
                                 break
-                    def uniq(alist):
-                        set = {}
-                        return [set.setdefault(e,e) for e in alist if e not in set]
-                    self.matches = uniq(self.matches)                
+                    self.matches = list(set(self.matches))
             try:
-                ret = self.matches[state].replace(magic_prefix,magic_escape)                
-                return ret
+                #print "MATCH: %r" % self.matches[state] # dbg
+                return self.matches[state]
             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.
             return None

IPython/core/debugger.py

@@ -1,522 +1,510 b''
 # -*- coding: utf-8 -*-
 """
 Pdb debugger class.
 
 Modified from the standard pdb.Pdb class to avoid including readline, so that
 the command line completion of other programs which include this isn't
 damaged.
 
 In the future, this class will be expanded with improvements over the standard
 pdb.
 
 The code in this file is mainly lifted out of cmd.py in Python 2.2, with minor
 changes. Licensing should therefore be under the standard Python terms.  For
 details on the PSF (Python Software Foundation) standard license, see:
 
 http://www.python.org/2.2.3/license.html"""
 
 #*****************************************************************************
 #
 #       This file is licensed under the PSF license.
 #
 #       Copyright (C) 2001 Python Software Foundation, www.python.org
 #       Copyright (C) 2005-2006 Fernando Perez. <[e-mail]>
 #
 #
 #*****************************************************************************
 
 import bdb
-import cmd
 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.io import Term
+from IPython.core.excolors import exception_colors
 
 # See if we can use pydb.
 has_pydb = False
 prompt = 'ipdb> '
 #We have to check this directly from sys.argv, config struct not yet available
 if '-pydb' in sys.argv:
     try:        
         import pydb
         if hasattr(pydb.pydb, "runl") and pydb.version>'1.17':
             # Version 1.17 is broken, and that's what ships with Ubuntu Edgy, so we
             # better protect against it.
             has_pydb = True
     except ImportError:
         print "Pydb (http://bashdb.sourceforge.net/pydb/) does not seem to be available"
 
 if has_pydb:
     from pydb import Pdb as OldPdb
     #print "Using pydb for %run -d and post-mortem" #dbg
     prompt = 'ipydb> '
 else:
     from pdb import Pdb as OldPdb
 
 # Allow the set_trace code to operate outside of an ipython instance, even if
 # it does so with some limitations.  The rest of this support is implemented in
 # the Tracer constructor.
 def BdbQuit_excepthook(et,ev,tb):
     if et==bdb.BdbQuit:
         print 'Exiting Debugger.'
     else:
         BdbQuit_excepthook.excepthook_ori(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.
 
     Instances of this class, when called, behave like pdb.set_trace, but
     providing IPython's enhanced capabilities.
 
     This is implemented as a class which must be initialized in your own code
     and not as a standalone function because we need to detect at runtime
     whether IPython is already active or not.  That detection is done in the
     constructor, ensuring that this code plays nicely with a running IPython,
     while functioning acceptably (though with limitations) if outside of it.
     """
 
     def __init__(self,colors=None):
         """Create a local debugger instance.
 
         :Parameters:
 
           - `colors` (None): a string containing the name of the color scheme to
         use, it must be one of IPython's valid color schemes.  If not given, the
         function will default to the current IPython scheme when running inside
         IPython, and to 'NoColor' otherwise.
 
         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.
 
         Once the debugger activates, you can use all of its regular commands to
         step through code, set breakpoints, etc.  See the pdb documentation
         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
-            ip.set_custom_exc((bdb.BdbQuit,),BdbQuit_IPython_excepthook)
+            def_colors = ip.colors
+            ip.set_custom_exc((bdb.BdbQuit,), BdbQuit_IPython_excepthook)
 
         if colors is None:
             colors = def_colors
         self.debugger = Pdb(colors)
 
     def __call__(self):
         """Starts an interactive debugger at the point where called.
 
         This is similar to the pdb.set_trace() function from the std lib, but
         using IPython's enhanced debugger."""
         
         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.
     Adapted from from a comp.lang.python posting
     by Duncan Booth."""
     def wrapper(*args, **kw):
         return new_fn(*args, **kw)
     if old_fn.__doc__:
         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.
 
     This function never raises an IOError exception: if the file can't be
     read, it simply returns an empty list."""
 
     try:
         outfile = open(fname)
     except IOError:
         return []
     else:
         out = outfile.readlines()
         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):
+    def __init__(self,color_scheme='NoColor',completekey=None,
+                 stdin=None, stdout=None):
 
-            # Parent constructor:
-            if has_pydb and completekey is None:
-                OldPdb.__init__(self,stdin=stdin,stdout=Term.cout)
-            else:
-                OldPdb.__init__(self,completekey,stdin,stdout)
-                
-            self.prompt = prompt # The default prompt is '(Pdb)'
+        # Parent constructor:
+        if has_pydb and completekey is None:
+            OldPdb.__init__(self,stdin=stdin,stdout=Term.cout)
+        else:
+            OldPdb.__init__(self,completekey,stdin,stdout)
             
-            # IPython changes...
-            self.is_pydb = has_pydb
-
-            if self.is_pydb:
-
-                # iplib.py's ipalias seems to want pdb's checkline
-                # which located in pydb.fn
-                import pydb.fns
-                self.checkline = lambda filename, lineno: \
-                                 pydb.fns.checkline(self, filename, lineno)
-
-                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.do_list = decorate_fn_with_doc(self.list_command_pydb,
-                                                    OldPdb.do_list)
-                self.do_l     = self.do_list
-                self.do_frame = decorate_fn_with_doc(self.new_do_frame,
-                                                     OldPdb.do_frame)
-
-            self.aliases = {}
-
-            # 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()
+        self.prompt = prompt # The default prompt is '(Pdb)'
+        
+        # IPython changes...
+        self.is_pydb = has_pydb
 
-            # shorthands 
-            C = ColorANSI.TermColors
-            cst = self.color_scheme_table
+        self.shell = ipapi.get()
 
-            cst['NoColor'].colors.breakpoint_enabled = C.NoColor
-            cst['NoColor'].colors.breakpoint_disabled = C.NoColor
+        if self.is_pydb:
 
-            cst['Linux'].colors.breakpoint_enabled = C.LightRed
-            cst['Linux'].colors.breakpoint_disabled = C.Red
+            # iplib.py's ipalias seems to want pdb's checkline
+            # which located in pydb.fn
+            import pydb.fns
+            self.checkline = lambda filename, lineno: \
+                             pydb.fns.checkline(self, filename, lineno)
 
-            cst['LightBG'].colors.breakpoint_enabled = C.LightRed
-            cst['LightBG'].colors.breakpoint_disabled = C.Red
+            self.curframe = None
+            self.do_restart = self.new_do_restart
 
-            self.set_colors(color_scheme)
+            self.old_all_completions = self.shell.Completer.all_completions
+            self.shell.Completer.all_completions=self.all_completions
 
-            # Add a python parser so we can syntax highlight source while
-            # debugging.
-            self.parser = PyColorize.Parser()
+            self.do_list = decorate_fn_with_doc(self.list_command_pydb,
+                                                OldPdb.do_list)
+            self.do_l     = self.do_list
+            self.do_frame = decorate_fn_with_doc(self.new_do_frame,
+                                                 OldPdb.do_frame)
 
+        self.aliases = {}
 
-    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()
 
-            # 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
+        cst = self.color_scheme_table
 
-            # shorthands 
-            C = ColorANSI.TermColors
-            cst = self.color_scheme_table
+        cst['NoColor'].colors.breakpoint_enabled = C.NoColor
+        cst['NoColor'].colors.breakpoint_disabled = C.NoColor
 
-            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['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
 
-            cst['LightBG'].colors.breakpoint_enabled = C.LightRed
-            cst['LightBG'].colors.breakpoint_disabled = C.Red
+        self.set_colors(color_scheme)
 
-            self.set_colors(color_scheme)
+        # Add a python parser so we can syntax highlight source while
+        # debugging.
+        self.parser = PyColorize.Parser()
 
-            # Add a python parser so we can syntax highlight source while
-            # debugging.
-            self.parser = PyColorize.Parser()
-        
     def set_colors(self, scheme):
         """Shorthand access to the color table scheme selector method."""
         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)
 
     do_q = do_quit = decorate_fn_with_doc(new_do_quit, OldPdb.do_quit)
 
     def new_do_restart(self, arg):
         """Restart command. In the context of ipython this is exactly the same
         thing as 'quit'."""
         self.msg("Restart doesn't make sense here. Using 'quit' instead.")
         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:
             for frame_lineno in self.stack:
                 self.print_stack_entry(frame_lineno, context = 5)
         except KeyboardInterrupt:
             pass
 
     def print_stack_entry(self,frame_lineno,prompt_prefix='\n-> ',
                           context = 3):
         #frame, lineno = frame_lineno
         print >>Term.cout, self.format_stack_entry(frame_lineno, '', context)
 
         # 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):
         import linecache, repr
         
         ret = []
         
         Colors = self.color_scheme_table.active_colors
         ColorsNormal = Colors.Normal
         tpl_link = '%s%%s%s' % (Colors.filenameEm, ColorsNormal)
         tpl_call = '%s%%s%s%%s%s' % (Colors.vName, Colors.valEm, ColorsNormal)
         tpl_line = '%%s%s%%s %s%%s' % (Colors.lineno, ColorsNormal)
         tpl_line_em = '%%s%s%%s %s%%s%s' % (Colors.linenoEm, Colors.line,
                                             ColorsNormal)
         
         frame, lineno = frame_lineno
         
         return_value = ''
         if '__return__' in frame.f_locals:
             rv = frame.f_locals['__return__']
             #return_value += '->'
             return_value += repr.repr(rv) + '\n'
         ret.append(return_value)
 
         #s = filename + '(' + `lineno` + ')'
         filename = self.canonic(frame.f_code.co_filename)
         link = tpl_link % filename
         
         if frame.f_code.co_name:
             func = frame.f_code.co_name
         else:
             func = "<lambda>"
             
         call = ''
         if func != '?':         
             if '__args__' in frame.f_locals:
                 args = repr.repr(frame.f_locals['__args__'])
             else:
                 args = '()'
             call = tpl_call % (func, args)
 
         # The level info should be generated in the same format pdb uses, to
         # avoid breaking the pdbtrack functionality of python-mode in *emacs.
         if frame is self.curframe:
             ret.append('> ')
         else:
             ret.append('  ')
         ret.append('%s(%s)%s\n' % (link,lineno,call))
             
         start = lineno - 1 - context//2
         lines = linecache.getlines(filename)
         start = max(start, 0)
         start = min(start, len(lines) - context)
         lines = lines[start : start + context]
             
         for i,line in enumerate(lines):
             show_arrow = (start + 1 + i == lineno)
             linetpl = (frame is self.curframe or show_arrow) \
                       and tpl_line_em \
                       or tpl_line
             ret.append(self.__format_line(linetpl, filename,
                                           start + 1 + i, line,
                                           arrow = show_arrow) )
 
         return ''.join(ret)
 
     def __format_line(self, tpl_line, filename, lineno, line, arrow = False):
         bp_mark = ""
         bp_mark_color = ""
 
         scheme = self.color_scheme_table.active_scheme_name
         new_line, err = self.parser.format2(line, 'str', scheme)
         if not err: line = new_line
 
         bp = None
         if lineno in self.get_file_breaks(filename):
             bps = self.get_breaks(filename, lineno)
             bp = bps[-1]
         
         if bp:
             Colors = self.color_scheme_table.active_colors
             bp_mark = str(bp.number)
             bp_mark_color = Colors.breakpoint_enabled
             if not bp.enabled:
                 bp_mark_color = Colors.breakpoint_disabled
 
         numbers_width = 7
         if arrow:
             # This is the line with the error
             pad = numbers_width - len(str(lineno)) - len(bp_mark)
             if pad >= 3:
                 marker = '-'*(pad-3) + '-> '
             elif pad == 2:
                  marker = '> '
             elif pad == 1:
                  marker = '>'
             else:
                  marker = ''
             num = '%s%s' % (marker, str(lineno))
             line = tpl_line % (bp_mark_color + bp_mark, num, line)
         else:
             num = '%*s' % (numbers_width - len(bp_mark), str(lineno))
             line = tpl_line % (bp_mark_color + bp_mark, num, line)
             
         return line
 
     def list_command_pydb(self, arg):
         """List command to use if we have a newer pydb installed"""
         filename, first, last = OldPdb.parse_list_cmd(self, arg)
         if filename is not None:
             self.print_list_lines(filename, first, last)
         
     def print_list_lines(self, filename, first, last):
         """The printing (as opposed to the parsing part of a 'list'
         command."""
         try:
             Colors = self.color_scheme_table.active_colors
             ColorsNormal = Colors.Normal
             tpl_line = '%%s%s%%s %s%%s' % (Colors.lineno, ColorsNormal)
             tpl_line_em = '%%s%s%%s %s%%s%s' % (Colors.linenoEm, Colors.line, ColorsNormal)
             src = []
             for lineno in range(first, last+1):
                 line = linecache.getline(filename, lineno)
                 if not line:
                     break
 
                 if lineno == self.curframe.f_lineno:
                     line = self.__format_line(tpl_line_em, filename, lineno, line, arrow = True)
                 else:
                     line = self.__format_line(tpl_line, filename, lineno, line, arrow = False)
 
                 src.append(line)
                 self.lineno = lineno
 
             print >>Term.cout, ''.join(src)
 
         except KeyboardInterrupt:
             pass
 
     def do_list(self, arg):
         self.lastcmd = 'list'
         last = None
         if arg:
             try:
                 x = eval(arg, {}, {})
                 if type(x) == type(()):
                     first, last = x
                     first = int(first)
                     last = int(last)
                     if last < first:
                         # Assume it's a count
                         last = first + last
                 else:
                     first = max(1, int(x) - 5)
             except:
                 print '*** Error in argument:', `arg`
                 return
         elif self.lineno is None:
             first = max(1, self.curframe.f_lineno - 5)
         else:
             first = self.lineno + 1
         if last is None:
             last = first + 10
         self.print_list_lines(self.curframe.f_code.co_filename, first, last)
 
         # 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
 
     def do_pdef(self, arg):
         """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)
+
+    def checkline(self, filename, lineno):
+        """Check whether specified line seems to be executable.
+
+        Return `lineno` if it is, 0 if not (e.g. a docstring, comment, blank
+        line or EOF). Warning: testing is not comprehensive.
+        """
+        #######################################################################
+        # XXX Hack!  Use python-2.5 compatible code for this call, because with
+        # all of our changes, we've drifted from the pdb api in 2.6.  For now,
+        # changing:
+        #
+        #line = linecache.getline(filename, lineno, self.curframe.f_globals)
+        # to:
+        #
+        line = linecache.getline(filename, lineno)
+        #
+        # does the trick.  But in reality, we need to fix this by reconciling
+        # our updates with the new Pdb APIs in Python 2.6.
+        #
+        # End hack.  The rest of this method is copied verbatim from 2.6 pdb.py
+        #######################################################################
+        
+        if not line:
+            print >>self.stdout, 'End of file'
+            return 0
+        line = line.strip()
+        # Don't allow setting breakpoint at a blank line
+        if (not line or (line[0] == '#') or
+             (line[:3] == '"""') or line[:3] == "'''"):
+            print >>self.stdout, '*** Blank or comment'
+            return 0
+        return lineno

IPython/core/excolors.py

@@ -1,137 +1,135 b''
 # -*- coding: utf-8 -*-
 """
 Color schemes for exception handling code in IPython.
 """
 
 #*****************************************************************************
 #       Copyright (C) 2005-2006 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.
 #*****************************************************************************
 
-#****************************************************************************
-# 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.
 
     The table is an instance of ColorSchemeTable with schemes added for
     'Linux', 'LightBG' and 'NoColor' and fields for exception handling filled
     in.
 
     Examples:
 
     >>> ec = exception_colors()
     >>> ec.active_scheme_name
     ''
     >>> print ec.active_colors
     None
 
     Now we activate a color scheme:    
     >>> ec.set_active_scheme('NoColor')
     >>> 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()
 
     # Populate it with color schemes
     C = TermColors # shorthand and local lookup
     ex_colors.add_scheme(ColorScheme(
         'NoColor',
         # The color to be used for the top line
         topline = C.NoColor,
 
         # The colors to be used in the traceback
         filename = C.NoColor,
         lineno = C.NoColor,
         name = C.NoColor,
         vName = C.NoColor,
         val = C.NoColor,
         em = C.NoColor,
 
         # Emphasized colors for the last frame of the traceback
         normalEm = C.NoColor,
         filenameEm = C.NoColor,
         linenoEm = C.NoColor,
         nameEm = C.NoColor,
         valEm = C.NoColor,
 
         # Colors for printing the exception
         excName = C.NoColor,
         line = C.NoColor,
         caret = C.NoColor,
         Normal = C.NoColor
         ))
 
     # make some schemes as instances so we can copy them for modification easily
     ex_colors.add_scheme(ColorScheme(
         'Linux',
         # The color to be used for the top line
         topline = C.LightRed,
 
         # The colors to be used in the traceback
         filename = C.Green,
         lineno = C.Green,
         name = C.Purple,
         vName = C.Cyan,
         val = C.Green,
         em = C.LightCyan,
 
         # Emphasized colors for the last frame of the traceback
         normalEm = C.LightCyan,
         filenameEm = C.LightGreen,
         linenoEm = C.LightGreen,
         nameEm = C.LightPurple,
         valEm = C.LightBlue,
 
         # Colors for printing the exception
         excName = C.LightRed,
         line = C.Yellow,
         caret = C.White,
         Normal = C.Normal
         ))
 
     # For light backgrounds, swap dark/light colors
     ex_colors.add_scheme(ColorScheme(
         'LightBG',
         # The color to be used for the top line
         topline = C.Red,
 
         # The colors to be used in the traceback
         filename = C.LightGreen,
         lineno = C.LightGreen,
         name = C.LightPurple,
         vName = C.Cyan,
         val = C.LightGreen,
         em = C.Cyan,
 
         # Emphasized colors for the last frame of the traceback
         normalEm = C.Cyan,
         filenameEm = C.Green,
         linenoEm = C.Green,
         nameEm = C.Purple,
         valEm = C.Blue,
 
         # Colors for printing the exception
         excName = C.Red,
         #line = C.Brown,  # brown often is displayed as yellow
         line = C.Red,
         caret = C.Normal,
         Normal = C.Normal,
         ))
 
     return ex_colors
 
 
 # For backwards compatibility, keep around a single global object.  Note that
 # this should NOT be used, the factory function should be used instead, since
 # these objects are stateful and it's very easy to get strange bugs if any code
 # modifies the module-level object's state.
 ExceptionColors = exception_colors()

IPython/core/fakemodule.py

@@ -1,42 +1,66 b''
 # -*- coding: utf-8 -*-
 """
 Class which mimics a module.
 
 Needed to allow pickle to correctly resolve namespaces during IPython
 sessions.
 """
 
 #*****************************************************************************
 #       Copyright (C) 2002-2004 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.
 #*****************************************************************************
 
 import types
 
+def init_fakemod_dict(fm,adict=None):
+    """Initialize a FakeModule instance __dict__.
+
+    Kept as a standalone function and not a method so the FakeModule API can
+    remain basically empty.
+
+    This should be considered for private IPython use, used in managing
+    namespaces for %run.
+
+    Parameters
+    ----------
+
+    fm : FakeModule instance
+
+    adict : dict, optional
+    """
+
+    dct = {}
+    # It seems pydoc (and perhaps others) needs any module instance to
+    # implement a __nonzero__ method, so we add it if missing:
+    dct.setdefault('__nonzero__',lambda : True)
+    dct.setdefault('__file__',__file__)
+
+    if adict is not None:
+        dct.update(adict)
+
+    # Hard assignment of the object's __dict__.  This is nasty but deliberate.
+    fm.__dict__.clear()
+    fm.__dict__.update(dct)
+
+
 class FakeModule(types.ModuleType):
     """Simple class with attribute access to fake a module.
 
     This is not meant to replace a module, but to allow inserting a fake
     module in sys.modules so that systems which rely on run-time module
     importing (like shelve and pickle) work correctly in interactive IPython
     sessions.
 
     Do NOT use this code for anything other than this IPython private hack."""
 
     def __init__(self,adict=None):
         
         # tmp to force __dict__ instance creation, else self.__dict__ fails
         self.__iptmp = None
-        
-        # It seems pydoc (and perhaps others) needs any module instance to
-        # implement a __nonzero__ method, so we add it if missing:
-        self.__dict__.setdefault('__nonzero__',lambda : True)
-        self.__dict__.setdefault('__file__',__file__)
-
         # cleanup our temp trick
         del self.__iptmp
-
-        if adict is not None:
-            self.__dict__.update(adict)
+        # Now, initialize the actual data in the instance dict.
+        init_fakemod_dict(self,adict)

IPython/core/history.py

@@ -1,258 +1,277 b''
 # -*- coding: utf-8 -*-
 """ History related magics and functionality """
 
 # Stdlib imports
 import fnmatch
 import os
 
-# IPython imports
-from IPython.genutils import Term, ask_yes_no, warn
-import IPython.ipapi
+from IPython.utils.io import Term, ask_yes_no
+from IPython.utils.warn import warn
+from IPython.core import ipapi
 
 def magic_history(self, parameter_s = ''):
     """Print input history (_i<n> variables), with most recent last.
     
     %history       -> print at most 40 inputs (some may be multi-line)\\
     %history n     -> print at most n inputs\\
     %history n1 n2 -> print inputs between n1 and n2 (n2 not included)\\
-    
-    Each input's number <n> is shown, and is accessible as the
-    automatically generated variable _i<n>.  Multi-line statements are
-    printed starting at a new line for easy copy/paste.
-    
 
-    Options:
+    By default, input history is printed without line numbers so it can be
+    directly pasted into an editor.
 
-      -n: do NOT print line numbers. This is useful if you want to get a
-      printout of many lines which can be directly pasted into a text
-      editor.
+    With -n, each input's number <n> is shown, and is accessible as the
+    automatically generated variable _i<n> as well as In[<n>].  Multi-line
+    statements are printed starting at a new line for easy copy/paste.
+
+    Options:
 
+      -n: print line numbers for each input.
       This feature is only available if numbered prompts are in use.
 
+      -o: also print outputs for each input.
+
+      -p: print classic '>>>' python prompts before each input.  This is useful
+       for making documentation, and in conjunction with -o, for producing
+       doctest-ready output.
+
       -t: (default) print the 'translated' history, as IPython understands it.
       IPython filters your input and converts it all into valid Python source
       before executing it (things like magics or aliases are turned into
       function calls, for example). With this option, you'll see the native
       history instead of the user-entered version: '%cd /' will be seen as
       '_ip.magic("%cd /")' instead of '%cd /'.
       
       -r: print the 'raw' history, i.e. the actual commands you typed.
       
       -g: treat the arg as a pattern to grep for in (full) history.
       This includes the "shadow history" (almost all commands ever written).
       Use '%hist -g' to show full shadow history (may be very long).
       In shadow history, every index nuwber starts with 0.
 
       -f FILENAME: instead of printing the output to the screen, redirect it to
        the given file.  The file is always overwritten, though IPython asks for
        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')
+    opts,args = self.parse_options(parameter_s,'gnoptsrf:',mode='list')
 
     # Check if output to specific file was requested.
     try:
         outfname = opts['f']
     except KeyError:
         outfile = Term.cout  # default
         # We don't want to close stdout at the end!
         close_at_end = False
     else:
         if os.path.exists(outfname):
             if not ask_yes_no("File %r exists. Overwrite?" % outfname): 
                 print 'Aborting.'
                 return
 
         outfile = open(outfname,'w')
         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
     if 'g' in opts:
         init = 1
         final = len(input_hist)
-        parts = parameter_s.split(None,1)
+        parts = parameter_s.split(None, 1)
         if len(parts) == 1:
             parts += '*'
         head, pattern = parts
         pattern = "*" + pattern + "*"
     elif len(args) == 0:
-        final = len(input_hist)
+        final = len(input_hist)-1
         init = max(1,final-default_length)
     elif len(args) == 1:
         final = len(input_hist)
-        init = max(1,final-int(args[0]))
+        init = max(1, final-int(args[0]))
     elif len(args) == 2:
-        init,final = map(int,args)
+        init, final = map(int, args)
     else:
         warn('%hist takes 0, 1 or 2 arguments separated by spaces.')
-        print self.magic_hist.__doc__
+        print >> Term.cout, self.magic_hist.__doc__
         return
+    
     width = len(str(final))
     line_sep = ['','\n']
-    print_nums = not opts.has_key('n')
+    print_nums = 'n' in opts
+    print_outputs = 'o' in opts
+    pyprompts = 'p' in opts
     
     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)
+                print >> outfile, "0%d: %s" %(idx, s)
                 found = True
     
     if found:
-        print "==="
-        print "shadow history ends, fetch by %rep <number> (must start with 0)"
-        print "=== start of normal history ==="
+        print >> outfile, "==="
+        print >> outfile, \
+              "shadow history ends, fetch by %rep <number> (must start with 0)"
+        print >> outfile, "=== start of normal history ==="
         
     for in_num in range(init,final):        
         inline = input_hist[in_num]
         if pattern is not None and not fnmatch.fnmatch(inline, pattern):
             continue
             
         multiline = int(inline.count('\n') > 1)
         if print_nums:
             print >> outfile, \
-                  '%s:%s' % (str(in_num).ljust(width),line_sep[multiline]),
-        print >> outfile, inline,
+                  '%s:%s' % (str(in_num).ljust(width), line_sep[multiline]),
+        if pyprompts:
+            print >> outfile, '>>>',
+            if multiline:
+                lines = inline.splitlines()
+                print >> outfile, '\n... '.join(lines)
+                print >> outfile, '... '
+            else:
+                print >> outfile, inline,
+        else:
+            print >> outfile, inline,
+        if print_outputs:
+            output = self.shell.user_ns['Out'].get(in_num)
+            if output is not None:
+                print >> outfile, repr(output)
 
     if close_at_end:
         outfile.close()
 
 
 def magic_hist(self, parameter_s=''):
     """Alternate name for %history."""
     return self.magic_history(parameter_s)
 
 
 def rep_f(self, arg):
     r""" Repeat a command, or get command to input line for editing
 
     - %rep (no arguments):
     
     Place a string version of last computation result (stored in the special '_'
     variable) to the next input prompt. Allows you to create elaborate command
     lines without using copy-paste::
     
         $ l = ["hei", "vaan"]       
         $ "".join(l)        
         ==> heivaan        
         $ %rep        
         $ heivaan_ <== cursor blinking    
     
     %rep 45
     
     Place history line 45 to next input prompt. Use %hist to find out the
     number.
     
     %rep 1-4 6-7 3
     
     Repeat the specified lines immediately. Input slice syntax is the same as
     in %macro and %save.
     
     %rep foo
     
     Place the most recent line that has the substring "foo" to next input.
     (e.g. 'svn ci -m foobar').    
     """
     
     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]:
         arg = args[0]
         if len(arg) > 1 and arg.startswith('0'):
             # 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
         self.db = db
         self.disabled = False
     
     def inc_idx(self):
         idx = self.db.get('shadowhist_idx', 1)
         self.db['shadowhist_idx'] = idx + 1
         return idx
         
     def add(self, ent):
         if self.disabled:
             return
         try:
             old = self.db.hget('shadowhist', ent, _sentinel)
             if old is not _sentinel:
                 return
             newidx = self.inc_idx()
             #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
     
     def all(self):
         d = self.db.hdict('shadowhist')
         items = [(i,s) for (s,i) in d.items()]
         items.sort()
         return items
 
     def get(self, idx):
         all = self.all()
         
         for k, v in all:
             #print k,v
             if k == idx:
                 return v
 
 
 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')
+    # XXX - ipy_completers are in quarantine, need to be updated to new apis
+    #import ipy_completers
+    #ipy_completers.quick_completer('%hist' ,'-g -t -r -n')

IPython/core/hooks.py

@@ -1,247 +1,276 b''
 """hooks for IPython.
 
 In Python, it is possible to overwrite any method of any object if you really
 want to.  But IPython exposes a few 'hooks', methods which are _designed_ to
 be overwritten by users for customization purposes.  This module defines the
 default versions of all such hooks, which get used by IPython if not
 overridden by the user.
 
 hooks are simple functions, but they should be declared with 'self' as their
 first argument, because when activated they are registered into IPython as
 instance methods.  The self argument will be the IPython running instance
 itself, so hooks have full access to the entire IPython object.
 
 If you wish to define a new hook and activate it, you need to put the
 necessary code into a python file which can be either imported or execfile()'d
 from within your ipythonrc configuration.
 
 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)
 
 You can then enable the functionality by doing 'import myiphooks'
 somewhere in your configuration files or ipython command line.
 """
 
 #*****************************************************************************
 #       Copyright (C) 2005 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.
 #*****************************************************************************
 
-from IPython import ipapi
+import os, bisect
+import sys
 
-import os,bisect
-from genutils import Term,shell
 from pprint import PrettyPrinter
 
+from IPython.utils.io import Term
+from IPython.utils.process import shell
+
+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']
-# vds: <<
+           'show_in_pager','pre_prompt_hook', 'pre_runcode_hook',
+           'clipboard_get']
 
 pformat = PrettyPrinter().pformat
 
 def editor(self,filename, linenum=None):
     """Open the default editor at the given filename and linenumber.
 
     This is IPython's default editor hook, you can use it as an example to
     write your own modified one.  To set your own editor function as the
     new editor hook, call ip.set_hook('editor',yourfunc)."""
 
     # 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':
         linemark = ''
     else:
         linemark = '+%d' % int(linenum)
     
     # Enclose in quotes if necessary and legal
     if ' ' in editor and os.path.isfile(editor) and editor[0] != '"':
         editor = '"%s"' % editor
         
     # 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):
     """Open the editor at the given filename, linenumber, column and 
     show an error message. This is used for correcting syntax errors.
     The current implementation only has special support for the VIM editor,
     and falls back on the 'editor' hook if VIM is not used.
 
     Call ip.set_hook('fix_error_editor',youfunc) to use your own function,
     """
     def vim_quickfix_file():
         t = tempfile.NamedTemporaryFile()
         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: <<
+        pass
+
 
 class CommandChainDispatcher:
     """ Dispatch calls to a chain of commands until some func can handle it
     
     Usage: instantiate, execute "add" to add commands (with optional
     priority), execute normally via f() calling mechanism.
     
     """
     def __init__(self,commands=None):
         if commands is None:
             self.chain = []
         else:
             self.chain = commands
             
             
     def __call__(self,*args, **kw):
         """ Command chain is called just like normal func. 
         
         This will call all funcs in chain with the same args as were given to this
         function, and return the result of first func that didn't raise
         TryNext """
         
         for prio,cmd in self.chain:
             #print "prio",prio,"cmd",cmd #dbg
             try:
-                ret = cmd(*args, **kw)
-                return ret
-            except ipapi.TryNext, exc:
+                return cmd(*args, **kw)
+            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)
     
     def add(self, func, priority=0):
         """ Add a func to the cmd chain with given priority """
         bisect.insort(self.chain,(priority,func))
 
     def __iter__(self):
         """ Return all objects in chain.
         
         Handy if the objects are not callable.
         """
         return iter(self.chain)
-    
+
+
 def result_display(self,arg):
     """ Default display hook.
     
     Called for displaying the result to the user.
     """
     
-    if self.rc.pprint:
+    if self.pprint:
         out = pformat(arg)
         if '\n' in out:
             # So that multi-line strings line up with the left column of
             # the screen, instead of having the output prompt mess up
             # their first line.                
             Term.cout.write('\n')
         print >>Term.cout, out
     else:
         # By default, the interactive prompt uses repr() to display results,
         # so we should honor this.  Users who'd rather use a different
         # mechanism can easily override this hook.
         print >>Term.cout, repr(arg)
     # the default display hook doesn't manipulate the value to put in history
     return None 
 
+
 def input_prefilter(self,line):     
     """ Default input prefilter
     
     This returns the line as unchanged, so that the interpreter
     knows that nothing was done and proceeds with "classic" prefiltering
     (%magics, !shell commands etc.). 
     
     Note that leading whitespace is not passed to this hook. Prefilter
     can't alter indentation.
     
     """
     #print "attempt to rewrite",line #dbg
     return line
 
+
 def shutdown_hook(self):
     """ default shutdown hook
     
     Typically, shotdown hooks should raise TryNext so all shutdown ops are done
     """
     
     #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
     
     Use this e.g. to display output from asynchronous operations (in order 
     to not mess up text entry)   
     """
     
     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.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':
+        chain = [osx_clipboard_get, tkinter_clipboard_get]
+    else:
+        chain = [tkinter_clipboard_get]
+    dispatcher = CommandChainDispatcher()
+    for func in chain:
+        dispatcher.add(func)
+    text = dispatcher()
+    return text

IPython/core/macro.py

@@ -1,43 +1,41 b''
 """Support for interactive macros in IPython"""
 
 #*****************************************************************************
 #       Copyright (C) 2001-2005 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.
 #*****************************************************************************
 
-import IPython.ipapi 
-
-from IPython.genutils import Term
-from IPython.ipapi import IPyAutocall
+from IPython.utils.io import Term
+from IPython.core.autocall import IPyAutocall
 
 class Macro(IPyAutocall):
     """Simple class to store the value of macros as strings.
 
     Macro is just a callable that executes a string of IPython
     input when called.
     
     Args to macro are available in _margv list if you need them.
     """
 
     def __init__(self,data):
 
         # store the macro value, as a single string which can be evaluated by
         # runlines()
         self.value = ''.join(data).rstrip()+'\n'
         
     def __str__(self):
         return self.value
 
     def __repr__(self):
         return 'IPython.macro.Macro(%s)' % repr(self.value)
     
     def __call__(self,*args):
         Term.cout.flush()
         self._ip.user_ns['_margv'] = args
         self._ip.runlines(self.value)
     
     def __getstate__(self):
         """ needed for safe pickling via %store """
         return {'value': self.value}