Documentation for the project added

docs/source/development/core_design.txt

@@ -0,0 +1,286 b''
+========================================
+ Design proposal for mod:`IPython.core`
+========================================
+
+Currently mod:`IPython.core` is not well suited for use in GUI applications.
+The purpose of this document is to describe a design that will resolve this
+limitation.
+
+Process and thread model
+========================
+
+The design described here is based on a two process model. These two processes
+are:
+
+1. The IPython engine/kernel. This process contains the user's namespace and 
+   is responsible for executing user code. If user code uses
+   :mod:`enthought.traits` or uses a GUI toolkit to perform plotting, the GUI
+   event loop will run in this process.
+
+2. The GUI application. The user facing GUI application will run in a second
+   process that communicates directly with the IPython engine using
+   asynchronous messaging. The GUI application will not execute any user code.
+   The canonical example of a GUI application that talks to the IPython 
+   engine, would be a GUI based IPython terminal. However, the GUI application 
+   could provide a more sophisticated interface such as a notebook.
+
+We now describe the threading model of the IPython engine. Two threads will be
+used to implement the IPython engine: a main thread that executes user code
+and a networking thread that communicates with the outside world. This
+specific design is required by a number of different factors.
+
+First, The IPython engine must run the GUI event loop if the user wants to
+perform interactive plotting. Because of the design of most GUIs, this means
+that the user code (which will make GUI calls) must live in the main thread.
+
+Second, networking code in the engine (Twisted or otherwise) must be able to
+communicate with the outside world while user code runs. An example would be
+if user code does the following::
+
+    import time
+    for i in range(10):
+        print i
+        time.sleep(2)
+
+We would like to result of each ``print i`` to be seen by the GUI application
+before the entire code block completes. We call this asynchronous printing.
+For this to be possible, the networking code has to be able to be able to
+communicate the current value of ``sys.stdout`` to the GUI application while
+user code is run. Another example is using :mod:`IPython.kernel.client` in
+user code to perform a parallel computation by talking to an IPython
+controller and a set of engines (these engines are separate from the one we
+are discussing here). This module requires the Twisted event loop to be run in
+a different thread than user code.
+
+For the GUI application, threads are optional. However, the GUI application
+does need to be able to perform network communications asynchronously (without
+blocking the GUI itself). With this in mind, there are two options:
+
+* Use Twisted (or another non-blocking socket library) in the same thread as
+  the GUI event loop.
+
+* Don't use Twisted, but instead run networking code in the GUI application
+  using blocking sockets in threads. This would require the usage of polling
+  and queues to manage the networking in the GUI application.
+
+Thus, for the GUI application, there is a choice between non-blocking sockets
+(Twisted) or threads.
+
+Asynchronous messaging
+======================
+
+The GUI application will use asynchronous message queues to communicate with
+the networking thread of the engine. Because this communication will typically
+happen over localhost, a simple, one way, network protocol like XML-RPC or
+JSON-RPC can be used to implement this messaging. These options will also make
+it easy to implement the required networking in the GUI application using the
+standard library. In applications where secure communications are required,
+Twisted and Foolscap will probably be the best way to go for now, but HTTP is
+also an option.
+
+There is some flexibility as to where the message queues are located. One
+option is that we could create a third process (like the IPython controller)
+that only manages the message queues. This is attractive, but does require
+an additional process.
+
+Using this communication channel, the GUI application and kernel/engine will
+be able to send messages back and forth. For the most part, these messages
+will have a request/reply form, but it will be possible for the kernel/engine
+to send multiple replies for a single request.
+
+The GUI application will use these messages to control the engine/kernel.
+Examples of the types of things that will be possible are:
+
+* Pass code (as a string) to be executed by the engine in the user's namespace
+  as a string.
+
+* Get the current value of stdout and stderr.
+
+* Get the ``repr`` of an object returned (Out []:).
+
+* Pass a string to the engine to be completed when the GUI application
+  receives a tab completion event.
+
+* Get a list of all variable names in the user's namespace.
+
+The in memory format of a message should be a Python dictionary, as this
+will be easy to serialize using virtually any network protocol. The 
+message dict should only contain basic types, such as strings, floats,
+ints, lists, tuples and other dicts.
+
+Each message will have a unique id and will probably be determined by the
+messaging system and returned when something is queued in the message
+system. This unique id will be used to pair replies with requests.
+
+Each message should have a header of key value pairs that can be introspected
+by the message system and a body, or payload, that is opaque. The queues
+themselves will be purpose agnostic, so the purpose of the message will have
+to be encoded in the message itself. While we are getting started, we
+probably don't need to distinguish between the header and body.
+
+Here are some examples::
+
+    m1 = dict(
+        method='execute',
+        id=24,  # added by the message system
+        parent=None # not a reply,
+        source_code='a=my_func()'
+    )
+
+This single message could generate a number of reply messages::
+    
+    m2 = dict(
+        method='stdout'
+        id=25,  # my id, added by the message system
+        parent_id=24,  # The message id of the request
+        value='This was printed by my_func()'
+    )
+
+    m3 = dict(
+        method='stdout'
+        id=26,  # my id, added by the message system
+        parent_id=24,  # The message id of the request
+        value='This too was printed by my_func() at a later time.'
+    )
+
+    m4 = dict(
+        method='execute_finished',
+        id=27,
+        parent_id=24
+        # not sure what else should come back with this message,
+        # but we will need a way for the GUI app to tell that an execute
+        # is done.
+    )
+
+We should probably use flags for the method and other purposes:
+
+EXECUTE='0'
+EXECUTE_REPLY='1'
+
+This will keep out network traffic down and enable us to easily change the
+actual value that is sent.
+
+Engine details
+==============
+
+As discussed above, the engine will consist of two threads: a main thread and
+a networking thread. These two threads will communicate using a pair of
+queues: one for data and requests passing to the main thread (the main
+thread's "input queue") and another for data and requests passing out of the
+main thread (the main thread's "output queue"). Both threads will have an
+event loop that will enqueue elements on one queue and dequeue elements on the
+other queue.
+
+The event loop of the main thread will be of a different nature depending on
+if the user wants to perform interactive plotting. If they do want to perform
+interactive plotting, the main threads event loop will simply be the GUI event
+loop. In that case, GUI timers will be used to monitor the main threads input
+queue. When elements appear on that queue, the main thread will respond
+appropriately. For example, if the queue contains an element that consists of
+user code to execute, the main thread will call the appropriate method of its
+IPython instance. If the user does not want to perform interactive plotting,
+the main thread will have a simpler event loop that will simply block on the
+input queue. When something appears on that queue, the main thread will awake
+and handle the request.
+
+The event loop of the networking thread will typically be the Twisted event
+loop. While it is possible to implement the engine's networking without using
+Twisted, at this point, Twisted provides the best solution. Note that the GUI
+application does not need to use Twisted in this case. The Twisted event loop
+will contain an XML-RPC or JSON-RPC server that takes requests over the
+network and handles those requests by enqueing elements on the main thread's
+input queue or dequeing elements on the main thread's output queue.
+
+Because of the asynchronous nature of the network communication, a single
+input and output queue will be used to handle the interaction with the main
+thread. It is also possible to use multiple queues to isolate the different
+types of requests, but our feeling is that this is more complicated than it
+needs to be.
+
+One of the main issues is how stdout/stderr will be handled. Our idea is to
+replace sys.stdout/sys.stderr by custom classes that will immediately write
+data to the main thread's output queue when user code writes to these streams
+(by doing print). Once on the main thread's output queue, the networking
+thread will make the data available to the GUI application over the network.
+
+One unavoidable limitation in this design is that if user code does a print
+and then enters non-GIL-releasing extension code, the networking thread will
+go silent until the GIL is again released. During this time, the networking
+thread will not be able to process the GUI application's requests of the
+engine. Thus, the values of stdout/stderr will be unavailable during this
+time. This goes beyond stdout/stderr, however. Anytime the main thread is
+holding the GIL, the networking thread will go silent and be unable to handle
+requests.
+
+GUI Application details
+=======================
+
+The GUI application will also have two threads. While this is not a strict
+requirement, it probably makes sense and is a good place to start. The main
+thread will be the GUI tread. The other thread will be a networking thread and
+will handle the messages that are sent to and from the engine process.
+
+Like the engine, we will use two queues to control the flow of messages
+between the main thread and networking thread. One of these queues will be
+used for messages sent from the GUI application to the engine. When the GUI
+application needs to send a message to the engine, it will simply enque the
+appropriate message on this queue. The networking thread will watch this queue
+and forward messages to the engine using an appropriate network protocol.
+
+The other queue will be used for incoming messages from the engine. The
+networking thread will poll for incoming messages from the engine. When it
+receives any message, it will simply put that message on this other queue. The
+GUI application will periodically see if there are any messages on this queue
+and if there are it will handle them.
+
+The GUI application must be prepared to handle any incoming message at any
+time. Due to a variety of reasons, the one or more reply messages associated
+with a request, may appear at any time in the future and possible in different
+orders. It is also possible that a reply might not appear. An example of this
+would be a request for a tab completion event. If the engine is busy, it won't
+be possible to fulfill the request for a while. While the tab completion
+request will eventually be handled, the GUI application has to be prepared to
+abandon waiting for the reply if the user moves on or a certain timeout
+expires.
+
+Prototype details
+=================
+
+With this design, it should be possible to develop a relatively complete GUI
+application, while using a mock engine. This prototype should use the two
+process design described above, but instead of making actual network calls,
+the network thread of the GUI application should have an object that fakes the
+network traffic. This mock object will consume messages off of one queue,
+pause for a short while (to model network and other latencies) and then place
+reply messages on the other queue.
+
+This simple design will allow us to determine exactly what the message types
+and formats should be as well as how the GUI application should interact with
+the two message queues. Note, it is not required that the mock object actually
+be able to execute Python code or actually complete strings in the users
+namespace. All of these things can simply be faked. This will also help us to
+understand what the interface needs to look like that handles the network
+traffic. This will also help us to understand the design of the engine better.
+
+The GUI application should be developed using IPython's component, application
+and configuration system. It may take some work to see what the best way of
+integrating these things with PyQt are.
+
+After this stage is done, we can move onto creating a real IPython engine for
+the GUI application to communicate with. This will likely be more work that
+the GUI application itself, but having a working GUI application will make it
+*much* easier to design and implement the engine.
+
+We also might want to introduce a third process into the mix. Basically, this
+would be a central messaging hub that both the engine and GUI application
+would use to send and retrieve messages. This is not required, but it might be
+a really good idea.
+
+Also, I have some ideas on the best way to handle notebook saving and
+persistence.
+
+Refactoring of IPython.core
+===========================
+
+We need to go through IPython.core and describe what specifically needs to be
+done.

docs/source/development/inputhook_app.txt

@@ -0,0 +1,55 b''
+=========================
+IPython GUI Support Notes
+=========================
+
+IPython allows GUI event loops to be run in an interactive IPython session.
+This is done using Python's PyOS_InputHook hook which Python calls
+when the :func:`raw_input` function is called and waiting for user input.
+IPython has versions of this hook for wx, pyqt4 and pygtk.
+
+When a GUI program is used interactively within IPython, the event loop of
+the GUI should *not* be started. This is because, the PyOS_Inputhook itself
+is responsible for iterating the GUI event loop.
+
+IPython has facilities for installing the needed input hook for each GUI 
+toolkit and for creating the needed main GUI application object. Usually,
+these main application objects should be created only once and for some
+GUI toolkits, special options have to be passed to the application object
+to enable it to function properly in IPython.
+
+We need to answer the following questions:
+
+* Who is responsible for creating the main GUI application object, IPython
+  or third parties (matplotlib, enthought.traits, etc.)?
+
+* What is the proper way for third party code to detect if a GUI application
+  object has already been created?  If one has been created, how should
+  the existing instance be retrieved?
+
+* In a GUI application object has been created, how should third party code
+  detect if the GUI event loop is running. It is not sufficient to call the
+  relevant function methods in the GUI toolkits (like ``IsMainLoopRunning``)
+  because those don't know if the GUI event loop is running through the
+  input hook.
+
+* We might need a way for third party code to determine if it is running
+  in IPython or not.  Currently, the only way of running GUI code in IPython
+  is by using the input hook, but eventually, GUI based versions of IPython
+  will allow the GUI event loop in the more traditional manner. We will need
+  a way for third party code to distinguish between these two cases.
+
+Here is some sample code I have been using to debug this issue::
+
+    from matplotlib import pyplot as plt
+
+    from enthought.traits import api as traits
+
+    class Foo(traits.HasTraits):
+        a = traits.Float()
+
+    f = Foo()
+    f.configure_traits()
+
+    plt.plot(range(10))
+
+

docs/source/development/session_format.txt

@@ -0,0 +1,111 b''
+===============================
+ IPython session storage notes
+===============================
+
+This document serves as a sample/template for ideas on how to store session
+data on disk.  This stems from discussions we had on various mailing lists, and
+should be considered a pure work in progress.  We haven't settled these ideas
+completely yet, and there's a lot to discuss; this document should just serve
+as a reference of the distilled points from various conversations on multiple
+mailing lists, and will congeal over time on a specific design we implement.
+
+The frontend would store, for now, 5 types of data:
+
+#. Input: this is python/ipython code to be executed.
+
+#. Output (python): result of executing Inputs.
+
+#. Standard output: from subprocesses.
+
+#. Standard error: from subprocesses.
+
+#. Text: arbitrary text.  For now, we'll just store plain text and will defer
+   to the user on how to format it, though it should be valid reST if it is
+   later to be converted into html/pdf.
+
+The non-text cells would be stored on-disk as follows::
+
+    .. input-cell::
+      :id: 1
+
+      3+3
+
+    .. output-cell::
+       :id: 1
+
+       6
+
+    .. input-cell::
+       :id: 2
+
+       ls
+
+    .. stdout-cell::
+       :id: 2
+
+       a.py b.py
+
+    .. input-cell::
+       :id: 3
+
+      !askdfj
+
+    .. stderr-cell::
+       :id: 3
+
+       sh: askdfj: command not found
+
+Brian made some interesting points on the mailing list inspired by the
+Mathematica format, reproduced here for reference:
+
+The Mathematica notebook format is a plain text file that itself is *valid
+Mathematica code*.  This id documented here: 
+
+http://reference.wolfram.com/mathematica/guide/LowLevelNotebookProgramming.html
+
+For examples a simple notebook with one text cell is just::
+
+  Notebook[{Cell['Here is my text', 'Text']}]
+
+Everything - input cells, output cells, static images and all are represented
+in this way and embedded in the plain text notebook file.  The Python
+generalization of this would be the following: 
+
+* A Python notebook is plain text, importable Python code.
+
+* That code is simply a tree of objects that declare the relevant parts of the
+  notebook. 
+
+This has a number of advantages:
+
+* A notebook can be imported, manipulated and run by anyone who has the support
+  code (the notebook module that defines the relevant classes).
+  
+* A notebook doesn't need to be parsed.  It is valid Python and can be imported
+  or exec'd.  Once that is done, you have the full notebook in memory.  You can
+  immediately do anything you want with it.
+  
+* The various Notebook, Cell, Image, etc. classes can know about how to output
+  to various formats, latex, html, reST, XML, etc::
+
+  import mynotebook
+  mynotebook.notebook.export('rest')
+
+* Each individual format (HTML, reST, latex) has weaknesses.  If you pick any
+  one to be *the* notebook format, you are building those weaknesses into your
+  design.  A pure python based notebook format won't suffer from that syndrome.
+  
+* It is a clean separation of the model (Notebook, Cell, Image, etc.) and the
+  view (HTML, reST, etc.).  Picking HTML or reST for the notebook format
+  confuses (at some level) the model and view...
+  
+* Third party code can define new Notebook elements that specify how they can
+  be rendered in different contexts.  For example, matplotlib could ship a
+  Figure element that knows how to render itself as a native PyQt GUI, a static
+  image, a web page, etc.
+  
+* A notebook remains a single plain text file that anyone can edit - even if it
+  has embedded images.  Neither HTML nor reST have the ability to inline
+  graphics in plain text files.  While I love reST, it is a pain that I need an
+  entire directory of files to render a single Sphinx doc.
+  
  No newline at end of file

IPython/__init__.py

@@ -5,7 +5,6 b' IPython.'
 
 IPython is a set of tools for interactive and exploratory computing in Python.
 """
-
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2009  The IPython Development Team
 #

IPython/config/default/ipython_config.py

@@ -112,7 +112,7 b' c = get_config()'
 # ]
 # c.InteractiveShell.readline_remove_delims = '-/~'
 # c.InteractiveShell.readline_merge_completions = True
-# c.InteractiveShell.readline_omit_names = 0
+# c.InteractiveShell.readline_omit__names = 0
 
 # c.InteractiveShell.screen_length = 0
 
@@ -145,4 +145,4 b' c = get_config()'
 
 # c.AliasManager.user_aliases = [
 #     ('foo', 'echo Hi')
-# ]
  No newline at end of file
+# ]

IPython/core/application.py

@@ -224,7 +224,7 b' class Application(object):'
 
         For the most part, we try to set default in the class attributes
         of Components.  But, defaults the top-level Application (which is
-        not a HasTraitlets or Component) are not set in this way.  Instead
+        not a HasTraits or Component) are not set in this way.  Instead
         we set them here.  The Global section is for variables like this that
         don't belong to a particular component.
         """

IPython/core/component.py

@@ -27,7 +27,7 b' from weakref import WeakValueDictionary'
 from IPython.utils.importstring import import_item
 from IPython.config.loader import Config
 from IPython.utils.traitlets import (
-    HasTraitlets, MetaHasTraitlets, Instance, This
+    HasTraits, MetaHasTraits, Instance, This
 )
 
 
@@ -173,7 +173,7 b' class __ComponentNameGenerator(object):'
 ComponentNameGenerator = __ComponentNameGenerator('ipython.component')
 
 
-class MetaComponent(MetaHasTraitlets, MetaComponentTracker):
+class MetaComponent(MetaHasTraits, MetaComponentTracker):
     pass
 
 
@@ -182,11 +182,11 b' class MetaComponent(MetaHasTraitlets, MetaComponentTracker):'
 #-----------------------------------------------------------------------------
 
 
-class Component(HasTraitlets):
+class Component(HasTraits):
 
     __metaclass__ = MetaComponent
 
-    # Traitlets are fun!
+    # Traits are fun!
     config = Instance(Config,(),{})
     parent = This()
     root = This()
@@ -256,7 +256,7 b' class Component(HasTraitlets):'
         self.created = datetime.datetime.now()
 
     #-------------------------------------------------------------------------
-    # Static traitlet notifiations
+    # Static trait notifiations
     #-------------------------------------------------------------------------
 
     def _parent_changed(self, name, old, new):
@@ -282,12 +282,12 b' class Component(HasTraitlets):'
     def _config_changed(self, name, old, new):
         """Update all the class traits having ``config=True`` as metadata.
 
-        For any class traitlet with a ``config`` metadata attribute that is
-        ``True``, we update the traitlet with the value of the corresponding
+        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 traitlets with a config metadata entry that is True
-        traitlets = self.traitlets(config=True)
+        # 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 Component subclasses.  This starts with Component
@@ -301,7 +301,7 b' class Component(HasTraitlets):'
             # dynamically create the section with name self.__class__.__name__.
             if new._has_section(sname):
                 my_config = new[sname]
-                for k, v in traitlets.items():
+                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

IPython/core/iplib.py

@@ -182,7 +182,7 b' def get_default_colors():'
 class SeparateStr(Str):
     """A Str subclass to validate separate_in, separate_out, etc.
 
-    This is a Str based traitlet that converts '0'->'' and '\\n'->'\n'.
+    This is a Str based trait that converts '0'->'' and '\\n'->'\n'.
     """
 
     def validate(self, obj, value):
@@ -263,7 +263,7 b' class InteractiveShell(Component, Magic):'
 
     screen_length = Int(0, config=True)
     
-    # Use custom TraitletTypes that convert '0'->'' and '\\n'->'\n'
+    # Use custom TraitTypes that convert '0'->'' and '\\n'->'\n'
     separate_in = SeparateStr('\n', config=True)
     separate_out = SeparateStr('', config=True)
     separate_out2 = SeparateStr('', config=True)
@@ -286,7 +286,7 b' class InteractiveShell(Component, Magic):'
                  banner1=None, banner2=None, display_banner=None,
                  custom_exceptions=((),None)):
 
-        # This is where traitlets with a config_key argument are updated
+        # This is where traits with a config_key argument are updated
         # from the values on config.
         super(InteractiveShell, self).__init__(parent, config=config)
 
@@ -341,7 +341,7 b' class InteractiveShell(Component, Magic):'
         return self
 
     #-------------------------------------------------------------------------
-    # Traitlet changed handlers
+    # Trait changed handlers
     #-------------------------------------------------------------------------
 
     def _banner1_changed(self):

IPython/core/tests/test_component.py

@@ -24,7 +24,7 b' from unittest import TestCase'
 
 from IPython.core.component import Component, ComponentError
 from IPython.utils.traitlets import (
-    TraitletError, Int, Float, Str
+    TraitError, Int, Float, Str
 )
 from IPython.config.loader import Config
 
@@ -109,7 +109,7 b' class TestComponent(TestCase):'
 
     def test_subclass_parent(self):
         c1 = Component(None)
-        self.assertRaises(TraitletError, setattr, c1, 'parent', 10)
+        self.assertRaises(TraitError, setattr, c1, 'parent', 10)
 
         class MyComponent(Component):
             pass

IPython/kernel/enginefc.py

@@ -28,7 +28,10 b' from zope.interface import Interface, implements'
 from twisted.internet.base import DelayedCall
 DelayedCall.debug = True
 
-from foolscap import Referenceable, DeadReferenceError
+try:
+    from foolscap.api import Referenceable, DeadReferenceError
+except ImportError:
+    from foolscap import Referenceable, DeadReferenceError
 from foolscap.referenceable import RemoteReference
 
 from IPython.kernel.pbutil import packageFailure, unpackageFailure

IPython/kernel/fcutil.py

@@ -24,7 +24,10 b' from twisted.internet import reactor, defer'
 from twisted.python import log
 
 import foolscap
-from foolscap import Tub, UnauthenticatedTub
+try:
+    from foolscap.api import Tub, UnauthenticatedTub
+except ImportError:
+    from foolscap import Tub, UnauthenticatedTub
 
 from IPython.config.loader import Config
 from IPython.kernel.configobjfactory import AdaptedConfiguredObjectFactory

IPython/kernel/multiengineclient.py

@@ -22,7 +22,11 b' import warnings'
 from twisted.python import components
 from twisted.python.failure import Failure
 from zope.interface import Interface, implements, Attribute
-from foolscap import DeadReferenceError
+
+try:
+    from foolscap.api import DeadReferenceError
+except ImportError:
+    from foolscap import DeadReferenceError
 
 from IPython.utils.coloransi import TermColors
 

IPython/kernel/multienginefc.py

@@ -24,7 +24,10 b' from zope.interface import Interface, implements'
 from twisted.internet import defer
 from twisted.python import components, failure
 
-from foolscap import Referenceable
+try:
+    from foolscap.api import Referenceable
+except ImportError:
+    from foolscap import Referenceable
 
 from IPython.kernel import error 
 from IPython.kernel import map as Map

IPython/kernel/taskclient.py

@@ -20,7 +20,11 b' __docformat__ = "restructuredtext en"'
 
 from zope.interface import Interface, implements
 from twisted.python import components
-from foolscap import DeadReferenceError
+
+try:
+    from foolscap.api import DeadReferenceError
+except ImportError:
+    from foolscap import DeadReferenceError
 
 from IPython.kernel.twistedutil import blockingCallFromThread
 from IPython.kernel import task, error

IPython/kernel/taskfc.py

@@ -24,7 +24,10 b' from zope.interface import Interface, implements'
 from twisted.internet import defer
 from twisted.python import components
 
-from foolscap import Referenceable
+try:
+    from foolscap.api import Referenceable
+except ImportError:
+    from foolscap import Referenceable
 
 from IPython.kernel import task as taskmodule
 from IPython.kernel.clientinterfaces import (

IPython/utils/tests/test_traitlets.py

@@ -25,8 +25,8 b' Authors:'
 from unittest import TestCase
 
 from IPython.utils.traitlets import (
-    HasTraitlets, MetaHasTraitlets, TraitletType, Any,
-    Int, Long, Float, Complex, Str, Unicode, TraitletError,
+    HasTraits, MetaHasTraits, TraitType, Any,
+    Int, Long, Float, Complex, Str, Unicode, TraitError,
     Undefined, Type, This, Instance
 )
 
@@ -36,9 +36,9 b' from IPython.utils.traitlets import ('
 #-----------------------------------------------------------------------------
 
 
-class HasTraitletsStub(HasTraitlets):
+class HasTraitsStub(HasTraits):
 
-    def _notify_traitlet(self, name, old, new):
+    def _notify_trait(self, name, old, new):
         self._notify_name = name
         self._notify_old = old
         self._notify_new = new
@@ -49,17 +49,17 b' class HasTraitletsStub(HasTraitlets):'
 #-----------------------------------------------------------------------------
 
 
-class TestTraitletType(TestCase):
+class TestTraitType(TestCase):
 
     def test_get_undefined(self):
-        class A(HasTraitlets):
-            a = TraitletType
+        class A(HasTraits):
+            a = TraitType
         a = A()
         self.assertEquals(a.a, Undefined)
 
     def test_set(self):
-        class A(HasTraitletsStub):
-            a = TraitletType
+        class A(HasTraitsStub):
+            a = TraitType
 
         a = A()
         a.a = 10
@@ -69,10 +69,10 b' class TestTraitletType(TestCase):'
         self.assertEquals(a._notify_new, 10)
 
     def test_validate(self):
-        class MyTT(TraitletType):
+        class MyTT(TraitType):
             def validate(self, inst, value):
                 return -1
-        class A(HasTraitletsStub):
+        class A(HasTraitsStub):
             tt = MyTT
         
         a = A()
@@ -80,26 +80,26 b' class TestTraitletType(TestCase):'
         self.assertEquals(a.tt, -1)
 
     def test_default_validate(self):
-        class MyIntTT(TraitletType):
+        class MyIntTT(TraitType):
             def validate(self, obj, value):
                 if isinstance(value, int):
                     return value
                 self.error(obj, value)
-        class A(HasTraitlets):
+        class A(HasTraits):
             tt = MyIntTT(10)
         a = A()
         self.assertEquals(a.tt, 10)
 
-        # Defaults are validated when the HasTraitlets is instantiated
-        class B(HasTraitlets):
+        # Defaults are validated when the HasTraits is instantiated
+        class B(HasTraits):
             tt = MyIntTT('bad default')
-        self.assertRaises(TraitletError, B)
+        self.assertRaises(TraitError, B)
 
     def test_is_valid_for(self):
-        class MyTT(TraitletType):
+        class MyTT(TraitType):
             def is_valid_for(self, value):
                 return True
-        class A(HasTraitlets):
+        class A(HasTraits):
             tt = MyTT
 
         a = A()
@@ -107,10 +107,10 b' class TestTraitletType(TestCase):'
         self.assertEquals(a.tt, 10)
 
     def test_value_for(self):
-        class MyTT(TraitletType):
+        class MyTT(TraitType):
             def value_for(self, value):
                 return 20
-        class A(HasTraitlets):
+        class A(HasTraits):
             tt = MyTT
 
         a = A()
@@ -118,33 +118,33 b' class TestTraitletType(TestCase):'
         self.assertEquals(a.tt, 20)
 
     def test_info(self):
-        class A(HasTraitlets):
-            tt = TraitletType
+        class A(HasTraits):
+            tt = TraitType
         a = A()
         self.assertEquals(A.tt.info(), 'any value')
 
     def test_error(self):
-        class A(HasTraitlets):
-            tt = TraitletType
+        class A(HasTraits):
+            tt = TraitType
         a = A()
-        self.assertRaises(TraitletError, A.tt.error, a, 10)
+        self.assertRaises(TraitError, A.tt.error, a, 10)
 
 
-class TestHasTraitletsMeta(TestCase):
+class TestHasTraitsMeta(TestCase):
 
     def test_metaclass(self):
-        self.assertEquals(type(HasTraitlets), MetaHasTraitlets)
+        self.assertEquals(type(HasTraits), MetaHasTraits)
 
-        class A(HasTraitlets):
+        class A(HasTraits):
             a = Int
 
         a = A()
-        self.assertEquals(type(a.__class__), MetaHasTraitlets)
+        self.assertEquals(type(a.__class__), MetaHasTraits)
         self.assertEquals(a.a,0)
         a.a = 10
         self.assertEquals(a.a,10)
 
-        class B(HasTraitlets):
+        class B(HasTraits):
             b = Int()
 
         b = B()
@@ -152,7 +152,7 b' class TestHasTraitletsMeta(TestCase):'
         b.b = 10
         self.assertEquals(b.b,10)
 
-        class C(HasTraitlets):
+        class C(HasTraits):
             c = Int(30)
 
         c = C()
@@ -161,7 +161,7 b' class TestHasTraitletsMeta(TestCase):'
         self.assertEquals(c.c,10)
 
     def test_this_class(self):
-        class A(HasTraitlets):
+        class A(HasTraits):
             t = This()
             tt = This()
         class B(A):
@@ -172,7 +172,7 b' class TestHasTraitletsMeta(TestCase):'
         self.assertEquals(B.tt.this_class, B)
         self.assertEquals(B.ttt.this_class, B)
 
-class TestHasTraitletsNotify(TestCase):
+class TestHasTraitsNotify(TestCase):
 
     def setUp(self):
         self._notify1 = []
@@ -186,12 +186,12 b' class TestHasTraitletsNotify(TestCase):'
 
     def test_notify_all(self):
 
-        class A(HasTraitlets):
+        class A(HasTraits):
             a = Int
             b = Float
 
         a = A()
-        a.on_traitlet_change(self.notify1)
+        a.on_trait_change(self.notify1)
         a.a = 0
         self.assertEquals(len(self._notify1),0)
         a.b = 0.0
@@ -200,31 +200,31 b' class TestHasTraitletsNotify(TestCase):'
         self.assert_(('a',0,10) in self._notify1)
         a.b = 10.0
         self.assert_(('b',0.0,10.0) in self._notify1)
-        self.assertRaises(TraitletError,setattr,a,'a','bad string')
-        self.assertRaises(TraitletError,setattr,a,'b','bad string')
+        self.assertRaises(TraitError,setattr,a,'a','bad string')
+        self.assertRaises(TraitError,setattr,a,'b','bad string')
         self._notify1 = []
-        a.on_traitlet_change(self.notify1,remove=True)
+        a.on_trait_change(self.notify1,remove=True)
         a.a = 20
         a.b = 20.0
         self.assertEquals(len(self._notify1),0)
 
     def test_notify_one(self):
 
-        class A(HasTraitlets):
+        class A(HasTraits):
             a = Int
             b = Float
 
         a = A()
-        a.on_traitlet_change(self.notify1, 'a')
+        a.on_trait_change(self.notify1, 'a')
         a.a = 0
         self.assertEquals(len(self._notify1),0)
         a.a = 10
         self.assert_(('a',0,10) in self._notify1)
-        self.assertRaises(TraitletError,setattr,a,'a','bad string')
+        self.assertRaises(TraitError,setattr,a,'a','bad string')
 
     def test_subclass(self):
 
-        class A(HasTraitlets):
+        class A(HasTraits):
             a = Int
 
         class B(A):
@@ -240,15 +240,15 b' class TestHasTraitletsNotify(TestCase):'
 
     def test_notify_subclass(self):
 
-        class A(HasTraitlets):
+        class A(HasTraits):
             a = Int
 
         class B(A):
             b = Float
 
         b = B()
-        b.on_traitlet_change(self.notify1, 'a')
-        b.on_traitlet_change(self.notify2, 'b')
+        b.on_trait_change(self.notify1, 'a')
+        b.on_trait_change(self.notify2, 'b')
         b.a = 0
         b.b = 0.0
         self.assertEquals(len(self._notify1),0)
@@ -260,7 +260,7 b' class TestHasTraitletsNotify(TestCase):'
 
     def test_static_notify(self):
 
-        class A(HasTraitlets):
+        class A(HasTraits):
             a = Int
             _notify1 = []
             def _a_changed(self, name, old, new):
@@ -296,73 +296,73 b' class TestHasTraitletsNotify(TestCase):'
         def callback3(name, old, new):
             self.cb = (name, old, new)
 
-        class A(HasTraitlets):
+        class A(HasTraits):
             a = Int
 
         a = A()
-        a.on_traitlet_change(callback0, 'a')
+        a.on_trait_change(callback0, 'a')
         a.a = 10
         self.assertEquals(self.cb,())
-        a.on_traitlet_change(callback0, 'a', remove=True)
+        a.on_trait_change(callback0, 'a', remove=True)
 
-        a.on_traitlet_change(callback1, 'a')
+        a.on_trait_change(callback1, 'a')
         a.a = 100
         self.assertEquals(self.cb,('a',))
-        a.on_traitlet_change(callback1, 'a', remove=True)
+        a.on_trait_change(callback1, 'a', remove=True)
 
-        a.on_traitlet_change(callback2, 'a')
+        a.on_trait_change(callback2, 'a')
         a.a = 1000
         self.assertEquals(self.cb,('a',1000))
-        a.on_traitlet_change(callback2, 'a', remove=True)
+        a.on_trait_change(callback2, 'a', remove=True)
 
-        a.on_traitlet_change(callback3, 'a')
+        a.on_trait_change(callback3, 'a')
         a.a = 10000
         self.assertEquals(self.cb,('a',1000,10000))
-        a.on_traitlet_change(callback3, 'a', remove=True)
+        a.on_trait_change(callback3, 'a', remove=True)
 
-        self.assertEquals(len(a._traitlet_notifiers['a']),0)
+        self.assertEquals(len(a._trait_notifiers['a']),0)
 
 
-class TestHasTraitlets(TestCase):
+class TestHasTraits(TestCase):
 
-    def test_traitlet_names(self):
-        class A(HasTraitlets):
+    def test_trait_names(self):
+        class A(HasTraits):
             i = Int
             f = Float
         a = A()
-        self.assertEquals(a.traitlet_names(),['i','f'])
+        self.assertEquals(a.trait_names(),['i','f'])
 
-    def test_traitlet_metadata(self):
-        class A(HasTraitlets):
+    def test_trait_metadata(self):
+        class A(HasTraits):
             i = Int(config_key='MY_VALUE')
         a = A()
-        self.assertEquals(a.traitlet_metadata('i','config_key'), 'MY_VALUE')
+        self.assertEquals(a.trait_metadata('i','config_key'), 'MY_VALUE')
 
-    def test_traitlets(self):
-        class A(HasTraitlets):
+    def test_traits(self):
+        class A(HasTraits):
             i = Int
             f = Float
         a = A()
-        self.assertEquals(a.traitlets(), dict(i=A.i, f=A.f))
+        self.assertEquals(a.traits(), dict(i=A.i, f=A.f))
 
-    def test_traitlets_metadata(self):
-        class A(HasTraitlets):
+    def test_traits_metadata(self):
+        class A(HasTraits):
             i = Int(config_key='VALUE1', other_thing='VALUE2')
             f = Float(config_key='VALUE3', other_thing='VALUE2')
             j = Int(0)
         a = A()
-        self.assertEquals(a.traitlets(), dict(i=A.i, f=A.f, j=A.j))
-        traitlets = a.traitlets(config_key='VALUE1', other_thing='VALUE2')
-        self.assertEquals(traitlets, dict(i=A.i))
+        self.assertEquals(a.traits(), dict(i=A.i, f=A.f, j=A.j))
+        traits = a.traits(config_key='VALUE1', other_thing='VALUE2')
+        self.assertEquals(traits, dict(i=A.i))
 
         # This passes, but it shouldn't because I am replicating a bug in 
         # traits.
-        traitlets = a.traitlets(config_key=lambda v: True)
-        self.assertEquals(traitlets, dict(i=A.i, f=A.f, j=A.j))
+        traits = a.traits(config_key=lambda v: True)
+        self.assertEquals(traits, dict(i=A.i, f=A.f, j=A.j))
 
 
 #-----------------------------------------------------------------------------
-# Tests for specific traitlet types
+# Tests for specific trait types
 #-----------------------------------------------------------------------------
 
 
@@ -371,7 +371,7 b' class TestType(TestCase):'
     def test_default(self):
 
         class B(object): pass
-        class A(HasTraitlets):
+        class A(HasTraits):
             klass = Type
 
         a = A()
@@ -379,42 +379,42 b' class TestType(TestCase):'
 
         a.klass = B
         self.assertEquals(a.klass, B)
-        self.assertRaises(TraitletError, setattr, a, 'klass', 10)
+        self.assertRaises(TraitError, setattr, a, 'klass', 10)
 
     def test_value(self):
 
         class B(object): pass
         class C(object): pass
-        class A(HasTraitlets):
+        class A(HasTraits):
             klass = Type(B)
         
         a = A()
         self.assertEquals(a.klass, B)
-        self.assertRaises(TraitletError, setattr, a, 'klass', C)
-        self.assertRaises(TraitletError, setattr, a, 'klass', object)
+        self.assertRaises(TraitError, setattr, a, 'klass', C)
+        self.assertRaises(TraitError, setattr, a, 'klass', object)
         a.klass = B
 
     def test_allow_none(self):
 
         class B(object): pass
         class C(B): pass
-        class A(HasTraitlets):
+        class A(HasTraits):
             klass = Type(B, allow_none=False)
 
         a = A()
         self.assertEquals(a.klass, B)
-        self.assertRaises(TraitletError, setattr, a, 'klass', None)
+        self.assertRaises(TraitError, setattr, a, 'klass', None)
         a.klass = C
         self.assertEquals(a.klass, C)
 
     def test_validate_klass(self):
 
-        class A(HasTraitlets):
+        class A(HasTraits):
             klass = Type('no strings allowed')
 
         self.assertRaises(ImportError, A)
 
-        class A(HasTraitlets):
+        class A(HasTraits):
             klass = Type('rub.adub.Duck')
 
         self.assertRaises(ImportError, A)
@@ -422,19 +422,19 b' class TestType(TestCase):'
     def test_validate_default(self):
 
         class B(object): pass
-        class A(HasTraitlets):
+        class A(HasTraits):
             klass = Type('bad default', B)
 
         self.assertRaises(ImportError, A)
 
-        class C(HasTraitlets):
+        class C(HasTraits):
             klass = Type(None, B, allow_none=False)
 
-        self.assertRaises(TraitletError, C)
+        self.assertRaises(TraitError, C)
 
     def test_str_klass(self):
 
-        class A(HasTraitlets):
+        class A(HasTraits):
             klass = Type('IPython.utils.ipstruct.Struct')
 
         from IPython.utils.ipstruct import Struct
@@ -442,7 +442,7 b' class TestType(TestCase):'
         a.klass = Struct
         self.assertEquals(a.klass, Struct)
         
-        self.assertRaises(TraitletError, setattr, a, 'klass', 10)
+        self.assertRaises(TraitError, setattr, a, 'klass', 10)
 
 class TestInstance(TestCase):
 
@@ -451,7 +451,7 b' class TestInstance(TestCase):'
         class Bar(Foo): pass
         class Bah(object): pass
         
-        class A(HasTraitlets):
+        class A(HasTraits):
             inst = Instance(Foo)
 
         a = A()
@@ -460,13 +460,13 b' class TestInstance(TestCase):'
         self.assert_(isinstance(a.inst, Foo))
         a.inst = Bar()
         self.assert_(isinstance(a.inst, Foo))
-        self.assertRaises(TraitletError, setattr, a, 'inst', Foo)
-        self.assertRaises(TraitletError, setattr, a, 'inst', Bar)
-        self.assertRaises(TraitletError, setattr, a, 'inst', Bah())
+        self.assertRaises(TraitError, setattr, a, 'inst', Foo)
+        self.assertRaises(TraitError, setattr, a, 'inst', Bar)
+        self.assertRaises(TraitError, setattr, a, 'inst', Bah())
 
     def test_unique_default_value(self):
         class Foo(object): pass
-        class A(HasTraitlets):
+        class A(HasTraits):
             inst = Instance(Foo,(),{})
 
         a = A()
@@ -481,18 +481,18 b' class TestInstance(TestCase):'
             def __init__(self, c, d):
                 self.c = c; self.d = d
 
-        class A(HasTraitlets):
+        class A(HasTraits):
             inst = Instance(Foo, (10,))
         a = A()
         self.assertEquals(a.inst.c, 10)
 
-        class B(HasTraitlets):
+        class B(HasTraits):
             inst = Instance(Bah, args=(10,), kw=dict(d=20))
         b = B()
         self.assertEquals(b.inst.c, 10)
         self.assertEquals(b.inst.d, 20)
 
-        class C(HasTraitlets):
+        class C(HasTraits):
             inst = Instance(Foo)
         c = C()
         self.assert_(c.inst is None)
@@ -500,25 +500,25 b' class TestInstance(TestCase):'
     def test_bad_default(self):
         class Foo(object): pass
 
-        class A(HasTraitlets):
+        class A(HasTraits):
             inst = Instance(Foo, allow_none=False)
         
-        self.assertRaises(TraitletError, A)
+        self.assertRaises(TraitError, A)
 
     def test_instance(self):
         class Foo(object): pass
 
         def inner():
-            class A(HasTraitlets):
+            class A(HasTraits):
                 inst = Instance(Foo())
         
-        self.assertRaises(TraitletError, inner)
+        self.assertRaises(TraitError, inner)
 
 
 class TestThis(TestCase):
 
     def test_this_class(self):
-        class Foo(HasTraitlets):
+        class Foo(HasTraits):
             this = This
 
         f = Foo()
@@ -526,10 +526,10 b' class TestThis(TestCase):'
         g = Foo()
         f.this = g
         self.assertEquals(f.this, g)
-        self.assertRaises(TraitletError, setattr, f, 'this', 10)
+        self.assertRaises(TraitError, setattr, f, 'this', 10)
 
     def test_this_inst(self):
-        class Foo(HasTraitlets):
+        class Foo(HasTraits):
             this = This()
         
         f = Foo()
@@ -537,7 +537,7 b' class TestThis(TestCase):'
         self.assert_(isinstance(f.this, Foo))
 
     def test_subclass(self):
-        class Foo(HasTraitlets):
+        class Foo(HasTraits):
             t = This()
         class Bar(Foo):
             pass
@@ -549,7 +549,7 b' class TestThis(TestCase):'
         self.assertEquals(b.t, f)
 
     def test_subclass_override(self):
-        class Foo(HasTraitlets):
+        class Foo(HasTraits):
             t = This()
         class Bar(Foo):
             t = This()
@@ -557,10 +557,10 b' class TestThis(TestCase):'
         b = Bar()
         f.t = b
         self.assertEquals(f.t, b)
-        self.assertRaises(TraitletError, setattr, b, 't', f)
+        self.assertRaises(TraitError, setattr, b, 't', f)
 
-class TraitletTestBase(TestCase):
-    """A best testing class for basic traitlet types."""
+class TraitTestBase(TestCase):
+    """A best testing class for basic trait types."""
 
     def assign(self, value):
         self.obj.value = value
@@ -577,33 +577,33 b' class TraitletTestBase(TestCase):'
     def test_bad_values(self):
         if hasattr(self, '_bad_values'):
             for value in self._bad_values:
-                self.assertRaises(TraitletError, self.assign, value)
+                self.assertRaises(TraitError, self.assign, value)
 
     def test_default_value(self):
         if hasattr(self, '_default_value'):
             self.assertEquals(self._default_value, self.obj.value)
 
 
-class AnyTraitlet(HasTraitlets):
+class AnyTrait(HasTraits):
 
     value = Any
 
-class AnyTraitTest(TraitletTestBase):
+class AnyTraitTest(TraitTestBase):
 
-    obj = AnyTraitlet()
+    obj = AnyTrait()
 
     _default_value = None
     _good_values   = [10.0, 'ten', u'ten', [10], {'ten': 10},(10,), None, 1j]
     _bad_values    = []
 
 
-class IntTraitlet(HasTraitlets):
+class IntTrait(HasTraits):
 
     value = Int(99)
 
-class TestInt(TraitletTestBase):
+class TestInt(TraitTestBase):
 
-    obj = IntTraitlet()
+    obj = IntTrait()
     _default_value = 99
     _good_values   = [10, -10]
     _bad_values    = ['ten', u'ten', [10], {'ten': 10},(10,), None, 1j, 10L,
@@ -611,13 +611,13 b' class TestInt(TraitletTestBase):'
                       u'-10L', u'10.1', u'-10.1',  '10', '-10', u'10', u'-10']
 
 
-class LongTraitlet(HasTraitlets):
+class LongTrait(HasTraits):
 
     value = Long(99L)
 
-class TestLong(TraitletTestBase):
+class TestLong(TraitTestBase):
 
-    obj = LongTraitlet()
+    obj = LongTrait()
 
     _default_value = 99L
     _good_values   = [10, -10, 10L, -10L]
@@ -627,13 +627,13 b' class TestLong(TraitletTestBase):'
                       u'-10.1']
 
 
-class FloatTraitlet(HasTraitlets):
+class FloatTrait(HasTraits):
 
     value = Float(99.0)
 
-class TestFloat(TraitletTestBase):
+class TestFloat(TraitTestBase):
 
-    obj = FloatTraitlet()
+    obj = FloatTrait()
 
     _default_value = 99.0
     _good_values   = [10, -10, 10.1, -10.1]
@@ -642,13 +642,13 b' class TestFloat(TraitletTestBase):'
                       u'-10', u'10L', u'-10L', u'10.1', u'-10.1']
 
 
-class ComplexTraitlet(HasTraitlets):
+class ComplexTrait(HasTraits):
 
     value = Complex(99.0-99.0j)
 
-class TestComplex(TraitletTestBase):
+class TestComplex(TraitTestBase):
 
-    obj = ComplexTraitlet()
+    obj = ComplexTrait()
 
     _default_value = 99.0-99.0j
     _good_values   = [10, -10, 10.1, -10.1, 10j, 10+10j, 10-10j, 
@@ -656,13 +656,13 b' class TestComplex(TraitletTestBase):'
     _bad_values    = [10L, -10L, u'10L', u'-10L', 'ten', [10], {'ten': 10},(10,), None]
 
 
-class StringTraitlet(HasTraitlets):
+class StringTrait(HasTraits):
 
     value = Str('string')
 
-class TestString(TraitletTestBase):
+class TestString(TraitTestBase):
 
-    obj = StringTraitlet()
+    obj = StringTrait()
 
     _default_value = 'string'
     _good_values   = ['10', '-10', '10L',
@@ -671,13 +671,13 b' class TestString(TraitletTestBase):'
                       ['ten'],{'ten': 10},(10,), None,  u'string']
 
 
-class UnicodeTraitlet(HasTraitlets):
+class UnicodeTrait(HasTraits):
 
     value = Unicode(u'unicode')
 
-class TestUnicode(TraitletTestBase):
+class TestUnicode(TraitTestBase):
 
-    obj = UnicodeTraitlet()
+    obj = UnicodeTrait()
 
     _default_value = u'unicode'
     _good_values   = ['10', '-10', '10L', '-10L', '10.1', 

IPython/utils/traitlets.py

@@ -17,7 +17,7 b" We don't support:"
 * Delegation
 * Automatic GUI generation
 * A full set of trait types.  Most importantly, we don't provide container
-  traitlets (list, dict, tuple) that can trigger notifications if their
+  traits (list, dict, tuple) that can trigger notifications if their
   contents change.
 * API compatibility with enthought.traits
 
@@ -57,7 +57,18 b' from types import ('
     ListType, TupleType
 )
 
-from IPython.utils.importstring import import_item
+def import_item(name):
+    """Import and return bar given the string foo.bar."""
+    package = '.'.join(name.split('.')[0:-1])
+    obj = name.split('.')[-1]
+    execString = 'from %s import %s' % (package, obj)
+    try:
+        exec execString
+    except SyntaxError:
+        raise ImportError("Invalid class specification: %s" % name)
+    exec 'temp = %s' % obj
+    return temp
+
 
 ClassTypes = (ClassType, type)
 
@@ -75,11 +86,9 b' NoDefaultSpecified = NoDefaultSpecified()'
 class Undefined ( object ): pass
 Undefined = Undefined()
 
-
-class TraitletError(Exception):
+class TraitError(Exception):
     pass
 
-
 #-----------------------------------------------------------------------------
 # Utilities
 #-----------------------------------------------------------------------------
@@ -129,12 +138,12 b' def parse_notifier_name(name):'
     >>> parse_notifier_name(['a','b'])
     ['a', 'b']
     >>> parse_notifier_name(None)
-    ['anytraitlet']
+    ['anytrait']
     """
     if isinstance(name, str):
         return [name]
     elif name is None:
-        return ['anytraitlet']
+        return ['anytrait']
     elif isinstance(name, (list, tuple)):
         for n in name:
             assert isinstance(n, str), "names must be strings"
@@ -172,25 +181,25 b' def getmembers(object, predicate=None):'
 
 
 #-----------------------------------------------------------------------------
-# Base TraitletType for all traitlets
+# Base TraitType for all traits
 #-----------------------------------------------------------------------------
 
 
-class TraitletType(object):
-    """A base class for all traitlet descriptors.
+class TraitType(object):
+    """A base class for all trait descriptors.
 
     Notes
     -----
-    Our implementation of traitlets is based on Python's descriptor
+    Our implementation of traits is based on Python's descriptor
     prototol.  This class is the base class for all such descriptors.  The
-    only magic we use is a custom metaclass for the main :class:`HasTraitlets`
+    only magic we use is a custom metaclass for the main :class:`HasTraits`
     class that does the following:
 
-    1. Sets the :attr:`name` attribute of every :class:`TraitletType`
+    1. Sets the :attr:`name` attribute of every :class:`TraitType`
        instance in the class dict to the name of the attribute.
-    2. Sets the :attr:`this_class` attribute of every :class:`TraitletType`
-       instance in the class dict to the *class* that declared the traitlet.
-       This is used by the :class:`This` traitlet to allow subclasses to
+    2. Sets the :attr:`this_class` attribute of every :class:`TraitType`
+       instance in the class dict to the *class* that declared the trait.
+       This is used by the :class:`This` trait to allow subclasses to
        accept superclasses for :class:`This` values.
     """
     
@@ -200,7 +209,7 b' class TraitletType(object):'
     info_text = 'any value'
 
     def __init__(self, default_value=NoDefaultSpecified, **metadata):
-        """Create a TraitletType.
+        """Create a TraitType.
         """
         if default_value is not NoDefaultSpecified:
             self.default_value = default_value
@@ -225,11 +234,11 b' class TraitletType(object):'
         return dv
 
     def instance_init(self, obj):
-        """This is called by :meth:`HasTraitlets.__new__` to finish init'ing.
+        """This is called by :meth:`HasTraits.__new__` to finish init'ing.
 
         Some stages of initialization must be delayed until the parent
-        :class:`HasTraitlets` instance has been created.  This method is
-        called in :meth:`HasTraitlets.__new__` after the instance has been
+        :class:`HasTraits` instance has been created.  This method is
+        called in :meth:`HasTraits.__new__` after the instance has been
         created.
 
         This method trigger the creation and validation of default values
@@ -238,8 +247,8 b' class TraitletType(object):'
 
         Parameters
         ----------
-        obj : :class:`HasTraitlets` instance
-            The parent :class:`HasTraitlets` instance that has just been
+        obj : :class:`HasTraits` instance
+            The parent :class:`HasTraits` instance that has just been
             created.
         """
         self.set_default_value(obj)
@@ -249,30 +258,30 b' class TraitletType(object):'
 
         This method is called by :meth:`instance_init` to create and
         validate the default value.  The creation and validation of 
-        default values must be delayed until the parent :class:`HasTraitlets`
+        default values must be delayed until the parent :class:`HasTraits`
         class has been instantiated.
         """
         dv = self.get_default_value()
         newdv = self._validate(obj, dv)
-        obj._traitlet_values[self.name] = newdv
+        obj._trait_values[self.name] = newdv
 
     def __get__(self, obj, cls=None):
-        """Get the value of the traitlet by self.name for the instance.
+        """Get the value of the trait by self.name for the instance.
 
-        Default values are instantiated when :meth:`HasTraitlets.__new__`
+        Default values are instantiated when :meth:`HasTraits.__new__`
         is called.  Thus by the time this method gets called either the 
         default value or a user defined value (they called :meth:`__set__`)
-        is in the :class:`HasTraitlets` instance.
+        is in the :class:`HasTraits` instance.
         """
         if obj is None:
             return self
         else:
             try:
-                value = obj._traitlet_values[self.name]
+                value = obj._trait_values[self.name]
             except:
-                # HasTraitlets should call set_default_value to populate
+                # HasTraits should call set_default_value to populate
                 # this.  So this should never be reached.
-                raise TraitletError('Unexpected error in TraitletType: '
+                raise TraitError('Unexpected error in TraitType: '
                                     'default value not set properly')
             else:
                 return value
@@ -281,8 +290,8 b' class TraitletType(object):'
         new_value = self._validate(obj, value)
         old_value = self.__get__(obj)
         if old_value != new_value:
-            obj._traitlet_values[self.name] = new_value
-            obj._notify_traitlet(self.name, old_value, new_value)
+            obj._trait_values[self.name] = new_value
+            obj._notify_trait(self.name, old_value, new_value)
 
     def _validate(self, obj, value):
         if hasattr(self, 'validate'):
@@ -292,7 +301,7 b' class TraitletType(object):'
             if valid:
                 return value
             else:
-                raise TraitletError('invalid value for type: %r' % value)
+                raise TraitError('invalid value for type: %r' % value)
         elif hasattr(self, 'value_for'):
             return self.value_for(value)
         else:
@@ -303,13 +312,13 b' class TraitletType(object):'
 
     def error(self, obj, value):
         if obj is not None:
-            e = "The '%s' traitlet of %s instance must be %s, but a value of %s was specified." \
+            e = "The '%s' trait of %s instance must be %s, but a value of %s was specified." \
                 % (self.name, class_of(obj),
                    self.info(), repr_type(value))
         else:
-            e = "The '%s' traitlet must be %s, but a value of %r was specified." \
+            e = "The '%s' trait must be %s, but a value of %r was specified." \
                 % (self.name, self.info(), repr_type(value))            
-        raise TraitletError(e)
+        raise TraitError(e)
 
     def get_metadata(self, key):
         return getattr(self, '_metadata', {}).get(key, None)
@@ -319,62 +328,62 b' class TraitletType(object):'
 
 
 #-----------------------------------------------------------------------------
-# The HasTraitlets implementation
+# The HasTraits implementation
 #-----------------------------------------------------------------------------
 
 
-class MetaHasTraitlets(type):
-    """A metaclass for HasTraitlets.
+class MetaHasTraits(type):
+    """A metaclass for HasTraits.
     
-    This metaclass makes sure that any TraitletType class attributes are
+    This metaclass makes sure that any TraitType class attributes are
     instantiated and sets their name attribute.
     """
     
     def __new__(mcls, name, bases, classdict):
-        """Create the HasTraitlets class.
+        """Create the HasTraits class.
         
-        This instantiates all TraitletTypes in the class dict and sets their
+        This instantiates all TraitTypes in the class dict and sets their
         :attr:`name` attribute.
         """
         # print "MetaHasTraitlets (mcls, name): ", mcls, name
         # print "MetaHasTraitlets (bases): ", bases
         # print "MetaHasTraitlets (classdict): ", classdict
         for k,v in classdict.iteritems():
-            if isinstance(v, TraitletType):
+            if isinstance(v, TraitType):
                 v.name = k
             elif inspect.isclass(v):
-                if issubclass(v, TraitletType):
+                if issubclass(v, TraitType):
                     vinst = v()
                     vinst.name = k
                     classdict[k] = vinst
-        return super(MetaHasTraitlets, mcls).__new__(mcls, name, bases, classdict)
+        return super(MetaHasTraits, mcls).__new__(mcls, name, bases, classdict)
 
     def __init__(cls, name, bases, classdict):
-        """Finish initializing the HasTraitlets class.
+        """Finish initializing the HasTraits class.
         
-        This sets the :attr:`this_class` attribute of each TraitletType in the
+        This sets the :attr:`this_class` attribute of each TraitType in the
         class dict to the newly created class ``cls``.
         """
         for k, v in classdict.iteritems():
-            if isinstance(v, TraitletType):
+            if isinstance(v, TraitType):
                 v.this_class = cls
-        super(MetaHasTraitlets, cls).__init__(name, bases, classdict)
+        super(MetaHasTraits, cls).__init__(name, bases, classdict)
 
-class HasTraitlets(object):
+class HasTraits(object):
 
-    __metaclass__ = MetaHasTraitlets
+    __metaclass__ = MetaHasTraits
 
     def __new__(cls, *args, **kw):
         # This is needed because in Python 2.6 object.__new__ only accepts
         # the cls argument.
-        new_meth = super(HasTraitlets, cls).__new__
+        new_meth = super(HasTraits, cls).__new__
         if new_meth is object.__new__:
             inst = new_meth(cls)
         else:
             inst = new_meth(cls, *args, **kw)
-        inst._traitlet_values = {}
-        inst._traitlet_notifiers = {}
-        # Here we tell all the TraitletType instances to set their default
+        inst._trait_values = {}
+        inst._trait_notifiers = {}
+        # Here we tell all the TraitType instances to set their default
         # values on the instance. 
         for key in dir(cls):
             # Some descriptors raise AttributeError like zope.interface's
@@ -385,19 +394,20 b' class HasTraitlets(object):'
             except AttributeError:
                 pass
             else:
-                if isinstance(value, TraitletType):
+                if isinstance(value, TraitType):
                     value.instance_init(inst)
+
         return inst
 
     # def __init__(self):
-    #     self._traitlet_values = {}
-    #     self._traitlet_notifiers = {}
+    #     self._trait_values = {}
+    #     self._trait_notifiers = {}
 
-    def _notify_traitlet(self, name, old_value, new_value):
+    def _notify_trait(self, name, old_value, new_value):
 
         # First dynamic ones
-        callables = self._traitlet_notifiers.get(name,[])
-        more_callables = self._traitlet_notifiers.get('anytraitlet',[])
+        callables = self._trait_notifiers.get(name,[])
+        more_callables = self._trait_notifiers.get('anytrait',[])
         callables.extend(more_callables)
 
         # Now static ones
@@ -430,25 +440,25 b' class HasTraitlets(object):'
                 elif nargs + offset == 3:
                     c(name, old_value, new_value)
                 else:
-                    raise TraitletError('a traitlet changed callback '
+                    raise TraitError('a trait changed callback '
                                         'must have 0-3 arguments.')
             else:
-                raise TraitletError('a traitlet changed callback '
+                raise TraitError('a trait changed callback '
                                     'must be callable.')
                 
 
     def _add_notifiers(self, handler, name):
-        if not self._traitlet_notifiers.has_key(name):
+        if not self._trait_notifiers.has_key(name):
             nlist = []
-            self._traitlet_notifiers[name] = nlist
+            self._trait_notifiers[name] = nlist
         else:
-            nlist = self._traitlet_notifiers[name]
+            nlist = self._trait_notifiers[name]
         if handler not in nlist:
             nlist.append(handler)
 
     def _remove_notifiers(self, handler, name):
-        if self._traitlet_notifiers.has_key(name):
-            nlist = self._traitlet_notifiers[name]
+        if self._trait_notifiers.has_key(name):
+            nlist = self._trait_notifiers[name]
             try:
                 index = nlist.index(handler)
             except ValueError:
@@ -456,25 +466,25 b' class HasTraitlets(object):'
             else:
                 del nlist[index]
 
-    def on_traitlet_change(self, handler, name=None, remove=False):
-        """Setup a handler to be called when a traitlet changes.
+    def on_trait_change(self, handler, name=None, remove=False):
+        """Setup a handler to be called when a trait changes.
 
-        This is used to setup dynamic notifications of traitlet changes.
+        This is used to setup dynamic notifications of trait changes.
         
-        Static handlers can be created by creating methods on a HasTraitlets
-        subclass with the naming convention '_[traitletname]_changed'.  Thus,
-        to create static handler for the traitlet 'a', create the method
+        Static handlers can be created by creating methods on a HasTraits
+        subclass with the naming convention '_[traitname]_changed'.  Thus,
+        to create static handler for the trait 'a', create the method
         _a_changed(self, name, old, new) (fewer arguments can be used, see
         below).
         
         Parameters
         ----------
         handler : callable
-            A callable that is called when a traitlet changes.  Its 
+            A callable that is called when a trait changes.  Its 
             signature can be handler(), handler(name), handler(name, new)
             or handler(name, old, new).
         name : list, str, None
-            If None, the handler will apply to all traitlets.  If a list
+            If None, the handler will apply to all traits.  If a list
             of str, handler will apply to all names in the list.  If a
             str, the handler will apply just to that name.
         remove : bool
@@ -490,62 +500,62 b' class HasTraitlets(object):'
             for n in names:
                 self._add_notifiers(handler, n)
 
-    def traitlet_names(self, **metadata):
-        """Get a list of all the names of this classes traitlets."""
-        return self.traitlets(**metadata).keys()
+    def trait_names(self, **metadata):
+        """Get a list of all the names of this classes traits."""
+        return self.traits(**metadata).keys()
 
-    def traitlets(self, **metadata):
-        """Get a list of all the traitlets of this class.
+    def traits(self, **metadata):
+        """Get a list of all the traits of this class.
 
-        The TraitletTypes returned don't know anything about the values
-        that the various HasTraitlet's instances are holding.
+        The TraitTypes returned don't know anything about the values
+        that the various HasTrait's instances are holding.
 
         This follows the same algorithm as traits does and does not allow
         for any simple way of specifying merely that a metadata name
         exists, but has any value.  This is because get_metadata returns
         None if a metadata key doesn't exist.
         """
-        traitlets = dict([memb for memb in getmembers(self.__class__) if \
-                     isinstance(memb[1], TraitletType)])
+        traits = dict([memb for memb in getmembers(self.__class__) if \
+                     isinstance(memb[1], TraitType)])
 
         if len(metadata) == 0:
-            return traitlets
+            return traits
 
         for meta_name, meta_eval in metadata.items():
             if type(meta_eval) is not FunctionType:
                 metadata[meta_name] = _SimpleTest(meta_eval)
 
         result = {}
-        for name, traitlet in traitlets.items():
+        for name, trait in traits.items():
             for meta_name, meta_eval in metadata.items():
-                if not meta_eval(traitlet.get_metadata(meta_name)):
+                if not meta_eval(trait.get_metadata(meta_name)):
                     break
             else:
-                result[name] = traitlet
+                result[name] = trait
 
         return result
 
-    def traitlet_metadata(self, traitletname, key):
-        """Get metadata values for traitlet by key."""
+    def trait_metadata(self, traitname, key):
+        """Get metadata values for trait by key."""
         try:
-            traitlet = getattr(self.__class__, traitletname)
+            trait = getattr(self.__class__, traitname)
         except AttributeError:
-            raise TraitletError("Class %s does not have a traitlet named %s" %
-                                (self.__class__.__name__, traitletname))
+            raise TraitError("Class %s does not have a trait named %s" %
+                                (self.__class__.__name__, traitname))
         else:
-            return traitlet.get_metadata(key)
+            return trait.get_metadata(key)
 
 #-----------------------------------------------------------------------------
-# Actual TraitletTypes implementations/subclasses
+# Actual TraitTypes implementations/subclasses
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
-# TraitletTypes subclasses for handling classes and instances of classes
+# TraitTypes subclasses for handling classes and instances of classes
 #-----------------------------------------------------------------------------
 
 
-class ClassBasedTraitletType(TraitletType):
-    """A traitlet with error reporting for Type, Instance and This."""
+class ClassBasedTraitType(TraitType):
+    """A trait with error reporting for Type, Instance and This."""
 
     def error(self, obj, value):
         kind = type(value)
@@ -554,16 +564,16 b' class ClassBasedTraitletType(TraitletType):'
         else:
             msg = '%s (i.e. %s)' % ( str( kind )[1:-1], repr( value ) )
 
-        super(ClassBasedTraitletType, self).error(obj, msg)
+        super(ClassBasedTraitType, self).error(obj, msg)
 
 
-class Type(ClassBasedTraitletType):
-    """A traitlet whose value must be a subclass of a specified class."""
+class Type(ClassBasedTraitType):
+    """A trait whose value must be a subclass of a specified class."""
 
     def __init__ (self, default_value=None, klass=None, allow_none=True, **metadata ):
-        """Construct a Type traitlet
+        """Construct a Type trait
 
-        A Type traitlet specifies that its values must be subclasses of
+        A Type trait specifies that its values must be subclasses of
         a particular class.
 
         If only ``default_value`` is given, it is used for the ``klass`` as
@@ -575,12 +585,12 b' class Type(ClassBasedTraitletType):'
             The default value must be a subclass of klass.  If an str,
             the str must be a fully specified class name, like 'foo.bar.Bah'.
             The string is resolved into real class, when the parent 
-            :class:`HasTraitlets` class is instantiated.
+            :class:`HasTraits` class is instantiated.
         klass : class, str, None
-            Values of this traitlet must be a subclass of klass.  The klass
+            Values of this trait must be a subclass of klass.  The klass
             may be specified in a string like: 'foo.bar.MyClass'.
             The string is resolved into real class, when the parent 
-            :class:`HasTraitlets` class is instantiated.
+            :class:`HasTraits` class is instantiated.
         allow_none : boolean
             Indicates whether None is allowed as an assignable value. Even if
             ``False``, the default value may be ``None``.
@@ -592,7 +602,7 b' class Type(ClassBasedTraitletType):'
             klass = default_value
 
         if not (inspect.isclass(klass) or isinstance(klass, basestring)):
-            raise TraitletError("A Type traitlet must specify a class.")
+            raise TraitError("A Type trait must specify a class.")
 
         self.klass       = klass
         self._allow_none = allow_none
@@ -646,7 +656,7 b' class DefaultValueGenerator(object):'
         return klass(*self.args, **self.kw)
 
 
-class Instance(ClassBasedTraitletType):
+class Instance(ClassBasedTraitType):
     """A trait whose value must be an instance of a specified class.
     
     The value can also be an instance of a subclass of the specified class.
@@ -654,9 +664,9 b' class Instance(ClassBasedTraitletType):'
 
     def __init__(self, klass=None, args=None, kw=None, 
                  allow_none=True, **metadata ):
-        """Construct an Instance traitlet.
+        """Construct an Instance trait.
 
-        This traitlet allows values that are instances of a particular
+        This trait allows values that are instances of a particular
         class or its sublclasses.  Our implementation is quite different
         from that of enthough.traits as we don't allow instances to be used
         for klass and we handle the ``args`` and ``kw`` arguments differently.
@@ -664,7 +674,7 b' class Instance(ClassBasedTraitletType):'
         Parameters
         ----------
         klass : class, str
-            The class that forms the basis for the traitlet.  Class names
+            The class that forms the basis for the trait.  Class names
             can also be specified as strings, like 'foo.bar.Bar'.
         args : tuple
             Positional arguments for generating the default value.
@@ -684,7 +694,7 b' class Instance(ClassBasedTraitletType):'
         self._allow_none = allow_none
 
         if (klass is None) or (not (inspect.isclass(klass) or isinstance(klass, basestring))):
-            raise TraitletError('The klass argument must be a class'
+            raise TraitError('The klass argument must be a class'
                                 ' you gave: %r' % klass)
         self.klass = klass
         
@@ -700,9 +710,9 b' class Instance(ClassBasedTraitletType):'
                 kw = {}
         
             if not isinstance(kw, dict):
-                raise TraitletError("The 'kw' argument must be a dict or None.")
+                raise TraitError("The 'kw' argument must be a dict or None.")
             if not isinstance(args, tuple):
-                raise TraitletError("The 'args' argument must be a tuple or None.")
+                raise TraitError("The 'args' argument must be a tuple or None.")
             
             default_value = DefaultValueGenerator(*args, **kw)
 
@@ -741,9 +751,9 b' class Instance(ClassBasedTraitletType):'
     def get_default_value(self):
         """Instantiate a default value instance.
         
-        This is called when the containing HasTraitlets classes'
+        This is called when the containing HasTraits classes'
         :meth:`__new__` method is called to ensure that a unique instance
-        is created for each HasTraitlets instance.
+        is created for each HasTraits instance.
         """
         dv  = self.default_value
         if isinstance(dv, DefaultValueGenerator):
@@ -752,11 +762,11 b' class Instance(ClassBasedTraitletType):'
             return dv
 
 
-class This(ClassBasedTraitletType):
-    """A traitlet for instances of the class containing this trait.
+class This(ClassBasedTraitType):
+    """A trait for instances of the class containing this trait.
 
     Because how how and when class bodies are executed, the ``This``
-    traitlet can only have a default value of None.  This, and because we 
+    trait can only have a default value of None.  This, and because we 
     always validate default values, ``allow_none`` is *always* true.
     """
 
@@ -768,7 +778,7 b' class This(ClassBasedTraitletType):'
     def validate(self, obj, value):
         # What if value is a superclass of obj.__class__?  This is
         # complicated if it was the superclass that defined the This
-        # traitlet.
+        # trait.
         if isinstance(value, self.this_class) or (value is None):
             return value
         else:
@@ -776,17 +786,17 b' class This(ClassBasedTraitletType):'
 
 
 #-----------------------------------------------------------------------------
-# Basic TraitletTypes implementations/subclasses
+# Basic TraitTypes implementations/subclasses
 #-----------------------------------------------------------------------------
 
 
-class Any(TraitletType):
+class Any(TraitType):
     default_value = None
     info_text = 'any value'
 
 
-class Int(TraitletType):
-    """A integer traitlet."""
+class Int(TraitType):
+    """A integer trait."""
 
     evaluate = int
     default_value = 0
@@ -798,7 +808,7 b' class Int(TraitletType):'
         self.error(obj, value)
 
 class CInt(Int):
-    """A casting version of the int traitlet."""
+    """A casting version of the int trait."""
 
     def validate(self, obj, value):
         try:
@@ -807,8 +817,8 b' class CInt(Int):'
             self.error(obj, value)
 
 
-class Long(TraitletType):
-    """A long integer traitlet."""
+class Long(TraitType):
+    """A long integer trait."""
 
     evaluate = long
     default_value = 0L
@@ -823,7 +833,7 b' class Long(TraitletType):'
 
 
 class CLong(Long):
-    """A casting version of the long integer traitlet."""
+    """A casting version of the long integer trait."""
 
     def validate(self, obj, value):
         try:
@@ -832,8 +842,8 b' class CLong(Long):'
             self.error(obj, value)
 
 
-class Float(TraitletType):
-    """A float traitlet."""
+class Float(TraitType):
+    """A float trait."""
 
     evaluate = float
     default_value = 0.0
@@ -848,7 +858,7 b' class Float(TraitletType):'
 
 
 class CFloat(Float):
-    """A casting version of the float traitlet."""
+    """A casting version of the float trait."""
 
     def validate(self, obj, value):
         try:
@@ -856,8 +866,8 b' class CFloat(Float):'
         except:
             self.error(obj, value)
 
-class Complex(TraitletType):
-    """A traitlet for complex numbers."""
+class Complex(TraitType):
+    """A trait for complex numbers."""
 
     evaluate = complex
     default_value = 0.0 + 0.0j
@@ -872,7 +882,7 b' class Complex(TraitletType):'
 
 
 class CComplex(Complex):
-    """A casting version of the complex number traitlet."""
+    """A casting version of the complex number trait."""
 
     def validate (self, obj, value):
         try:
@@ -881,8 +891,8 b' class CComplex(Complex):'
             self.error(obj, value)
 
 
-class Str(TraitletType):
-    """A traitlet for strings."""
+class Str(TraitType):
+    """A trait for strings."""
 
     evaluate = lambda x: x
     default_value = ''
@@ -895,7 +905,7 b' class Str(TraitletType):'
 
 
 class CStr(Str):
-    """A casting version of the string traitlet."""
+    """A casting version of the string trait."""
 
     def validate(self, obj, value):
         try:
@@ -907,8 +917,8 b' class CStr(Str):'
                 self.error(obj, value)
 
 
-class Unicode(TraitletType):
-    """A traitlet for unicode strings."""
+class Unicode(TraitType):
+    """A trait for unicode strings."""
 
     evaluate = unicode
     default_value = u''
@@ -923,7 +933,7 b' class Unicode(TraitletType):'
 
 
 class CUnicode(Unicode):
-    """A casting version of the unicode traitlet."""
+    """A casting version of the unicode trait."""
 
     def validate(self, obj, value):
         try:
@@ -932,8 +942,8 b' class CUnicode(Unicode):'
             self.error(obj, value)
 
 
-class Bool(TraitletType):
-    """A boolean (True, False) traitlet."""
+class Bool(TraitType):
+    """A boolean (True, False) trait."""
     evaluate = bool
     default_value = False
     info_text = 'a boolean'
@@ -945,7 +955,7 b' class Bool(TraitletType):'
 
 
 class CBool(Bool):
-    """A casting version of the boolean traitlet."""
+    """A casting version of the boolean trait."""
 
     def validate(self, obj, value):
         try:
@@ -954,7 +964,7 b' class CBool(Bool):'
             self.error(obj, value)
 
 
-class Enum(TraitletType):
+class Enum(TraitType):
     """An enum that whose value must be in a given sequence."""
 
     def __init__(self, values, default_value=None, allow_none=True, **metadata):
@@ -999,7 +1009,7 b' class List(Instance):'
     """An instance of a Python list."""
 
     def __init__(self, default_value=None, allow_none=True, **metadata):
-        """Create a list traitlet type from a list or tuple.
+        """Create a list trait type from a list or tuple.
 
         The default value is created by doing ``list(default_value)``, 
         which creates a copy of the ``default_value``.
@@ -1008,6 +1018,8 b' class List(Instance):'
             args = ((),)
         elif isinstance(default_value, SequenceTypes):
             args = (default_value,)
+        else:
+            raise TypeError('default value of List was %s' % default_value)
 
         super(List,self).__init__(klass=list, args=args, 
                                   allow_none=allow_none, **metadata)

README.txt

@@ -11,8 +11,8 b' subdirectory in ``.html`` and ``.pdf`` formats, also available online at our'
 the plaintext version of these manuals.
 
 
-Instant running and testing
-===========================
+Instant running
+===============
 
 You can run IPython from this directory without even installing it system-wide
 by typing at the terminal:
@@ -20,10 +20,4 b' by typing at the terminal:'
 .. code-block:: bash
 
    python ipython.py
-
-and similarly, you can execute the built-in test suite with:
    
-.. code-block:: bash
-
-   python iptest.py
-   
  No newline at end of file

docs/Makefile

@@ -50,7 +50,9 b' html: api'
 	@echo
 	@echo "Build finished. The HTML pages are in build/html."
 
-api:
+api: source/api/generated/gen.txt
+
+source/api/generated/gen.txt:
 	python autogen_api.py
 	@echo "Build API docs finished."
 
@@ -71,7 +73,7 b' htmlhelp:'
 	@echo "Build finished; now you can run HTML Help Workshop with the" \
 	      ".hhp project file in build/htmlhelp."
 
-latex:
+latex: api
 	mkdir -p build/latex build/doctrees
 	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) build/latex
 	@echo

docs/examples/kernel/mcdriver.py

@@ -1,71 +1,148 b''
 #!/usr/bin/env python
 """Run a Monte-Carlo options pricer in parallel."""
 
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
+import sys
+import time
 from IPython.kernel import client
 import numpy as np
 from mcpricer import price_options
+from matplotlib import pyplot as plt
+
+#-----------------------------------------------------------------------------
+# Setup parameters for the run
+#-----------------------------------------------------------------------------
+
+def ask_question(text, the_type, default):
+    s = '%s [%r]: ' % (text, the_type(default))
+    result = raw_input(s)
+    if result:
+        return the_type(result)
+    else:
+        return the_type(default)
+
+cluster_profile = ask_question("Cluster profile", str, "default")
+price = ask_question("Initial price", float, 100.0)
+rate = ask_question("Interest rate", float, 0.05)
+days = ask_question("Days to expiration", int, 260)
+paths = ask_question("Number of MC paths", int, 10000)
+n_strikes = ask_question("Number of strike values", int, 5)
+min_strike = ask_question("Min strike price", float, 90.0)
+max_strike = ask_question("Max strike price", float, 110.0)
+n_sigmas = ask_question("Number of volatility values", int, 5)
+min_sigma = ask_question("Min volatility", float, 0.1)
+max_sigma = ask_question("Max volatility", float, 0.4)
+
+strike_vals = np.linspace(min_strike, max_strike, n_strikes)
+sigma_vals = np.linspace(min_sigma, max_sigma, n_sigmas)
+
+#-----------------------------------------------------------------------------
+# Setup for parallel calculation
+#-----------------------------------------------------------------------------
 
 # The MultiEngineClient is used to setup the calculation and works with all
 # engine.
-mec = client.MultiEngineClient(profile='mycluster')
+mec = client.MultiEngineClient(profile=cluster_profile)
 
 # The TaskClient is an interface to the engines that provides dynamic load 
 # balancing at the expense of not knowing which engine will execute the code.
-tc = client.TaskClient(profile='mycluster')
+tc = client.TaskClient(profile=cluster_profile)
 
 # Initialize the common code on the engines. This Python module has the
 # price_options function that prices the options.
 mec.run('mcpricer.py')
 
-# Define the function that will make up our tasks. We basically want to
-# call the price_options function with all but two arguments (K, sigma)
-# fixed.
-def my_prices(K, sigma):
-    S = 100.0
-    r = 0.05
-    days = 260
-    paths = 100000
-    return price_options(S, K, sigma, r, days, paths)
-
-# Create arrays of strike prices and volatilities
-nK = 10
-nsigma = 10
-K_vals = np.linspace(90.0, 100.0, nK)
-sigma_vals = np.linspace(0.1, 0.4, nsigma)
-
-# Submit tasks to the TaskClient for each (K, sigma) pair as a MapTask.
-# The MapTask simply applies a function (my_prices) to the arguments:
-# my_prices(K, sigma) and returns the result.
+#-----------------------------------------------------------------------------
+# Perform parallel calculation
+#-----------------------------------------------------------------------------
+
+print "Running parallel calculation over strike prices and volatilities..."
+print "Strike prices: ", strike_vals
+print "Volatilities: ", sigma_vals
+sys.stdout.flush()
+
+# Submit tasks to the TaskClient for each (strike, sigma) pair as a MapTask.
+t1 = time.time()
 taskids = []
-for K in K_vals:
+for strike in strike_vals:
     for sigma in sigma_vals:
-        t = client.MapTask(my_prices, args=(K, sigma))
+        t = client.MapTask(
+            price_options, 
+            args=(price, strike, sigma, rate, days, paths)
+        )
         taskids.append(tc.run(t))
 
 print "Submitted tasks: ", len(taskids)
+sys.stdout.flush()
 
 # Block until all tasks are completed.
 tc.barrier(taskids)
+t2 = time.time()
+t = t2-t1
+
+print "Parallel calculation completed, time = %s s" % t
+print "Collecting results..."
 
 # Get the results using TaskClient.get_task_result.
 results = [tc.get_task_result(tid) for tid in taskids]
 
 # Assemble the result into a structured NumPy array.
-prices = np.empty(nK*nsigma,
+prices = np.empty(n_strikes*n_sigmas,
     dtype=[('ecall',float),('eput',float),('acall',float),('aput',float)]
 )
+
 for i, price_tuple in enumerate(results):
     prices[i] = price_tuple
-prices.shape = (nK, nsigma)
-K_vals, sigma_vals = np.meshgrid(K_vals, sigma_vals)
+    
+prices.shape = (n_strikes, n_sigmas)
+strike_mesh, sigma_mesh = np.meshgrid(strike_vals, sigma_vals)
 
-def plot_options(sigma_vals, K_vals, prices):
+print "Results are available: strike_mesh, sigma_mesh, prices"
+print "To plot results type 'plot_options(sigma_mesh, strike_mesh, prices)'"
+
+#-----------------------------------------------------------------------------
+# Utilities
+#-----------------------------------------------------------------------------
+
+def plot_options(sigma_mesh, strike_mesh, prices):
     """
-    Make a contour plot of the option price in (sigma, K) space.
+    Make a contour plot of the option price in (sigma, strike) space.
     """
-    from matplotlib import pyplot as plt
-    plt.contourf(sigma_vals, K_vals, prices)
+    plt.figure(1)
+    
+    plt.subplot(221)
+    plt.contourf(sigma_mesh, strike_mesh, prices['ecall'])
+    plt.axis('tight')
     plt.colorbar()
-    plt.title("Option Price")
+    plt.title('European Call')
+    plt.ylabel("Strike Price")
+
+    plt.subplot(222)
+    plt.contourf(sigma_mesh, strike_mesh, prices['acall'])
+    plt.axis('tight')
+    plt.colorbar()
+    plt.title("Asian Call")
+
+    plt.subplot(223)
+    plt.contourf(sigma_mesh, strike_mesh, prices['eput'])
+    plt.axis('tight')
+    plt.colorbar()
+    plt.title("European Put")
     plt.xlabel("Volatility")
     plt.ylabel("Strike Price")
+
+    plt.subplot(224)
+    plt.contourf(sigma_mesh, strike_mesh, prices['aput'])
+    plt.axis('tight')
+    plt.colorbar()
+    plt.title("Asian Put")
+    plt.xlabel("Volatility")
+
+
+
+    
+
+

docs/source/config/overview.txt

@@ -134,7 +134,7 b' traitlets for a number of other types.'
 .. note::
 
     Underneath the hood, the :class:`Component` base class is a subclass of
-    :class:`IPython.utils.traitlets.HasTraitlets`. The
+    :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
     (mostly API compatible) of :mod:`enthought.traits` that does not have any

docs/source/development/index.txt

@@ -17,4 +17,4 b" IPython developer's guide"
    magic_blueprint.txt
    notification_blueprint.txt
    ipgraph.txt
-
+   ipython_qt.txt

docs/source/development/ipgraph.txt

@@ -57,3 +57,5 b' methods in :class:`InteractiveShell` that manage code execution::'
     nx.draw_spectral(g, node_size=100, alpha=0.6, node_color='r',
                      font_size=10, node_shape='o')
     plt.show()
+
+

docs/sphinxext/numpydoc.py

@@ -68,7 +68,8 b' def mangle_docstrings(app, what, name, obj, options, lines,'
 def mangle_signature(app, what, name, obj, options, sig, retann):
     # Do not try to inspect classes that don't define `__init__`
     if (inspect.isclass(obj) and
-        'initializes x; see ' in pydoc.getdoc(obj.__init__)):
+        (not hasattr(obj, '__init__') or
+        'initializes x; see ' in pydoc.getdoc(obj.__init__))):
         return '', ''
 
     if not (callable(obj) or hasattr(obj, '__argspec_is_invalid_')): return