Merge branch 'configurable' into trunk

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.

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

@@ -373,14 +373,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
@@ -399,9 +399,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):
 
@@ -1023,3 +1026,25 b' class List(Instance):'
 
         super(List,self).__init__(klass=list, args=args, 
                                   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)

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/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