Merge branch 'master' into kernelmanager

Conflicts:
	IPython/utils/traitlets.py

IPython/config/configurable.py

@@ -0,0 +1,139 b''
+#!/usr/bin/env python
+# encoding: utf-8
+"""
+A base class for objects that are configurable.
+
+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 copy import deepcopy
+import datetime
+from weakref import WeakValueDictionary
+
+from IPython.utils.importstring import import_item
+from loader import Config
+from IPython.utils.traitlets import HasTraits, Instance
+
+
+#-----------------------------------------------------------------------------
+# Helper classes for Configurables
+#-----------------------------------------------------------------------------
+
+
+class ConfigurableError(Exception):
+    pass
+
+
+#-----------------------------------------------------------------------------
+# Configurable implementation
+#-----------------------------------------------------------------------------
+
+
+class Configurable(HasTraits):
+
+    config = Instance(Config,(),{})
+    created = None
+
+    def __init__(self, **kwargs):
+        """Create a conigurable given a config config.
+
+        Parameters
+        ----------
+        config : Config
+            If this is empty, default values are used. If config is a 
+            :class:`Config` instance, it will be used to configure the
+            instance.
+        
+        Notes
+        -----
+        Subclasses of Configurable must call the :meth:`__init__` method of
+        :class:`Configurable` *before* doing anything else and using 
+        :func:`super`::
+        
+            class MyConfigurable(Configurable):
+                def __init__(self, config=None):
+                    super(MyConfigurable, self).__init__(config)
+                    # Then any other code you need to finish initialization.
+
+        This ensures that instances will be configured properly.
+        """
+        config = kwargs.pop('config', None)
+        if config is not None:
+            # 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)
+            self.config = config
+        # This should go second so individual keyword arguments override 
+        # the values in config.
+        super(Configurable, self).__init__(**kwargs)
+        self.created = datetime.datetime.now()
+
+    #-------------------------------------------------------------------------
+    # Static trait notifiations
+    #-------------------------------------------------------------------------
+
+    def _config_changed(self, name, old, new):
+        """Update all the class traits having ``config=True`` as metadata.
+
+        For any class trait with a ``config`` metadata attribute that is
+        ``True``, we update the trait with the value of the corresponding
+        config entry.
+        """
+        # Get all traits with a config metadata entry that is True
+        traits = self.traits(config=True)
+
+        # We auto-load config section for this class as well as any parent
+        # classes that are Configurable subclasses.  This starts with Configurable
+        # 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, Configurable) 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 traits.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 ConfigurableError('Configurable 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))
+

IPython/config/tests/test_configurable.py

@@ -0,0 +1,124 b''
+#!/usr/bin/env python
+# encoding: utf-8
+"""
+Tests for IPython.config.configurable
+
+Authors:
+
+* Brian Granger
+* Fernando Perez (design help)
+"""
+
+#-----------------------------------------------------------------------------
+#  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 unittest import TestCase
+
+from IPython.config.configurable import Configurable, ConfigurableError
+from IPython.utils.traitlets import (
+    TraitError, Int, Float, Str
+)
+from IPython.config.loader import Config
+
+
+#-----------------------------------------------------------------------------
+# Test cases
+#-----------------------------------------------------------------------------
+
+
+class MyConfigurable(Configurable):
+    a = Int(1, config=True)
+    b = Float(1.0, config=True)
+    c = Str('no config')
+
+
+class Foo(Configurable):
+    a = Int(0, config=True)
+    b = Str('nope', config=True)
+
+
+class Bar(Foo):
+    b = Str('gotit', config=False)
+    c = Float(config=True)
+
+
+class TestConfigurableConfig(TestCase):
+
+    def test_default(self):
+        c1 = Configurable()
+        c2 = Configurable(config=c1.config)
+        c3 = Configurable(config=c2.config)
+        self.assertEquals(c1.config, c2.config)
+        self.assertEquals(c2.config, c3.config)
+
+    def test_custom(self):
+        config = Config()
+        config.foo = 'foo'
+        config.bar = 'bar'
+        c1 = Configurable(config=config)
+        c2 = Configurable(config=c1.config)
+        c3 = Configurable(config=c2.config)
+        self.assertEquals(c1.config, config)
+        self.assertEquals(c2.config, config)
+        self.assertEquals(c3.config, config)
+        # Test that copies are not made
+        self.assert_(c1.config is config)
+        self.assert_(c2.config is config)
+        self.assert_(c3.config is config)
+        self.assert_(c1.config is c2.config)
+        self.assert_(c2.config is c3.config)
+        
+    def test_inheritance(self):
+        config = Config()
+        config.MyConfigurable.a = 2
+        config.MyConfigurable.b = 2.0
+        c1 = MyConfigurable(config=config)
+        c2 = MyConfigurable(config=c1.config)
+        self.assertEquals(c1.a, config.MyConfigurable.a)
+        self.assertEquals(c1.b, config.MyConfigurable.b)
+        self.assertEquals(c2.a, config.MyConfigurable.a)
+        self.assertEquals(c2.b, config.MyConfigurable.b)
+
+    def test_parent(self):
+        config = Config()
+        config.Foo.a = 10
+        config.Foo.b = "wow"
+        config.Bar.b = 'later'
+        config.Bar.c = 100.0
+        f = Foo(config=config)
+        b = Bar(config=f.config)
+        self.assertEquals(f.a, 10)
+        self.assertEquals(f.b, 'wow')
+        self.assertEquals(b.b, 'gotit')
+        self.assertEquals(b.c, 100.0)
+
+    def test_override1(self):
+        config = Config()
+        config.MyConfigurable.a = 2
+        config.MyConfigurable.b = 2.0
+        c = MyConfigurable(a=3, config=config)
+        self.assertEquals(c.a, 3)
+        self.assertEquals(c.b, config.MyConfigurable.b)
+        self.assertEquals(c.c, 'no config')
+
+    def test_override2(self):
+        config = Config()
+        config.Foo.a = 1
+        config.Bar.b = 'or'  # Up above b is config=False, so this won't do it.
+        config.Bar.c = 10.0
+        c = Bar(config=config)
+        self.assertEquals(c.a, config.Foo.a)
+        self.assertEquals(c.b, 'gotit')
+        self.assertEquals(c.c, config.Bar.c)
+        c = Bar(a=2, b='and', c=20.0, config=config)
+        self.assertEquals(c.a, 2)
+        self.assertEquals(c.b, 'and')
+        self.assertEquals(c.c, 20.0)

IPython/core/extensions.py

@@ -0,0 +1,125 b''
+# encoding: utf-8
+"""A class for managing IPython extensions.
+
+Authors:
+
+* Brian Granger
+"""
+
+#-----------------------------------------------------------------------------
+#  Copyright (C) 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 IPython.config.configurable import Configurable
+from IPython.utils.traitlets import Instance
+
+#-----------------------------------------------------------------------------
+# Main class
+#-----------------------------------------------------------------------------
+
+class ExtensionManager(Configurable):
+    """A class to manage IPython extensions.
+
+    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.
+    """
+
+    shell = Instance('IPython.core.iplib.InteractiveShellABC')
+
+    def __init__(self, shell=None, config=None):
+        super(ExtensionManager, self).__init__(shell=shell, config=config)
+        self.shell.on_trait_change(
+            self._on_ipython_dir_changed, 'ipython_dir'
+        )
+
+    def __del__(self):
+        self.shell.on_trait_change(
+            self._on_ipython_dir_changed, 'ipython_dir', remove=True
+        )
+
+    @property
+    def ipython_extension_dir(self):
+        return os.path.join(self.shell.ipython_dir, u'extensions')
+
+    def _on_ipython_dir_changed(self):
+        if not os.path.isdir(self.ipython_extension_dir):
+            os.makedirs(self.ipython_extension_dir, mode = 0777)
+
+    def load_extension(self, module_str):
+        """Load an IPython extension by its module name.
+
+        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.shell)
+
+    def _call_unload_ipython_extension(self, mod):
+        if hasattr(mod, 'unload_ipython_extension'):
+            return mod.unload_ipython_extension(self.shell)

IPython/core/plugin.py

@@ -0,0 +1,51 b''
+# encoding: utf-8
+"""IPython plugins.
+
+Authors:
+
+* Brian Granger
+"""
+
+#-----------------------------------------------------------------------------
+#  Copyright (C) 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 IPython.config.configurable import Configurable
+from IPython.utils.traitlets import Dict
+
+#-----------------------------------------------------------------------------
+# Main class
+#-----------------------------------------------------------------------------
+
+class PluginManager(Configurable):
+    """A manager for IPython plugins."""
+
+    plugins = Dict({})
+
+    def __init__(self, config=None):
+        super(PluginManager, self).__init__(config=config)
+
+    def register_plugin(self, name, plugin):
+        if not isinstance(plugin, Plugin):
+            raise TypeError('Expected Plugin, got: %r' % plugin)
+        if self.plugins.has_key(name):
+            raise KeyError('Plugin with name already exists: %r' % name)
+        self.plugins[name] = plugin
+
+    def unregister_plugin(self, name):
+        del self.plugins[name]
+
+    def get_plugin(self, name, default=None):
+        return self.plugins.get(name, default)
+
+
+class Plugin(Configurable):
+    """Base class for IPython plugins."""
+    pass

IPython/core/tests/test_plugin.py

@@ -0,0 +1,46 b''
+"""Tests for plugin.py"""
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
+from unittest import TestCase
+
+from IPython.core.plugin import Plugin, PluginManager
+
+#-----------------------------------------------------------------------------
+# Tests
+#-----------------------------------------------------------------------------
+
+class FooPlugin(Plugin):
+    pass
+
+
+class BarPlugin(Plugin):
+    pass
+
+
+class BadPlugin(object):
+    pass
+
+
+class PluginTest(TestCase):
+
+    def setUp(self):
+        self.manager = PluginManager()
+
+    def test_register_get(self):
+        self.assertEquals(None, self.manager.get_plugin('foo'))
+        foo = FooPlugin()
+        self.manager.register_plugin('foo', foo)
+        self.assertEquals(foo, self.manager.get_plugin('foo'))
+        bar = BarPlugin()
+        self.assertRaises(KeyError, self.manager.register_plugin, 'foo', bar)
+        bad = BadPlugin()
+        self.assertRaises(TypeError, self.manager.register_plugin, 'bad')
+
+    def test_unregister(self):
+        foo = FooPlugin()
+        self.manager.register_plugin('foo', foo)
+        self.manager.unregister_plugin('foo')
+        self.assertEquals(None, self.manager.get_plugin('foo'))

docs/source/config/extensions.txt

@@ -0,0 +1,61 b''
+.. _extensions_overview:
+
+==================
+IPython extensions
+==================
+
+Configuration files are just the first level of customization that IPython
+supports. The next level is that of extensions. An IPython extension is an
+importable Python module that has a a few special function. By defining these
+functions, users can customize IPython by accessing the actual runtime objects
+of IPython.  Here is a sample extension::
+
+    # myextension.py
+
+    def load_ipython_extension(ipython):
+        # The ``ipython`` argument is the currently active 
+        # :class:`InteractiveShell` instance that can be used in any way.
+        # This allows you do to things like register new magics, plugins or
+        # aliases.
+
+    def unload_ipython_extension(ipython):
+        # If you want your extension to be unloadable, put that logic here.
+
+This :func:`load_ipython_extension` 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.
+
+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.
+
+Using extensions
+================
+
+There are two ways you can tell IPython to use your extension:
+
+1. Listing it in a configuration file.
+2. Using the ``%load_ext`` magic function.
+
+To load an extension called :file:`myextension.py` add the following logic
+to your configuration file::
+
+    c.Global.extensions = [
+        'myextension'
+    ]
+
+To load that same extension at runtime, use the ``%load_ext`` magic::
+
+.. sourcecode:: ipython
+
+    In [1]: %load_ext myextension
+
+To summarize, in conjunction with configuration files and profiles, IPython
+extensions give you complete and flexible control over your IPython
+setup.

docs/source/config/plugins.txt

@@ -0,0 +1,23 b''
+.. _plugins_overview:
+
+===============
+IPython plugins
+===============
+
+IPython has a plugin mechanism that allows users to create new and custom
+runtime components for IPython. Plugins are different from extensions:
+
+* Extensions are used to load plugins.
+* Extensions are a more advanced configuration system that gives you access
+  to the running IPython instance.
+* Plugins add entirely new capabilities to IPython.
+* Plugins are traited and configurable.
+
+At this point, our plugin system is brand new and the documentation is 
+minimal. If you are interested in creating a new plugin, see the following
+files:
+
+* :file:`IPython/extensions/parallemagic.py`
+* :file:`IPython/extensions/pretty.`
+
+As well as our documentation on the configuration system and extensions.

docs/source/links.rst

@@ -0,0 +1,74 b''
+.. This (-*- rst -*-) format file contains commonly used link targets
+   and name substitutions.  It may be included in many files,
+   therefore it should only contain link targets and name
+   substitutions.  Try grepping for "^\.\. _" to find plausible
+   candidates for this list.  
+
+   NOTE: this file must have an extension *opposite* to that of the main reST
+   files in the manuals, so that we can include it with ".. include::"
+   directives, but without triggering warnings from Sphinx for not being listed
+   in any toctree.  Since IPython uses .txt for the main files, this wone will
+   use .rst.
+   
+   NOTE: reST targets are
+   __not_case_sensitive__, so only one target definition is needed for
+   ipython, IPython, etc.
+
+   NOTE: Some of these were taken from the nipy links compendium.
+
+.. Main IPython links
+.. _ipython: http://ipython.scipy.org
+.. _`ipython manual`: http://ipython.scipy.org/doc/manual/html
+.. _ipython_github: http://github.com/ipython/ipython/
+.. _ipython_github_repo: http://github.com/ipython/ipython/
+.. _ipython_downloads: http://ipython.scipy.org/dist
+.. _ipython_pypi: http://pypi.python.org/pypi/ipython
+
+.. _ZeroMQ: http://zeromq.org
+
+.. Documentation tools and related links
+.. _graphviz: http://www.graphviz.org
+.. _Sphinx: http://sphinx.pocoo.org
+.. _`Sphinx reST`: http://sphinx.pocoo.org/rest.html
+.. _sampledoc: http://matplotlib.sourceforge.net/sampledoc
+.. _reST: http://docutils.sourceforge.net/rst.html
+.. _docutils: http://docutils.sourceforge.net
+.. _lyx: http://www.lyx.org
+.. _pep8: http://www.python.org/dev/peps/pep-0008
+.. _numpy_coding_guide: http://projects.scipy.org/numpy/wiki/CodingStyleGuidelines
+
+.. Licenses
+.. _GPL: http://www.gnu.org/licenses/gpl.html
+.. _BSD: http://www.opensource.org/licenses/bsd-license.php
+.. _LGPL: http://www.gnu.org/copyleft/lesser.html
+
+.. Other python projects
+.. _numpy: http://numpy.scipy.org
+.. _scipy: http://www.scipy.org
+.. _scipy_conference: http://conference.scipy.org
+.. _matplotlib: http://matplotlib.sourceforge.net
+.. _pythonxy: http://www.pythonxy.com
+.. _ETS: http://code.enthought.com/projects/tool-suite.php
+.. _EPD: http://www.enthought.com/products/epd.php
+.. _python: http://www.python.org
+.. _mayavi: http://code.enthought.com/projects/mayavi
+.. _sympy: http://code.google.com/p/sympy
+.. _sage: http://sagemath.org
+.. _pydy: http://code.google.com/p/pydy
+.. _vpython: http://vpython.org
+.. _cython: http://cython.org
+.. _software carpentry: http://software-carpentry.org
+
+.. Not so python scientific computing tools
+.. _matlab: http://www.mathworks.com
+.. _VTK: http://vtk.org
+
+.. Other organizations
+.. _enthought: http://www.enthought.com
+.. _kitware: http://www.kitware.com
+.. _netlib: http://netlib.org
+
+.. Other tools and projects
+.. _indefero: http://www.indefero.net
+.. _git: http://git-scm.com
+.. _github: http://github.com

IPython/__init__.py

@@ -24,8 +24,8 b' import sys'
 # Setup everything
 #-----------------------------------------------------------------------------
 
-if sys.version[0:3] < '2.5':
-    raise ImportError('Python Version 2.5 or above is required for IPython.')
+if sys.version[0:3] < '2.6':
+    raise ImportError('Python Version 2.6 or above is required for IPython.')
 
 
 # Make it easy to import extensions - they are always directly on pythonpath.

IPython/core/alias.py

@@ -1,10 +1,11 b''
 #!/usr/bin/env python
 # encoding: utf-8
 """
-IPython's alias component
+System command aliases.
 
 Authors:
 
+* Fernando Perez
 * Brian Granger
 """
 
@@ -25,10 +26,10 b' import os'
 import re
 import sys
 
-from IPython.core.component import Component
+from IPython.config.configurable import Configurable
 from IPython.core.splitinput import split_user_input
 
-from IPython.utils.traitlets import List
+from IPython.utils.traitlets import List, Instance
 from IPython.utils.autoattr import auto_attr
 from IPython.utils.warn import warn, error
 
@@ -99,23 +100,18 b' class InvalidAliasError(AliasError):'
 #-----------------------------------------------------------------------------
 
 
-class AliasManager(Component):
+class AliasManager(Configurable):
 
     default_aliases = List(default_aliases(), config=True)
     user_aliases = List(default_value=[], config=True)
+    shell = Instance('IPython.core.iplib.InteractiveShellABC')
 
-    def __init__(self, parent, config=None):
-        super(AliasManager, self).__init__(parent, config=config)
+    def __init__(self, shell=None, config=None):
+        super(AliasManager, self).__init__(shell=shell, 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

IPython/core/application.py

@@ -6,7 +6,7 b' 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.
+object and then create the configurable objects, passing the config to them.
 
 Authors:
 
@@ -76,7 +76,7 b' class BaseAppConfigLoader(ArgParseConfigLoader):'
 
 
 class Application(object):
-    """Load a config, construct components and set them running.
+    """Load a config, construct configurables 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
@@ -113,7 +113,7 b' class Application(object):'
     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.
+    #: The final config that will be passed to the main object.
     master_config = None
     #: A reference to the argv to be used (typically ends up being sys.argv[1:])
     argv = None
@@ -223,10 +223,10 b' class Application(object):'
         """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 HasTraits or Component) are not set in this way.  Instead
+        of Configurables.  But, defaults the top-level Application (which is
+        not a HasTraits or Configurables) 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.
+        don't belong to a particular configurable.
         """
         c = Config()
         c.Global.ipython_dir = get_ipython_dir()
@@ -418,8 +418,8 b' class Application(object):'
         pass
 
     def construct(self):
-        """Construct the main components that make up this app."""
-        self.log.debug("Constructing components for application")
+        """Construct the main objects that make up this app."""
+        self.log.debug("Constructing main objects for application")
 
     def post_construct(self):
         """Do actions after construct, but before starting the app."""

IPython/core/builtin_trap.py

@@ -21,10 +21,10 b' Authors:'
 
 import __builtin__
 
-from IPython.core.component import Component
+from IPython.config.configurable import Configurable
 from IPython.core.quitter import Quitter
 
-from IPython.utils.autoattr import auto_attr
+from IPython.utils.traitlets import Instance
 
 #-----------------------------------------------------------------------------
 # Classes and functions
@@ -35,20 +35,17 b' class __BuiltinUndefined(object): pass'
 BuiltinUndefined = __BuiltinUndefined()
 
 
-class BuiltinTrap(Component):
+class BuiltinTrap(Configurable):
 
-    def __init__(self, parent):
-        super(BuiltinTrap, self).__init__(parent, None, None)
+    shell = Instance('IPython.core.iplib.InteractiveShellABC')
+
+    def __init__(self, shell=None):
+        super(BuiltinTrap, self).__init__(shell=shell, config=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]
+        self.shell = shell
 
     def __enter__(self):
         if self._nested_level == 0:

IPython/core/display_trap.py

@@ -22,34 +22,30 b' Authors:'
 
 import sys
 
-from IPython.core.component import Component
+from IPython.config.configurable import Configurable
+from IPython.utils.traitlets import Any
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
 
-class DisplayTrap(Component):
+class DisplayTrap(Configurable):
     """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
+    hook = Any
+
+    def __init__(self, hook=None):
+        super(DisplayTrap, self).__init__(hook=hook, config=None)
         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()

IPython/core/ipapi.py

@@ -24,13 +24,7 b' has been made into a component, this module will be sent to deathrow.'
 
 
 def get():
-    """Get the most recently created InteractiveShell instance."""
+    """Get the global 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
+    return InteractiveShell.instance()
+

IPython/core/ipapp.py

@@ -475,8 +475,8 b' class IPythonApp(Application):'
         # But that might be the place for them
         sys.path.insert(0, '')
 
-        # Create an InteractiveShell instance
-        self.shell = InteractiveShell(None, self.master_config)
+        # Create an InteractiveShell instance.
+        self.shell = InteractiveShell.instance(config=self.master_config)
 
     def post_construct(self):
         """Do actions after construct, but before starting the app."""
@@ -543,7 +543,7 b' class IPythonApp(Application):'
     def _load_extensions(self):
         """Load all IPython extensions in Global.extensions.
 
-        This uses the :meth:`InteractiveShell.load_extensions` to load all
+        This uses the :meth:`ExtensionManager.load_extensions` to load all
         the extensions listed in ``self.master_config.Global.extensions``.
         """
         try:
@@ -553,7 +553,7 b' class IPythonApp(Application):'
                 for ext in extensions:
                     try:
                         self.log.info("Loading IPython extension: %s" % ext)                        
-                        self.shell.load_extension(ext)
+                        self.shell.extension_manager.load_extension(ext)
                     except:
                         self.log.warn("Error in loading extension: %s" % ext)
                         self.shell.showtraceback()

IPython/core/iplib.py

@@ -1,12 +1,10 b''
 # -*- coding: utf-8 -*-
-"""
-Main IPython Component
-"""
+"""Main IPython class."""
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2001 Janko Hauser <[e-mail]>
 #  Copyright (C) 2001-2007 Fernando Perez. <[e-mail]>
-#  Copyright (C) 2008-2009  The IPython Development Team
+#  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.
@@ -20,6 +18,7 b' from __future__ import with_statement'
 from __future__ import absolute_import
 
 import __builtin__
+import abc
 import bdb
 import codeop
 import exceptions
@@ -38,12 +37,14 b' 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.config.configurable import Configurable
 from IPython.core.display_trap import DisplayTrap
 from IPython.core.error import TryNext, UsageError
+from IPython.core.extensions import ExtensionManager
 from IPython.core.fakemodule import FakeModule, init_fakemod_dict
 from IPython.core.logger import Logger
 from IPython.core.magic import Magic
+from IPython.core.plugin import PluginManager
 from IPython.core.prefilter import PrefilterManager
 from IPython.core.prompts import CachedOutput
 from IPython.core.usage import interactive_usage, default_banner
@@ -69,7 +70,7 b' 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
+    Int, Str, CBool, CaselessStrEnum, Enum, List, Unicode, Instance
 )
 
 # from IPython.utils import growl
@@ -196,7 +197,7 b' class SeparateStr(Str):'
 #-----------------------------------------------------------------------------
 
 
-class InteractiveShell(Component, Magic):
+class InteractiveShell(Configurable, Magic):
     """An enhanced, interactive shell for Python."""
 
     autocall = Enum((0,1,2), default_value=1, config=True)
@@ -281,14 +282,22 b' class InteractiveShell(Component, Magic):'
     # Subclasses with thread support should override this as needed.
     isthreaded = False
 
-    def __init__(self, parent=None, config=None, ipython_dir=None, usage=None,
+    # Subcomponents of InteractiveShell
+    alias_manager = Instance('IPython.core.alias.AliasManager')
+    prefilter_manager = Instance('IPython.core.prefilter.PrefilterManager')
+    builtin_trap = Instance('IPython.core.builtin_trap.BuiltinTrap')
+    display_trap = Instance('IPython.core.display_trap.DisplayTrap')
+    extension_manager = Instance('IPython.core.extensions.ExtensionManager')
+    plugin_manager = Instance('IPython.core.plugin.PluginManager')
+
+    def __init__(self, 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 traits with a config_key argument are updated
         # from the values on config.
-        super(InteractiveShell, self).__init__(parent, config=config)
+        super(InteractiveShell, self).__init__(config=config)
 
         # These are relatively independent and stateless
         self.init_ipython_dir(ipython_dir)
@@ -334,8 +343,21 b' class InteractiveShell(Component, Magic):'
         self.init_reload_doctest()
         self.init_magics()
         self.init_pdb()
+        self.init_extension_manager()
+        self.init_plugin_manager()
         self.hooks.late_startup_hook()
 
+    @classmethod
+    def instance(cls, *args, **kwargs):
+        """Returns a global InteractiveShell instance."""
+        if not hasattr(cls, "_instance"):
+            cls._instance = cls(*args, **kwargs)
+        return cls._instance
+
+    @classmethod
+    def initialized(cls):
+        return hasattr(cls, "_instance")
+
     def get_ipython(self):
         """Return the currently running IPython instance."""
         return self
@@ -353,12 +375,6 b' class InteractiveShell(Component, Magic):'
     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):
@@ -494,7 +510,7 b' class InteractiveShell(Component, Magic):'
             self.magic_logstart()
 
     def init_builtins(self):
-        self.builtin_trap = BuiltinTrap(self)
+        self.builtin_trap = BuiltinTrap(shell=self)
 
     def init_inspector(self):
         # Object inspector
@@ -523,7 +539,7 b' class InteractiveShell(Component, Magic):'
             pass
 
     def init_displayhook(self):
-        self.display_trap = DisplayTrap(self, self.outputcache)
+        self.display_trap = DisplayTrap(hook=self.outputcache)
 
     def init_reload_doctest(self):
         # Do a proper resetting of doctest, including the necessary displayhook
@@ -1743,10 +1759,20 b' class InteractiveShell(Component, Magic):'
     #-------------------------------------------------------------------------
 
     def init_alias(self):
-        self.alias_manager = AliasManager(self, config=self.config)
+        self.alias_manager = AliasManager(shell=self, config=self.config)
         self.ns_table['alias'] = self.alias_manager.alias_table,
 
     #-------------------------------------------------------------------------
+    # Things related to extensions and plugins
+    #-------------------------------------------------------------------------
+
+    def init_extension_manager(self):
+        self.extension_manager = ExtensionManager(shell=self, config=self.config)
+
+    def init_plugin_manager(self):
+        self.plugin_manager = PluginManager(config=self.config)
+
+    #-------------------------------------------------------------------------
     # Things related to the running of code
     #-------------------------------------------------------------------------
 
@@ -2340,101 +2366,11 b' class InteractiveShell(Component, Magic):'
             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)
+        self.prefilter_manager = PrefilterManager(shell=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).
@@ -2580,3 +2516,8 b' class InteractiveShell(Component, Magic):'
         self.restore_sys_module_state()
 
 
+class InteractiveShellABC(object):
+    """An abstract base class for InteractiveShell."""
+    __metaclass__ = abc.ABCMeta
+
+InteractiveShellABC.register(InteractiveShell)

IPython/core/magic.py

@@ -97,11 +97,11 b' def compress_dhist(dh):'
 
 # XXX - for some odd reason, if Magic is made a new-style class, we get errors
 # on construction of the main InteractiveShell object.  Something odd is going
-# on with super() calls, Component and the MRO... For now leave it as-is, but
+# on with super() calls, Configurable and the MRO... For now leave it as-is, but
 # eventually this needs to be clarified.
 # BG: This is because InteractiveShell inherits from this, but is itself a 
-# Component. This messes up the MRO in some way. The fix is that we need to
-# make Magic a component that InteractiveShell does not subclass.
+# Configurable. This messes up the MRO in some way. The fix is that we need to
+# make Magic a configurable that InteractiveShell does not subclass.
 
 class Magic:
     """Magic functions for InteractiveShell.
@@ -3586,15 +3586,15 b' Defaulting color scheme to \'NoColor\'"""'
 
     def magic_load_ext(self, module_str):
         """Load an IPython extension by its module name."""
-        return self.load_extension(module_str)
+        return self.extension_manager.load_extension(module_str)
 
     def magic_unload_ext(self, module_str):
         """Unload an IPython extension by its module name."""
-        self.unload_extension(module_str)
+        self.extension_manager.unload_extension(module_str)
 
     def magic_reload_ext(self, module_str):
         """Reload an IPython extension by its module name."""
-        self.reload_extension(module_str)
+        self.extension_manager.reload_extension(module_str)
 
     @testdec.skip_doctest
     def magic_install_profiles(self, s):

IPython/core/prefilter.py

@@ -31,11 +31,11 b' import re'
 
 from IPython.core.alias import AliasManager
 from IPython.core.autocall import IPyAutocall
-from IPython.core.component import Component
+from IPython.config.configurable import Configurable
 from IPython.core.splitinput import split_user_input
 from IPython.core.page import page
 
-from IPython.utils.traitlets import List, Int, Any, Str, CBool, Bool
+from IPython.utils.traitlets import List, Int, Any, Str, CBool, Bool, Instance
 from IPython.utils.io import Term
 from IPython.utils.text import make_quoted_expr
 from IPython.utils.autoattr import auto_attr
@@ -169,7 +169,7 b' class LineInfo(object):'
 #-----------------------------------------------------------------------------
 
 
-class PrefilterManager(Component):
+class PrefilterManager(Configurable):
     """Main prefilter component.
 
     The IPython prefilter is run on all user input before it is run.  The
@@ -210,19 +210,15 b' class PrefilterManager(Component):'
     """
 
     multi_line_specials = CBool(True, config=True)
+    shell = Instance('IPython.core.iplib.InteractiveShellABC')
 
-    def __init__(self, parent, config=None):
-        super(PrefilterManager, self).__init__(parent, config=config)
+    def __init__(self, shell=None, config=None):
+        super(PrefilterManager, self).__init__(shell=shell, config=config)
+        self.shell = shell
         self.init_transformers()
         self.init_handlers()
         self.init_checkers()
 
-    @auto_attr
-    def shell(self):
-        return Component.get_instances(
-            root=self.root,
-            klass='IPython.core.iplib.InteractiveShell')[0]
-
     #-------------------------------------------------------------------------
     # API for managing transformers
     #-------------------------------------------------------------------------
@@ -231,7 +227,9 b' class PrefilterManager(Component):'
         """Create the default transformers."""
         self._transformers = []
         for transformer_cls in _default_transformers:
-            transformer_cls(self, config=self.config)
+            transformer_cls(
+                shell=self.shell, prefilter_manager=self, config=self.config
+            )
 
     def sort_transformers(self):
         """Sort the transformers by priority.
@@ -265,7 +263,9 b' class PrefilterManager(Component):'
         """Create the default checkers."""
         self._checkers = []
         for checker in _default_checkers:
-            checker(self, config=self.config)
+            checker(
+                shell=self.shell, prefilter_manager=self, config=self.config
+            )
 
     def sort_checkers(self):
         """Sort the checkers by priority.
@@ -300,7 +300,9 b' class PrefilterManager(Component):'
         self._handlers = {}
         self._esc_handlers = {}
         for handler in _default_handlers:
-            handler(self, config=self.config)
+            handler(
+                shell=self.shell, prefilter_manager=self, config=self.config
+            )
 
     @property
     def handlers(self):
@@ -445,28 +447,22 b' class PrefilterManager(Component):'
 #-----------------------------------------------------------------------------
 
 
-class PrefilterTransformer(Component):
+class PrefilterTransformer(Configurable):
     """Transform a line of user input."""
 
     priority = Int(100, config=True)
-    shell = Any
-    prefilter_manager = Any
+    # Transformers don't currently use shell or prefilter_manager, but as we
+    # move away from checkers and handlers, they will need them.
+    shell = Instance('IPython.core.iplib.InteractiveShellABC')
+    prefilter_manager = Instance('IPython.core.prefilter.PrefilterManager')
     enabled = Bool(True, config=True)
 
-    def __init__(self, parent, config=None):
-        super(PrefilterTransformer, self).__init__(parent, config=config)
+    def __init__(self, shell=None, prefilter_manager=None, config=None):
+        super(PrefilterTransformer, self).__init__(
+            shell=shell, prefilter_manager=prefilter_manager, config=config
+        )
         self.prefilter_manager.register_transformer(self)
 
-    @auto_attr
-    def shell(self):
-        return Component.get_instances(
-            root=self.root,
-            klass='IPython.core.iplib.InteractiveShell')[0]
-
-    @auto_attr
-    def prefilter_manager(self):
-        return PrefilterManager.get_instances(root=self.root)[0]
-
     def transform(self, line, continue_prompt):
         """Transform a line, returning the new one."""
         return None
@@ -561,28 +557,20 b' class IPyPromptTransformer(PrefilterTransformer):'
 #-----------------------------------------------------------------------------
 
 
-class PrefilterChecker(Component):
+class PrefilterChecker(Configurable):
     """Inspect an input line and return a handler for that line."""
 
     priority = Int(100, config=True)
-    shell = Any
-    prefilter_manager = Any
+    shell = Instance('IPython.core.iplib.InteractiveShellABC')
+    prefilter_manager = Instance('IPython.core.prefilter.PrefilterManager')
     enabled = Bool(True, config=True)
 
-    def __init__(self, parent, config=None):
-        super(PrefilterChecker, self).__init__(parent, config=config)
+    def __init__(self, shell=None, prefilter_manager=None, config=None):
+        super(PrefilterChecker, self).__init__(
+            shell=shell, prefilter_manager=prefilter_manager, config=config
+        )
         self.prefilter_manager.register_checker(self)
 
-    @auto_attr
-    def shell(self):
-        return Component.get_instances(
-            root=self.root,
-            klass='IPython.core.iplib.InteractiveShell')[0]
-
-    @auto_attr
-    def prefilter_manager(self):
-        return PrefilterManager.get_instances(root=self.root)[0]
-
     def check(self, line_info):
         """Inspect line_info and return a handler instance or None."""
         return None
@@ -709,16 +697,12 b' class AliasChecker(PrefilterChecker):'
 
     priority = Int(800, config=True)
 
-    @auto_attr
-    def alias_manager(self):
-        return AliasManager.get_instances(root=self.root)[0]
-
     def check(self, line_info):
         "Check if the initital identifier on the line is an alias."
         # Note: aliases can not contain '.'
         head = line_info.ifun.split('.',1)[0]
-        if line_info.ifun not in self.alias_manager \
-               or head not in self.alias_manager \
+        if line_info.ifun not in self.shell.alias_manager \
+               or head not in self.shell.alias_manager \
                or is_shadowed(head, self.shell):
             return None
 
@@ -766,31 +750,23 b' class AutocallChecker(PrefilterChecker):'
 #-----------------------------------------------------------------------------
 
 
-class PrefilterHandler(Component):
+class PrefilterHandler(Configurable):
 
     handler_name = Str('normal')
     esc_strings = List([])
-    shell = Any
-    prefilter_manager = Any
+    shell = Instance('IPython.core.iplib.InteractiveShellABC')
+    prefilter_manager = Instance('IPython.core.prefilter.PrefilterManager')
 
-    def __init__(self, parent, config=None):
-        super(PrefilterHandler, self).__init__(parent, config=config)
+    def __init__(self, shell=None, prefilter_manager=None, config=None):
+        super(PrefilterHandler, self).__init__(
+            shell=shell, prefilter_manager=prefilter_manager, config=config
+        )
         self.prefilter_manager.register_handler(
             self.handler_name,
             self,
             self.esc_strings
         )
 
-    @auto_attr
-    def shell(self):
-        return Component.get_instances(
-            root=self.root,
-            klass='IPython.core.iplib.InteractiveShell')[0]
-
-    @auto_attr
-    def prefilter_manager(self):
-        return PrefilterManager.get_instances(root=self.root)[0]
-
     def handle(self, line_info):
         # print "normal: ", line_info
         """Handle normal input lines. Use as a template for handlers."""
@@ -827,13 +803,9 b' class AliasHandler(PrefilterHandler):'
 
     handler_name = Str('alias')
 
-    @auto_attr
-    def alias_manager(self):
-        return AliasManager.get_instances(root=self.root)[0]
-
     def handle(self, line_info):
         """Handle alias input lines. """
-        transformed = self.alias_manager.expand_aliases(line_info.ifun,line_info.the_rest)
+        transformed = self.shell.alias_manager.expand_aliases(line_info.ifun,line_info.the_rest)
         # pre is needed, because it carries the leading whitespace.  Otherwise
         # aliases won't work in indented sections.
         line_out = '%sget_ipython().system(%s)' % (line_info.pre_whitespace,
@@ -894,7 +866,7 b' class AutoHandler(PrefilterHandler):'
     esc_strings = List([ESC_PAREN, ESC_QUOTE, ESC_QUOTE2])
 
     def handle(self, line_info):
-        """Hande lines which can be auto-executed, quoting if requested."""
+        """Handle lines which can be auto-executed, quoting if requested."""
         line    = line_info.line
         ifun    = line_info.ifun
         the_rest = line_info.the_rest

IPython/core/tests/refbug.py

@@ -23,19 +23,25 b' from IPython.core import ipapi'
 #-----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------
-ip = ipapi.get()
 
-if not '_refbug_cache' in ip.user_ns:
-    ip.user_ns['_refbug_cache'] = []
+# This needs to be here because nose and other test runners will import
+# this module. Importing this module has potential side effects that we
+# want to prevent.
+if __name__ == '__main__':
 
+    ip = ipapi.get()
 
-aglobal = 'Hello'
-def f():
-    return aglobal
+    if not '_refbug_cache' in ip.user_ns:
+        ip.user_ns['_refbug_cache'] = []
 
-cache = ip.user_ns['_refbug_cache']
-cache.append(f)
 
-def call_f():
-    for func in cache:
-        print 'lowercased:',func().lower()
+    aglobal = 'Hello'
+    def f():
+        return aglobal
+
+    cache = ip.user_ns['_refbug_cache']
+    cache.append(f)
+
+    def call_f():
+        for func in cache:
+            print 'lowercased:',func().lower()

IPython/extensions/__init__.py

@@ -1,13 +1,2 b''
 # -*- coding: utf-8 -*-
-"""This directory is meant for special-purpose extensions to IPython.
-
-This can include things which alter the syntax processing stage (see
-PhysicalQ_Input for an example of how to do this).
-
-Any file located here can be called with an 'execfile =' option as
-
-  execfile = extensions/filename.py
-
-since the IPython directory itself is already part of the search path for
-files listed as 'execfile ='.
-"""
+"""This directory is meant for IPython extensions."""

IPython/extensions/parallelmagic.py

@@ -16,8 +16,8 b''
 
 import new
 
-from IPython.core.component import Component
-from IPython.utils.traitlets import Bool, Any
+from IPython.core.plugin import Plugin
+from IPython.utils.traitlets import Bool, Any, Instance
 from IPython.utils.autoattr import auto_attr
 from IPython.testing import decorators as testdec
 
@@ -31,28 +31,19 b' Use activate() on a MultiEngineClient object to activate it for magics.'
 """
 
 
-class ParalleMagicComponent(Component):
+class ParalleMagic(Plugin):
     """A component to manage the %result, %px and %autopx magics."""
 
     active_multiengine_client = Any()
     verbose = Bool(False, config=True)
+    shell = Instance('IPython.core.iplib.InteractiveShellABC')
 
-    def __init__(self, parent, name=None, config=None):
-        super(ParalleMagicComponent, self).__init__(parent, name=name, config=config)
+    def __init__(self, shell=None, config=None):
+        super(ParalleMagic, self).__init__(shell=shell, config=config)
         self._define_magics()
         # A flag showing if autopx is activated or not
         self.autopx = False
 
-    # Access other components like this rather than by a regular attribute.
-    # This won't lookup the InteractiveShell object until it is used and
-    # then it is cached.  This is both efficient and couples this class 
-    # more loosely to InteractiveShell.
-    @auto_attr
-    def shell(self):
-        return Component.get_instances(
-            root=self.root,
-            klass='IPython.core.iplib.InteractiveShell')[0]
-
     def _define_magics(self):
         """Define the magic functions."""
         self.shell.define_magic('result', self.magic_result)
@@ -204,6 +195,7 b' def load_ipython_extension(ip):'
     """Load the extension in IPython."""
     global _loaded
     if not _loaded:
-        prd = ParalleMagicComponent(ip, name='parallel_magic')
+        plugin = ParalleMagic(shell=ip, config=ip.config)
+        ip.plugin_manager.register_plugin('parallel_magic', plugin)
         _loaded = True
 

IPython/extensions/pretty.py

@@ -37,8 +37,8 b' by doing::'
 
 from IPython.core.error import TryNext
 from IPython.external import pretty
-from IPython.core.component import Component
-from IPython.utils.traitlets import Bool, List
+from IPython.core.plugin import Plugin
+from IPython.utils.traitlets import Bool, List, Instance
 from IPython.utils.io import Term
 from IPython.utils.autoattr import auto_attr
 from IPython.utils.importstring import import_item
@@ -51,10 +51,11 b' from IPython.utils.importstring import import_item'
 _loaded = False
 
 
-class PrettyResultDisplay(Component):
+class PrettyResultDisplay(Plugin):
     """A component for pretty printing on steroids."""
 
     verbose = Bool(False, config=True)
+    shell = Instance('IPython.core.iplib.InteractiveShellABC')
 
     # A list of (type, func_name), like
     # [(dict, 'my_dict_printer')]
@@ -66,8 +67,8 b' class PrettyResultDisplay(Component):'
     # The final argument can also be a callable
     defaults_for_type_by_name = List(default_value=[], config=True)
 
-    def __init__(self, parent, name=None, config=None):
-        super(PrettyResultDisplay, self).__init__(parent, name=name, config=config)
+    def __init__(self, shell=None, config=None):
+        super(PrettyResultDisplay, self).__init__(shell=shell, config=config)
         self._setup_defaults()
 
     def _setup_defaults(self):
@@ -87,16 +88,6 b' class PrettyResultDisplay(Component):'
         else:
             raise TypeError('func_name must be a str or callable, got: %r' % func_name)
 
-    # Access other components like this rather than by a regular attribute.
-    # This won't lookup the InteractiveShell object until it is used and
-    # then it is cached.  This is both efficient and couples this class 
-    # more loosely to InteractiveShell.
-    @auto_attr
-    def shell(self):
-        return Component.get_instances(
-            root=self.root,
-            klass='IPython.core.iplib.InteractiveShell')[0]
-
     def __call__(self, otherself, arg):
         """Uber-pretty-printing display hook.
 
@@ -132,10 +123,10 b' def load_ipython_extension(ip):'
     """Load the extension in IPython as a hook."""
     global _loaded
     if not _loaded:
-        prd = PrettyResultDisplay(ip, name='pretty_result_display')
-        ip.set_hook('result_display', prd, priority=99)
+        plugin = PrettyResultDisplay(shell=ip, config=ip.config)
+        ip.set_hook('result_display', plugin, priority=99)
         _loaded = True
-        return prd
+        ip.plugin_manager.register_plugin('pretty_result_display', plugin)
 
 def unload_ipython_extension(ip):
     """Unload the extension."""

IPython/extensions/tests/test_pretty.py

@@ -17,8 +17,8 b' Simple tests for :mod:`IPython.extensions.pretty`.'
 
 from unittest import TestCase
 
-from IPython.core.component import Component, masquerade_as
-from IPython.core.iplib import InteractiveShell
+from IPython.config.configurable import Configurable
+from IPython.core.iplib import InteractiveShellABC
 from IPython.extensions import pretty as pretty_ext
 from IPython.external import pretty
 from IPython.testing import decorators as dec
@@ -29,9 +29,11 b' from IPython.utils.traitlets import Bool'
 # Tests
 #-----------------------------------------------------------------------------
 
-class InteractiveShellStub(Component):
+class InteractiveShellStub(Configurable):
     pprint = Bool(True)
 
+InteractiveShellABC.register(InteractiveShellStub)
+
 class A(object):
     pass
 
@@ -41,12 +43,8 b' def a_pprinter(o, p, c):'
 class TestPrettyResultDisplay(TestCase):
 
     def setUp(self):
-        self.ip = InteractiveShellStub(None)
-        # This allows our stub to be retrieved instead of the real
-        # InteractiveShell
-        masquerade_as(self.ip, InteractiveShell)
-        self.prd = pretty_ext.PrettyResultDisplay(self.ip,
-                                                  name='pretty_result_display')
+        self.ip = InteractiveShellStub()
+        self.prd = pretty_ext.PrettyResultDisplay(shell=self.ip, config=None)
 
     def test_for_type(self):
         self.prd.for_type(A, a_pprinter)
@@ -77,7 +75,8 b' a'
 b
 
 ip = get_ipython()
-prd = ip.load_extension('pretty')
+ip.extension_manager.load_extension('pretty')
+prd = ip.plugin_manager.get_plugin('pretty_result_display')
 prd.for_type(A, a_pretty_printer)
 prd.for_type_by_name(B.__module__, B.__name__, b_pretty_printer)
 

IPython/kernel/clusterdir.py

@@ -26,7 +26,7 b' from twisted.python import log'
 
 from IPython.config.loader import PyFileConfigLoader
 from IPython.core.application import Application, BaseAppConfigLoader
-from IPython.core.component import Component
+from IPython.config.configurable import Configurable
 from IPython.core.crashhandler import CrashHandler
 from IPython.core import release
 from IPython.utils.path import (
@@ -63,7 +63,7 b' class PIDFileError(Exception):'
 # Class for managing cluster directories
 #-----------------------------------------------------------------------------
 
-class ClusterDir(Component):
+class ClusterDir(Configurable):
     """An object to manage the cluster directory and its resources.
 
     The cluster directory is used by :command:`ipcontroller`, 
@@ -82,9 +82,8 b' class ClusterDir(Component):'
     pid_dir = Unicode(u'')
     location = Unicode(u'')
 
-    def __init__(self, location):
-        super(ClusterDir, self).__init__(None)
-        self.location = location
+    def __init__(self, location=u''):
+        super(ClusterDir, self).__init__(location=location)
 
     def _location_changed(self, name, old, new):
         if not os.path.isdir(new):
@@ -166,7 +165,7 b' class ClusterDir(Component):'
             The full path to the cluster directory.  If it does exist, it will
             be used.  If not, it will be created.
         """
-        return ClusterDir(cluster_dir)
+        return ClusterDir(location=cluster_dir)
 
     @classmethod
     def create_cluster_dir_by_profile(cls, path, profile=u'default'):
@@ -183,7 +182,7 b' class ClusterDir(Component):'
         if not os.path.isdir(path):
             raise ClusterDirError('Directory not found: %s' % path)
         cluster_dir = os.path.join(path, u'cluster_' + profile)
-        return ClusterDir(cluster_dir)
+        return ClusterDir(location=cluster_dir)
 
     @classmethod
     def find_cluster_dir_by_profile(cls, ipython_dir, profile=u'default'):
@@ -216,7 +215,7 b' class ClusterDir(Component):'
         for p in paths:
             cluster_dir = os.path.join(p, dirname)
             if os.path.isdir(cluster_dir):
-                return ClusterDir(cluster_dir)
+                return ClusterDir(location=cluster_dir)
         else:
             raise ClusterDirError('Cluster directory not found in paths: %s' % dirname)
 
@@ -235,7 +234,7 b' class ClusterDir(Component):'
         cluster_dir = expand_path(cluster_dir)
         if not os.path.isdir(cluster_dir):
             raise ClusterDirError('Cluster directory not found: %s' % cluster_dir)
-        return ClusterDir(cluster_dir)
+        return ClusterDir(location=cluster_dir)
 
 
 #-----------------------------------------------------------------------------

IPython/kernel/configobjfactory.py

@@ -18,7 +18,7 b' configuration system.'
 
 import zope.interface as zi
 
-from IPython.core.component import Component
+from IPython.config.configurable import Configurable
 
 #-----------------------------------------------------------------------------
 # Code
@@ -29,7 +29,7 b' class IConfiguredObjectFactory(zi.Interface):'
     """I am a component that creates a configured object.
 
     This class is useful if you want to configure a class that is not a 
-    subclass of :class:`IPython.core.component.Component`.
+    subclass of :class:`IPython.config.configurable.Configurable`.
     """
 
     def __init__(config):
@@ -39,12 +39,12 b' class IConfiguredObjectFactory(zi.Interface):'
         """Return an instance of the configured object."""
 
 
-class ConfiguredObjectFactory(Component):
+class ConfiguredObjectFactory(Configurable):
 
     zi.implements(IConfiguredObjectFactory)
 
-    def __init__(self, config):
-        super(ConfiguredObjectFactory, self).__init__(None, config=config)
+    def __init__(self, config=None):
+        super(ConfiguredObjectFactory, self).__init__(config=config)
 
     def create(self):
         raise NotImplementedError('create must be implemented in a subclass')
@@ -56,24 +56,24 b' class IAdaptedConfiguredObjectFactory(zi.Interface):'
     This class is useful if you have the adapt an instance and configure it.
     """
 
-    def __init__(config, adaptee=None):
+    def __init__(config=None, adaptee=None):
         """Get ready to adapt adaptee and then configure it using config."""
 
     def create():
         """Return an instance of the adapted and configured object."""
 
 
-class AdaptedConfiguredObjectFactory(Component):
+class AdaptedConfiguredObjectFactory(Configurable):
 
     # zi.implements(IAdaptedConfiguredObjectFactory)
 
-    def __init__(self, config, adaptee):
+    def __init__(self, config=None, adaptee=None):
         # print
         # print "config pre:", config
-        super(AdaptedConfiguredObjectFactory, self).__init__(None, config=config)
+        super(AdaptedConfiguredObjectFactory, self).__init__(config=config)
         # print
         # print "config post:", config
         self.adaptee = adaptee
 
     def create(self):
-        raise NotImplementedError('create must be implemented in a subclass')
  No newline at end of file
+        raise NotImplementedError('create must be implemented in a subclass')

IPython/kernel/fcutil.py

@@ -191,9 +191,9 b' class FCServiceFactory(AdaptedConfiguredObjectFactory):'
     """This class creates a tub with various services running in it.
 
     The basic idea is that :meth:`create` returns a running :class:`Tub`
-    instance that has a number of Foolscap references registered in it.
-    This class is a subclass of :class:`IPython.core.component.Component`
-    so the IPython configuration and component system are used.
+    instance that has a number of Foolscap references registered in it. This
+    class is a subclass of :class:`IPython.config.configurable.Configurable`
+    so the IPython configuration system is used.
 
     Attributes
     ----------

IPython/kernel/launcher.py

@@ -19,7 +19,7 b' import os'
 import re
 import sys
 
-from IPython.core.component import Component
+from IPython.config.configurable import Configurable
 from IPython.external import Itpl
 from IPython.utils.traitlets import Str, Int, List, Unicode
 from IPython.utils.path import get_ipython_module_path
@@ -77,7 +77,7 b' class UnknownStatus(LauncherError):'
     pass
 
 
-class BaseLauncher(Component):
+class BaseLauncher(Configurable):
     """An asbtraction for starting, stopping and signaling a process."""
 
     # In all of the launchers, the work_dir is where child processes will be
@@ -89,9 +89,8 b' class BaseLauncher(Component):'
     # the --work-dir option.
     work_dir = Unicode(u'')
 
-    def __init__(self, work_dir, parent=None, name=None, config=None):
-        super(BaseLauncher, self).__init__(parent, name, config)
-        self.work_dir = work_dir
+    def __init__(self, work_dir=u'', config=None):
+        super(BaseLauncher, self).__init__(work_dir=work_dir, config=config)
         self.state = 'before' # can be before, running, after
         self.stop_deferreds = []
         self.start_data = None
@@ -265,9 +264,9 b' class LocalProcessLauncher(BaseLauncher):'
     # spawnProcess.
     cmd_and_args = List([])
 
-    def __init__(self, work_dir, parent=None, name=None, config=None):
+    def __init__(self, work_dir=u'', config=None):
         super(LocalProcessLauncher, self).__init__(
-            work_dir, parent, name, config
+            work_dir=work_dir, config=config
         )
         self.process_protocol = None
         self.start_deferred = None
@@ -356,9 +355,9 b' class LocalEngineSetLauncher(BaseLauncher):'
         ['--log-to-file','--log-level', '40'], config=True
     )
 
-    def __init__(self, work_dir, parent=None, name=None, config=None):
+    def __init__(self, work_dir=u'', config=None):
         super(LocalEngineSetLauncher, self).__init__(
-            work_dir, parent, name, config
+            work_dir=work_dir, config=config
         )
         self.launchers = []
 
@@ -367,7 +366,7 b' class LocalEngineSetLauncher(BaseLauncher):'
         self.cluster_dir = unicode(cluster_dir)
         dlist = []
         for i in range(n):
-            el = LocalEngineLauncher(self.work_dir, self)
+            el = LocalEngineLauncher(work_dir=self.work_dir, config=self.config)
             # Copy the engine args over to each engine launcher.
             import copy
             el.engine_args = copy.deepcopy(self.engine_args)
@@ -560,9 +559,9 b' class WindowsHPCLauncher(BaseLauncher):'
     scheduler = Str('', config=True)
     job_cmd = Str(find_job_cmd(), config=True)
 
-    def __init__(self, work_dir, parent=None, name=None, config=None):
+    def __init__(self, work_dir=u'', config=None):
         super(WindowsHPCLauncher, self).__init__(
-            work_dir, parent, name, config
+            work_dir=work_dir, config=config
         )
 
     @property
@@ -633,9 +632,9 b' class WindowsHPCControllerLauncher(WindowsHPCLauncher):'
     extra_args = List([], config=False)
 
     def write_job_file(self, n):
-        job = IPControllerJob(self)
+        job = IPControllerJob(config=self.config)
 
-        t = IPControllerTask(self)
+        t = IPControllerTask(config=self.config)
         # The tasks work directory is *not* the actual work directory of 
         # the controller. It is used as the base path for the stdout/stderr
         # files that the scheduler redirects to.
@@ -664,10 +663,10 b' class WindowsHPCEngineSetLauncher(WindowsHPCLauncher):'
     extra_args = List([], config=False)
 
     def write_job_file(self, n):
-        job = IPEngineSetJob(self)
+        job = IPEngineSetJob(config=self.config)
 
         for i in range(n):
-            t = IPEngineTask(self)
+            t = IPEngineTask(config=self.config)
             # The tasks work directory is *not* the actual work directory of 
             # the engine. It is used as the base path for the stdout/stderr
             # files that the scheduler redirects to.
@@ -725,9 +724,9 b' class BatchSystemLauncher(BaseLauncher):'
     # The full path to the instantiated batch script.
     batch_file = Unicode(u'')
 
-    def __init__(self, work_dir, parent=None, name=None, config=None):
+    def __init__(self, work_dir=u'', config=None):
         super(BatchSystemLauncher, self).__init__(
-            work_dir, parent, name, config
+            work_dir=work_dir, config=config
         )
         self.batch_file = os.path.join(self.work_dir, self.batch_file_name)
         self.context = {}

IPython/kernel/winhpcjob.py

@@ -24,14 +24,14 b' import uuid'
 
 from xml.etree import ElementTree as ET
 
-from IPython.core.component import Component
+from IPython.config.configurable import Configurable
 from IPython.utils.traitlets import (
     Str, Int, List, Instance,
     Enum, Bool, CStr
 )
 
 #-----------------------------------------------------------------------------
-# Job and Task Component
+# Job and Task classes
 #-----------------------------------------------------------------------------
 
 
@@ -74,7 +74,7 b' def find_username():'
         return '%s\\%s' % (domain, username)
 
 
-class WinHPCJob(Component):
+class WinHPCJob(Configurable):
 
     job_id = Str('')
     job_name = Str('MyJob', config=True)
@@ -165,7 +165,7 b' class WinHPCJob(Component):'
         self.tasks.append(task)
 
 
-class WinHPCTask(Component):
+class WinHPCTask(Configurable):
 
     task_id = Str('')
     task_name = Str('')
@@ -261,8 +261,8 b' class IPControllerTask(WinHPCTask):'
     unit_type = Str("Core", config=False)
     work_directory = CStr('', config=False)
 
-    def __init__(self, parent, name=None, config=None):
-        super(IPControllerTask, self).__init__(parent, name, config)
+    def __init__(self, config=None):
+        super(IPControllerTask, self).__init__(config=config)
         the_uuid = uuid.uuid1()
         self.std_out_file_path = os.path.join('log','ipcontroller-%s.out' % the_uuid)
         self.std_err_file_path = os.path.join('log','ipcontroller-%s.err' % the_uuid)
@@ -289,8 +289,8 b' class IPEngineTask(WinHPCTask):'
     unit_type = Str("Core", config=False)
     work_directory = CStr('', config=False)
 
-    def __init__(self, parent, name=None, config=None):
-        super(IPEngineTask,self).__init__(parent, name, config)
+    def __init__(self, config=None):
+        super(IPEngineTask,self).__init__(config=config)
         the_uuid = uuid.uuid1()
         self.std_out_file_path = os.path.join('log','ipengine-%s.out' % the_uuid)
         self.std_err_file_path = os.path.join('log','ipengine-%s.err' % the_uuid)

IPython/testing/globalipapp.py

@@ -136,8 +136,8 b' def start_ipython():'
     config = tools.default_config()
 
     # Create and initialize our test-friendly IPython instance.
-    shell = iplib.InteractiveShell(
-        parent=None, config=config, 
+    shell = iplib.InteractiveShell.instance(
+        config=config, 
         user_ns=ipnsdict(), user_global_ns={}
     )
 

IPython/utils/tests/test_traitlets.py

@@ -360,6 +360,13 b' class TestHasTraits(TestCase):'
         traits = a.traits(config_key=lambda v: True)
         self.assertEquals(traits, dict(i=A.i, f=A.f, j=A.j))
 
+    def test_init(self):
+        class A(HasTraits):
+            i = Int()
+            x = Float()
+        a = A(i=1, x=10.0)
+        self.assertEquals(a.i, 1)
+        self.assertEquals(a.x, 10.0)
 
 #-----------------------------------------------------------------------------
 # Tests for specific trait types

IPython/utils/traitlets.py

@@ -372,14 +372,14 b' class HasTraits(object):'
 
     __metaclass__ = MetaHasTraits
 
-    def __new__(cls, *args, **kw):
+    def __new__(cls, **kw):
         # This is needed because in Python 2.6 object.__new__ only accepts
         # the cls argument.
         new_meth = super(HasTraits, cls).__new__
         if new_meth is object.__new__:
             inst = new_meth(cls)
         else:
-            inst = new_meth(cls, *args, **kw)
+            inst = new_meth(cls, **kw)
         inst._trait_values = {}
         inst._trait_notifiers = {}
         # Here we tell all the TraitType instances to set their default
@@ -398,9 +398,12 b' class HasTraits(object):'
 
         return inst
 
-    # def __init__(self):
-    #     self._trait_values = {}
-    #     self._trait_notifiers = {}
+    def __init__(self, **kw):
+        # Allow trait values to be set using keyword arguments.
+        # We need to use setattr for this to trigger validation and
+        # notifications.
+        for key, value in kw.iteritems():
+            setattr(self, key, value)
 
     def _notify_trait(self, name, old_value, new_value):
 
@@ -1018,6 +1021,28 b' class List(Instance):'
                                   allow_none=allow_none, **metadata)
 
 
+class Dict(Instance):
+    """An instance of a Python dict."""
+
+    def __init__(self, default_value=None, allow_none=True, **metadata):
+        """Create a dict trait type from a dict.
+
+        The default value is created by doing ``dict(default_value)``, 
+        which creates a copy of the ``default_value``.
+        """
+        if default_value is None:
+            args = ((),)
+        elif isinstance(default_value, dict):
+            args = (default_value,)
+        elif isinstance(default_value, SequenceTypes):
+            args = (default_value,)
+        else:
+            raise TypeError('default value of Dict was %s' % default_value)
+
+        super(Dict,self).__init__(klass=dict, args=args, 
+                                  allow_none=allow_none, **metadata)
+
+
 class TCPAddress(TraitType):
     """A trait for an (ip, port) tuple.
 
@@ -1035,4 +1060,3 b' class TCPAddress(TraitType):'
                     if port >= 0 and port <= 65535:
                         return value
         self.error(obj, value)
-

docs/Makefile

@@ -39,8 +39,9 b' pdf: latex'
 
 all: html pdf
 
-dist: clean all
+dist: all
 	mkdir -p dist
+	rm -rf dist/*
 	ln build/latex/ipython.pdf dist/
 	cp -al build/html dist/
 	@echo "Build finished.  Final docs are in dist/"
@@ -98,3 +99,6 b' linkcheck:'
 gitwash-update:
 	python ../tools/gitwash_dumper.py source/development ipython
 	cd source/development/gitwash && rename 's/.rst/.txt/' *.rst
+
+nightly: dist
+	rsync -avH --delete dist/ ipython:www/doc/nightly
  No newline at end of file

docs/autogen_api.py

@@ -27,7 +27,12 b" if __name__ == '__main__':"
                                         r'\.config\.default',
                                         r'\.config\.profile',
                                         r'\.frontend',
-                                        r'\.gui'
+                                        r'\.gui',
+                                        # For now, the zmq code has
+                                        # unconditional top-level code so it's
+                                        # not import safe.  This needs fixing
+                                        # soon.
+                                        r'\.zmq',
                                         ]
 
     docwriter.module_skip_patterns += [ r'\.core\.fakemodule',
@@ -38,7 +43,7 b" if __name__ == '__main__':"
                                         # for each group copied below
                                         
                                         # AttributeError: __abstractmethods__
-                                        r'\.core\.component',
+                                        r'\.config\.configurable',
                                         r'\.utils\.traitlets',
         
                                         # AttributeError: __provides__

docs/source/config/index.txt

@@ -8,6 +8,8 b' Configuration and customization'
    :maxdepth: 2
 
    overview.txt
+   extensions.txt
+   plugins.txt
    ipython.txt
    editors.txt
    old.txt

docs/source/config/ipython.txt

@@ -133,4 +133,4 b' attributes::'
 
     c.AliasManager.user_aliases = [
      ('la', 'ls -al')
-    ]
  No newline at end of file
+    ]

docs/source/config/overview.txt

@@ -42,29 +42,26 b' Application: :class:`~IPython.core.application.Application`'
     application is the :command:`ipython` command line program. Each
     application reads a *single* configuration file and command line options
     and then produces a master configuration object for the application. This
-    configuration object is then passed to the components that the application
-    creates. Components implement the actual logic of the application and know
-    how to configure themselves given the configuration object.
-
-Component: :class:`~IPython.core.component.Component`
-    A component is a regular Python class that serves as a base class for all
-    main classes in an application. The
-    :class:`~IPython.core.component.Component` base class is lightweight and
-    only does two main things.
+    configuration object is then passed to the configurable objects that the
+    application creates. These configurable objects implement the actual logic
+    of the application and know how to configure themselves given the
+    configuration object.
+
+Component: :class:`~IPython.config.configurable.Configurable`
+    A configurable is a regular Python class that serves as a base class for
+    all main classes in an application. The
+    :class:`~IPython.config.configurable.Configurable` base class is
+    lightweight and only does one things.
+
+    This :class:`~IPython.config.configurable.Configurable` is a subclass
+    of :class:`~IPython.utils.traitlets.HasTraits` that knows how to configure
+    itself. Class level traits with the metadata ``config=True`` become
+    values that can be configured from the command line and configuration
+    files.
     
-    First, it keeps track of all instances of itself and provides an
-    interfaces for querying those instances. This enables components to get
-    references to other components, even though they are not "nearby" in the
-    runtime object graph.
-    
-    Second, it declares what class attributes are configurable and specifies
-    the default types and values of those attributes. This information is used
-    to automatically configure instances given the applications configuration
-    object.
-    
-    Developers create :class:`~IPython.core.component.Component` subclasses
-    that implement all of the logic in the application. Each of these
-    subclasses has its own configuration information that controls how
+    Developers create :class:`~IPython.config.configurable.Configurable`
+    subclasses that implement all of the logic in the application. Each of
+    these subclasses has its own configuration information that controls how
     instances are created.
 
 Having described these main concepts, we can now state the main idea in our
@@ -73,7 +70,9 b' attributes to be controlled on a class by class basis*. Thus all instances of'
 a given class are configured in the same way. Furthermore, if two instances
 need to be configured differently, they need to be instances of two different
 classes. While this model may seem a bit restrictive, we have found that it
-expresses most things that need to be configured extremely well.
+expresses most things that need to be configured extremely well. However, it
+is possible to create two instances of the same class that have different
+trait values. This is done by overriding the configuration.
 
 Now, we show what our configuration objects and files look like.
 
@@ -98,33 +97,34 b' attributes on it. All you have to know is:'
 * The type of each attribute.
 
 The answers to these two questions are provided by the various
-:class:`~IPython.core.component.Component` subclasses that an application
-uses.  Let's look at how this would work for a simple component subclass::
+:class:`~IPython.config.configurable.Configurable` subclasses that an
+application uses. Let's look at how this would work for a simple component
+subclass::
 
     # Sample component that can be configured.
-    from IPython.core.component import Component
+    from IPython.config.configurable import Configurable
     from IPython.utils.traitlets import Int, Float, Str, Bool
     
-    class MyComponent(Component):
+    class MyClass(Configurable):
         name = Str('defaultname', config=True)
         ranking = Int(0, config=True)
         value = Float(99.0)
         # The rest of the class implementation would go here..
 
-In this example, we see that :class:`MyComponent` has three attributes, two
+In this example, we see that :class:`MyClass` has three attributes, two
 of whom (``name``, ``ranking``) can be configured.  All of the attributes
-are given types and default values.  If a :class:`MyComponent` is instantiated,
+are given types and default values.  If a :class:`MyClass` is instantiated,
 but not configured, these default values will be used.  But let's see how
 to configure this class in a configuration file::
 
     # Sample config file
     c = get_config()
     
-    c.MyComponent.name = 'coolname'
-    c.MyComponent.ranking = 10
+    c.MyClass.name = 'coolname'
+    c.MyClass.ranking = 10
 
 After this configuration file is loaded, the values set in it will override
-the class defaults anytime a :class:`MyComponent` is created.  Furthermore,
+the class defaults anytime a :class:`MyClass` is created.  Furthermore,
 these attributes will be type checked and validated anytime they are set.
 This type checking is handled by the :mod:`IPython.utils.traitlets` module,
 which provides the :class:`Str`, :class:`Int` and :class:`Float` types.  In 
@@ -133,7 +133,7 b' traitlets for a number of other types.'
 
 .. note::
 
-    Underneath the hood, the :class:`Component` base class is a subclass of
+    Underneath the hood, the :class:`Configurable` base class is a subclass of
     :class:`IPython.utils.traitlets.HasTraits`. The
     :mod:`IPython.utils.traitlets` module is a lightweight version of
     :mod:`enthought.traits`. Our implementation is a pure Python subset
@@ -157,7 +157,7 b' attribute of ``c`` is not the actual class, but instead is another'
 
 .. note::
 
-    The careful reader may wonder how the ``ClassName`` (``MyComponent`` in
+    The careful reader may wonder how the ``ClassName`` (``MyClass`` in
     the above example) attribute of the configuration object ``c`` gets
     created. These attributes are created on the fly by the
     :class:`~IPython.config.loader.Config` instance, using a simple naming
@@ -165,8 +165,7 b' attribute of ``c`` is not the actual class, but instead is another'
     instance whose name begins with an uppercase character is assumed to be a
     sub-configuration and a new empty :class:`~IPython.config.loader.Config`
     instance is dynamically created for that attribute. This allows deeply
-    hierarchical information created easily (``c.Foo.Bar.value``) on the 
-    fly.
+    hierarchical information created easily (``c.Foo.Bar.value``) on the fly.
 
 Configuration files inheritance
 ===============================
@@ -179,8 +178,8 b' example that loads all of the values from the file :file:`base_config.py`::'
 
     # base_config.py
     c = get_config()
-    c.MyComponent.name = 'coolname'
-    c.MyComponent.ranking = 100
+    c.MyClass.name = 'coolname'
+    c.MyClass.ranking = 100
 
 into the configuration file :file:`main_config.py`::
 
@@ -191,7 +190,7 b' into the configuration file :file:`main_config.py`::'
     load_subconfig('base_config.py')
     
     # Now override one of the values
-    c.MyComponent.name = 'bettername'
+    c.MyClass.name = 'bettername'
 
 In a situation like this the :func:`load_subconfig` makes sure that the
 search path for sub-configuration files is inherited from that of the parent.
@@ -205,10 +204,10 b' There is another aspect of configuration where inheritance comes into play.'
 Sometimes, your classes will have an inheritance hierarchy that you want
 to be reflected in the configuration system.  Here is a simple example::
 
-    from IPython.core.component import Component
+    from IPython.config.configurable import Configurable
     from IPython.utils.traitlets import Int, Float, Str, Bool
     
-    class Foo(Component):
+    class Foo(Configurable):
         name = Str('fooname', config=True)
         value = Float(100.0, config=True)
     
@@ -328,4 +327,3 b' Here are the main requirements we wanted our configuration system to have:'
   dynamic language and you don't always know everything that needs to be
   configured when a program starts.
 
-

docs/source/development/messaging.txt

@@ -1,106 +1,579 b''
-=====================
-Message Specification
-=====================
+======================
+ Messaging in IPython
+======================
 
-Note: not all of these have yet been fully fleshed out, but the key ones are,
-see kernel and frontend files for actual implementation details.
 
-General Message Format
+Introduction
+============
+
+This document explains the basic communications design and messaging
+specification for how the various IPython objects interact over a network
+transport.  The current implementation uses the ZeroMQ_ library for messaging
+within and between hosts.
+
+.. Note::
+
+   This document should be considered the authoritative description of the
+   IPython messaging protocol, and all developers are strongly encouraged to
+   keep it updated as the implementation evolves, so that we have a single
+   common reference for all protocol details.
+   
+The basic design is explained in the following diagram:
+
+.. image:: frontend-kernel.png
+   :width: 450px
+   :alt: IPython kernel/frontend messaging architecture.
+   :align: center
+   :target: ../_images/frontend-kernel.png
+
+A single kernel can be simultaneously connected to one or more frontends.  The
+kernel has three sockets that serve the following functions:
+
+1. REQ: this socket is connected to a *single* frontend at a time, and it allows
+   the kernel to request input from a frontend when :func:`raw_input` is called.
+   The frontend holding the matching REP socket acts as a 'virtual keyboard'
+   for the kernel while this communication is happening (illustrated in the
+   figure by the black outline around the central keyboard).  In practice,
+   frontends may display such kernel requests using a special input widget or
+   otherwise indicating that the user is to type input for the kernel instead
+   of normal commands in the frontend.
+
+2. XREP: this single sockets allows multiple incoming connections from
+   frontends, and this is the socket where requests for code execution, object
+   information, prompts, etc. are made to the kernel by any frontend.  The
+   communication on this socket is a sequence of request/reply actions from
+   each frontend and the kernel.
+
+3. PUB: this socket is the 'broadcast channel' where the kernel publishes all
+   side effects (stdout, stderr, etc.) as well as the requests coming from any
+   client over the XREP socket and its own requests on the REP socket.  There
+   are a number of actions in Python which generate side effects: :func:`print`
+   writes to ``sys.stdout``, errors generate tracebacks, etc.  Additionally, in
+   a multi-client scenario, we want all frontends to be able to know what each
+   other has sent to the kernel (this can be useful in collaborative scenarios,
+   for example).  This socket allows both side effects and the information
+   about communications taking place with one client over the XREQ/XREP channel
+   to be made available to all clients in a uniform manner.
+
+   All messages are tagged with enough information (details below) for clients
+   to know which messages come from their own interaction with the kernel and
+   which ones are from other clients, so they can display each type
+   appropriately.
+
+The actual format of the messages allowed on each of these channels is
+specified below.  Messages are dicts of dicts with string keys and values that
+are reasonably representable in JSON.  Our current implementation uses JSON
+explicitly as its message format, but this shouldn't be considered a permanent
+feature.  As we've discovered that JSON has non-trivial performance issues due
+to excessive copying, we may in the future move to a pure pickle-based raw
+message format.  However, it should be possible to easily convert from the raw
+objects to JSON, since we may have non-python clients (e.g. a web frontend).
+As long as it's easy to make a JSON version of the objects that is a faithful
+representation of all the data, we can communicate with such clients.
+
+.. Note::
+
+   Not all of these have yet been fully fleshed out, but the key ones are, see
+   kernel and frontend files for actual implementation details.
+
+   
+Python functional API
 =====================
 
-General message format::
+As messages are dicts, they map naturally to a ``func(**kw)`` call form.  We
+should develop, at a few key points, functional forms of all the requests that
+take arguments in this manner and automatically construct the necessary dict
+for sending.
+
+
+General Message Format
+======================
 
+All messages send or received by any IPython process should have the following
+generic structure::
+    
     {
-        header : { 'msg_id' : 10,    # start with 0
-	           'username' : 'name',
+      # The message header contains a pair of unique identifiers for the
+      # originating session and the actual message id, in addition to the
+      # username for the process that generated the message.  This is useful in
+      # collaborative settings where multiple users may be interacting with the
+      # same kernel simultaneously, so that frontends can label the various
+      # messages in a meaningful way.
+      'header' : { 'msg_id' : uuid,
+                   'username' : str,
 		   'session' : uuid
-		   },
-	parent_header : dict,
-        msg_type : 'string_message_type',
-        content : blackbox_dict , # Must be a dict
+		 },
+
+      # In a chain of messages, the header from the parent is copied so that
+      # clients can track where messages come from.
+      'parent_header' : dict,
+
+      # All recognized message type strings are listed below.
+      'msg_type' : str,
+
+      # The actual content of the message must be a dict, whose structure
+      # depends on the message type.x
+      'content' : dict,
     }
 
-Side effect: (PUB/SUB)
-======================
+For each message type, the actual content will differ and all existing message
+types are specified in what follows of this document.
 
-# msg_type = 'stream'::
+
+Messages on the XREP/XREQ socket
+================================
+
+.. _execute:
+
+Execute
+-------
+
+The execution request contains a single string, but this may be a multiline
+string.  The kernel is responsible for splitting this into possibly more than
+one block and deciding whether to compile these in 'single' or 'exec' mode.
+We're still sorting out this policy.  The current inputsplitter is capable of
+splitting the input for blocks that can all be run as 'single', but in the long
+run it may prove cleaner to only use 'single' mode for truly single-line
+inputs, and run all multiline input in 'exec' mode.  This would preserve the
+natural behavior of single-line inputs while allowing long cells to behave more
+likea a script.  This design will be refined as we complete the implementation.
+
+Message type: ``execute_request``::
 
     content = {
-	name : 'stdout',
-	data : 'blob',
+        # Source code to be executed by the kernel, one or more lines.
+	'code' : str,
+
+	# A boolean flag which, if True, signals the kernel to execute this
+	# code as quietly as possible.  This means that the kernel will compile
+	# the code with 'exec' instead of 'single' (so sys.displayhook will not
+	# fire), and will *not*:
+	#   - broadcast exceptions on the PUB socket
+	#   - do any logging
+	#   - populate any history
+	# The default is False.
+	'silent' : bool,
     }
 
-# msg_type = 'pyin'::
+Upon execution, the kernel *always* sends a reply, with a status code
+indicating what happened and additional data depending on the outcome.
+
+Message type: ``execute_reply``::
 
     content = {
-	code = 'x=1',
+      # One of: 'ok' OR 'error' OR 'abort'
+      'status' : str,
+
+      # Any additional data depends on status value
     }
 
-# msg_type = 'pyout'::
+When status is 'ok', the following extra fields are present::
+
+    {
+      # This has the same structure as the output of a prompt request, but is
+      # for the client to set up the *next* prompt (with identical limitations
+      # to a prompt request)
+      'next_prompt' : {
+            'prompt_string' : str,
+	    'prompt_number' : int,
+	    },
+	    
+      # The prompt number of the actual execution for this code, which may be
+      # different from the one used when the code was typed, which was the
+      # 'next_prompt' field of the *previous* request.  They will differ in the
+      # case where there is more than one client talking simultaneously to a
+      # kernel, since the numbers can go out of sync.  GUI clients can use this
+      # to correct the previously written number in-place, terminal ones may
+      # re-print a corrected one if desired.
+      'prompt_number' : int,
+
+      # The kernel will often transform the input provided to it.  This
+      # contains the transformed code, which is what was actually executed.
+      'transformed_code' : str,
+
+      # The execution payload is a dict with string keys that may have been
+      # produced by the code being executed.  It is retrieved by the kernel at
+      # the end of the execution and sent back to the front end, which can take
+      # action on it as needed.  See main text for further details.
+      'payload' : dict,
+    }
+
+.. admonition:: Execution payloads
+    
+   The notion of an 'execution payload' is different from a return value of a
+   given set of code, which normally is just displayed on the pyout stream
+   through the PUB socket.  The idea of a payload is to allow special types of
+   code, typically magics, to populate a data container in the IPython kernel
+   that will be shipped back to the caller via this channel.  The kernel will
+   have an API for this, probably something along the lines of::
+
+       ip.exec_payload_add(key, value)
+
+   though this API is still in the design stages.  The data returned in this
+   payload will allow frontends to present special views of what just happened.
+
+   
+When status is 'error', the following extra fields are present::
+
+    {
+      'exc_name' : str,   # Exception name, as a string
+      'exc_value' : str,  # Exception value, as a string
+
+      # The traceback will contain a list of frames, represented each as a
+      # string.  For now we'll stick to the existing design of ultraTB, which
+      # controls exception level of detail statefully.  But eventually we'll
+      # want to grow into a model where more information is collected and
+      # packed into the traceback object, with clients deciding how little or
+      # how much of it to unpack.  But for now, let's start with a simple list
+      # of strings, since that requires only minimal changes to ultratb as
+      # written.
+      'traceback' : list,
+    }
+
+
+When status is 'abort', there are for now no additional data fields.  This
+happens when the kernel was interrupted by a signal.
+
+
+Prompt
+------
+
+A simple request for a current prompt string.
+
+Message type: ``prompt_request``::
+
+    content = {}
+
+In the reply, the prompt string comes back with the prompt number placeholder
+*unevaluated*.  The message format is:
+    
+Message type: ``prompt_reply``::
+
+    content = {
+      'prompt_string' : str,
+      'prompt_number' : int,
+    }
+
+Clients can produce a prompt with ``prompt_string.format(prompt_number)``, but
+they should be aware that the actual prompt number for that input could change
+later, in the case where multiple clients are interacting with a single
+kernel. 
+
+
+Object information
+------------------
+
+One of IPython's most used capabilities is the introspection of Python objects
+in the user's namespace, typically invoked via the ``?`` and ``??`` characters
+(which in reality are shorthands for the ``%pinfo`` magic).  This is used often
+enough that it warrants an explicit message type, especially because frontends
+may want to get object information in response to user keystrokes (like Tab or
+F1) besides from the user explicitly typing code like ``x??``.
+
+Message type: ``object_info_request``::
 
     content = {
-	data = 'repr(obj)',
-	prompt_number = 10
+        # The (possibly dotted) name of the object to be searched in all
+	# relevant namespaces
+	'name' : str,
+
+	# The level of detail desired.  The default (0) is equivalent to typing
+	# 'x?' at the prompt, 1 is equivalent to 'x??'.
+	'detail_level' : int,
     }
 
-# msg_type = 'pyerr'::
+The returned information will be a dictionary with keys very similar to the
+field names that IPython prints at the terminal.
+    
+Message type: ``object_info_reply``::
 
     content = {
-	traceback : 'full traceback',
-	exc_type : 'TypeError',
-	exc_value :  'msg'
+        # Flags for magics and system aliases
+	'ismagic' : bool,
+	'isalias' : bool,
+
+	# The name of the namespace where the object was found ('builtin',
+	# 'magics', 'alias', 'interactive', etc.)
+	'namespace' : str,
+
+	# The type name will be type.__name__ for normal Python objects, but it
+	# can also be a string like 'Magic function' or 'System alias'
+	'type_name' : str,
+
+	'string_form' : str,
+
+	# For objects with a __class__ attribute this will be set
+	'base_class' : str,
+
+	# For objects with a __len__ attribute this will be set
+	'length' : int,
+
+	# If the object is a function, class or method whose file we can find,
+	# we give its full path
+	'file' : str,
+
+	# For pure Python callable objects, we can reconstruct the object
+	# definition line which provides its call signature
+	'definition' : str,
+
+	# For instances, provide the constructor signature (the definition of
+	# the __init__ method):
+	'init_definition' : str,
+	
+	# Docstrings: for any object (function, method, module, package) with a
+	# docstring, we show it.  But in addition, we may provide additional
+	# docstrings.  For example, for instances we will show the constructor
+	# and class docstrings as well, if available.
+	'docstring' : str,
+
+	# For instances, provide the constructor and class docstrings
+	'init_docstring' : str,
+	'class_docstring' : str,
+
+	# If detail_level was 1, we also try to find the source code that
+	# defines the object, if possible.  The string 'None' will indicate
+	# that no source was found.
+	'source' : str,
     }
 
-# msg_type = 'file':
+    
+Complete
+--------
+
+Message type: ``complete_request``::
+
     content = {
-	path = 'cool.jpg',
-	data : 'blob'
+        # The text to be completed, such as 'a.is'
+	'text' : str,
+
+	# The full line, such as 'print a.is'.  This allows completers to
+	# make decisions that may require information about more than just the
+	# current word.
+	'line' : str,
     }
 
-Request/Reply
-=============
+Message type: ``complete_reply``::
 
-Execute
+    content = {
+        # The list of all matches to the completion request, such as
+	# ['a.isalnum', 'a.isalpha'] for the above example.
+	'matches' : list
+    }
+
+    
+History
 -------
 
-Request:
+For clients to explicitly request history from a kernel.  The kernel has all
+the actual execution history stored in a single location, so clients can
+request it from the kernel when needed.
 
-# msg_type = 'execute_request'::
+Message type: ``history_request``::
 
     content = {
-	code : 'a = 10',
+    
+      # If true, also return output history in the resulting dict.
+      'output' : bool,
+
+      # This parameter can be one of: A number,  a pair of numbers, 'all'
+      # If not given, last 40 are returned.
+      #  - number n: return the last n entries.
+      #  - pair n1, n2: return entries in the range(n1, n2).
+      #  - 'all': return all history
+      'range' : n or (n1, n2) or 'all',
+
+      # If a filter is given, it is  treated as a regular expression and only
+      #  matching entries are returned.  re.search() is used to find matches.
+      'filter' : str,
     }
 
-Reply:
+Message type: ``history_reply``::
+
+    content = {
+      # A list of (number, input) pairs
+      'input' : list,
+      
+      # A list of (number, output) pairs
+      'output' : list,
+      }
 
-# msg_type = 'execute_reply'::
+    
+Messages on the PUB/SUB socket
+==============================
+
+Streams (stdout,  stderr, etc)
+------------------------------
+
+Message type: ``stream``::
 
     content = {
-      'status' : 'ok' OR 'error' OR 'abort'
-      # data depends on status value
+        # The name of the stream is one of 'stdin', 'stdout', 'stderr'
+	'name' : str,
+	
+	# The data is an arbitrary string to be written to that stream
+	'data' : str,
     }
 
-Complete
---------
+When a kernel receives a raw_input call, it should also broadcast it on the pub
+socket with the names 'stdin' and 'stdin_reply'.  This will allow other clients
+to monitor/display kernel interactions and possibly replay them to their user
+or otherwise expose them.
 
-# msg_type = 'complete_request'::
+Python inputs
+-------------
+
+These messages are the re-broadcast of the ``execute_request``.
+
+Message type: ``pyin``::
 
     content = {
-	text : 'a.f',    # complete on this
-	line : 'print a.f'    # full line
+        # Source code to be executed, one or more lines
+	'code' : str
     }
 
-# msg_type = 'complete_reply'::
+Python outputs
+--------------
+
+When Python produces output from code that has been compiled in with the
+'single' flag to :func:`compile`, any expression that produces a value (such as
+``1+1``) is passed to ``sys.displayhook``, which is a callable that can do with
+this value whatever it wants.  The default behavior of ``sys.displayhook`` in
+the Python interactive prompt is to print to ``sys.stdout`` the :func:`repr` of
+the value as long as it is not ``None`` (which isn't printed at all).  In our
+case, the kernel instantiates as ``sys.displayhook`` an object which has
+similar behavior, but which instead of printing to stdout, broadcasts these
+values as ``pyout`` messages for clients to display appropriately.
+
+Message type: ``pyout``::
 
     content = {
-	matches : ['a.foo', 'a.bar']
+        # The data is typically the repr() of the object.
+	'data' : str,
+	
+	# The prompt number for this execution is also provided so that clients
+	# can display it, since IPython automatically creates variables called
+	# _N (for prompt N).
+	'prompt_number' : int,
     }
+    
+Python errors
+-------------
 
-Control
--------
+When an error occurs during code execution
 
-# msg_type = 'heartbeat'::
+Message type: ``pyerr``::
 
     content = {
-    # XXX - unfinished
+       # Similar content to the execute_reply messages for the 'error' case,
+       # except the 'status' field is omitted.
     }
+
+Kernel crashes
+--------------
+
+When the kernel has an unexpected exception, caught by the last-resort
+sys.excepthook, we should broadcast the crash handler's output before exiting.
+This will allow clients to notice that a kernel died, inform the user and
+propose further actions.
+
+Message type: ``crash``::
+
+    content = {
+       # Similarly to the 'error' case for execute_reply messages, this will
+       # contain exc_name, exc_type and traceback fields.
+
+       # An additional field with supplementary information such as where to
+       # send the crash message
+       'info' : str,
+    }
+
+
+Future ideas
+------------
+    
+Other potential message types, currently unimplemented, listed below as ideas.
+    
+Message type: ``file``::
+
+    content = {
+	'path' : 'cool.jpg',
+	'mimetype' : str,
+	'data' : str,
+    }
+
+    
+Messages on the REQ/REP socket
+==============================
+
+This is a socket that goes in the opposite direction: from the kernel to a
+*single* frontend, and its purpose is to allow ``raw_input`` and similar
+operations that read from ``sys.stdin`` on the kernel to be fulfilled by the
+client.  For now we will keep these messages as simple as possible, since they
+basically only mean to convey the ``raw_input(prompt)`` call.
+
+Message type: ``input_request``::
+
+    content = { 'prompt' : str }
+
+Message type: ``input_reply``::
+
+    content = { 'value' : str }
+    
+.. Note::
+
+   We do not explicitly try to forward the raw ``sys.stdin`` object, because in
+   practice the kernel should behave like an interactive program.  When a
+   program is opened on the console, the keyboard effectively takes over the
+   ``stdin`` file descriptor, and it can't be used for raw reading anymore.
+   Since the IPython kernel effectively behaves like a console program (albeit
+   one whose "keyboard" is actually living in a separate process and
+   transported over the zmq connection), raw ``stdin`` isn't expected to be
+   available.
+
+   
+Heartbeat for kernels
+=====================
+
+Initially we had considered using messages like those above over ZMQ for a
+kernel 'heartbeat' (a way to detect quickly and reliably whether a kernel is
+alive at all, even if it may be busy executing user code).  But this has the
+problem that if the kernel is locked inside extension code, it wouldn't execute
+the python heartbeat code.  But it turns out that we can implement a basic
+heartbeat with pure ZMQ, without using any Python messaging at all.
+
+The monitor sends out a single zmq message (right now, it is a str of the
+monitor's lifetime in seconds), and gets the same message right back, prefixed
+with the zmq identity of the XREQ socket in the heartbeat process. This can be
+a uuid, or even a full message, but there doesn't seem to be a need for packing
+up a message when the sender and receiver are the exact same Python object.
+
+The model is this::
+
+    monitor.send(str(self.lifetime)) # '1.2345678910'
+
+and the monitor receives some number of messages of the form::
+
+    ['uuid-abcd-dead-beef', '1.2345678910']
+
+where the first part is the zmq.IDENTITY of the heart's XREQ on the engine, and
+the rest is the message sent by the monitor.  No Python code ever has any
+access to the message between the monitor's send, and the monitor's recv.
+
+
+ToDo
+====
+
+Missing things include:
+
+* Important: finish thinking through the payload concept and API.
+
+* Important: ensure that we have a good solution for magics like %edit.  It's
+  likely that with the payload concept we can build a full solution, but not
+  100% clear yet.
+
+* Finishing the details of the heartbeat protocol.
+
+* Signal handling: specify what kind of information kernel should broadcast (or
+  not) when it receives signals.
+
+.. include:: ../links.rst

docs/sphinxext/ipython_directive.py

@@ -220,7 +220,7 b' class EmbeddedSphinxShell(object):'
         config.InteractiveShell.colors = 'NoColor'
 
         # Create and initialize ipython, but don't start its mainloop
-        IP = InteractiveShell(parent=None, config=config)
+        IP = InteractiveShell.instance(config=config)
 
         # Store a few parts of IPython we'll need.
         self.IP = IP