Improvement to how config is handled in Components.

When a Component gets a config object, it aways makes a deepcopy of it.

IPython/core/component.py

@@ -1,214 +1,225 b''
 #!/usr/bin/env python
 # encoding: utf-8
 """
 A lightweight component system for IPython.
 
 Authors:
 
 * Brian Granger
 * Fernando Perez
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2009  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
-
+from copy import deepcopy
 from weakref import WeakValueDictionary
 
 from IPython.utils.ipstruct import Struct
 from IPython.utils.traitlets import (
     HasTraitlets, TraitletError, MetaHasTraitlets, Instance, This
 )
 
 
 #-----------------------------------------------------------------------------
 # Helper classes for Components
 #-----------------------------------------------------------------------------
 
 
 class ComponentError(Exception):
     pass
 
 class MetaComponentTracker(type):
     """A metaclass that tracks instances of Components and its subclasses."""
 
     def __init__(cls, name, bases, d):
         super(MetaComponentTracker, cls).__init__(name, bases, d)
         cls.__instance_refs = WeakValueDictionary()
         cls.__numcreated = 0
 
     def __call__(cls, *args, **kw):
         """Called when *class* is called (instantiated)!!!
         
         When a Component or subclass is instantiated, this is called and
         the instance is saved in a WeakValueDictionary for tracking.
         """
 
         instance = super(MetaComponentTracker, cls).__call__(*args, **kw)
         for c in cls.__mro__:
             if issubclass(cls, c) and issubclass(c, Component):
                 c.__numcreated += 1
                 c.__instance_refs[c.__numcreated] = instance
         return instance
 
     def get_instances(cls, name=None, klass=None, root=None):
         """Get all instances of cls and its subclasses.
 
         Parameters
         ----------
         name : str
             Limit to components with this name.
         klass : class
             Limit to components having isinstance(component, klass)
         root : Component or subclass
             Limit to components having this root.
         """
         instances = cls.__instance_refs.values()
         if name is not None:
             instances = [i for i in instances if i.name == name]
         if klass is not None:
             instances = [i for i in instances if isinstance(i, klass)]
         if root is not None:
             instances = [i for i in instances if i.root == root]
         return instances
 
     def get_instances_by_condition(cls, call, name=None, klass=None, root=None):
         """Get all instances of cls, i such that call(i)==True.
 
         This also takes the ``name``, ``klass`` and ``root`` arguments of
         :meth:`get_instance`
         """
         return [i for i in cls.get_instances(name,klass,root) if call(i)]
 
 
 class ComponentNameGenerator(object):
     """A Singleton to generate unique component names."""
 
     def __init__(self, prefix):
         self.prefix = prefix
         self.i = 0
 
     def __call__(self):
         count = self.i
         self.i += 1
         return "%s%s" % (self.prefix, count)
 
 
 ComponentNameGenerator = ComponentNameGenerator('ipython.component')
 
 
 class MetaComponent(MetaHasTraitlets, MetaComponentTracker):
     pass
 
 
 #-----------------------------------------------------------------------------
 # Component implementation
 #-----------------------------------------------------------------------------
 
 
 class Component(HasTraitlets):
 
     __metaclass__ = MetaComponent
 
     # Traitlets are fun!
     config = Instance(Struct,(),{})
     parent = This()
     root = This()
 
     def __init__(self, parent, name=None, config=None):
         """Create a component given a parent and possibly and name and config.
 
         Parameters
         ----------
         parent : Component subclass
             The parent in the component graph.  The parent is used
             to get the root of the component graph.
         name : str
             The unique name of the component.  If empty, then a unique
             one will be autogenerated.
-        config : Config
+        config : Struct
             If this is empty, self.config = parent.config, otherwise
             self.config = config and root.config is ignored.  This argument
             should only be used to *override* the automatic inheritance of 
             parent.config.  If a caller wants to modify parent.config 
             (not override), the caller should make a copy and change 
             attributes and then pass the copy to this argument.
         
         Notes
         -----
         Subclasses of Component must call the :meth:`__init__` method of
         :class:`Component` *before* doing anything else and using 
         :func:`super`::
         
             class MyComponent(Component):
                 def __init__(self, parent, name=None, config=None):
                     super(MyComponent, self).__init__(parent, name, config)
                     # Then any other code you need to finish initialization.
 
         This ensures that the :attr:`parent`, :attr:`name` and :attr:`config`
         attributes are handled properly.
         """
         super(Component, self).__init__()
         self._children = []
         if name is None:
             self.name = ComponentNameGenerator()
         else:
             self.name = name
         self.root = self # This is the default, it is set when parent is set
         self.parent = parent
         if config is not None:
-            self.config = config
+            self.config = deepcopy(config)
         else:
             if self.parent is not None:
-                self.config = self.parent.config
+                self.config = deepcopy(self.parent.config)
 
     #-------------------------------------------------------------------------
     # Static traitlet notifiations
     #-------------------------------------------------------------------------
 
     def _parent_changed(self, name, old, new):
         if old is not None:
             old._remove_child(self)
         if new is not None:
             new._add_child(self)
 
         if new is None:
             self.root = self
         else:
             self.root = new.root
 
     def _root_changed(self, name, old, new):
         if self.parent is None:
             if not (new is self):
                 raise ComponentError("Root not self, but parent is None.")
         else:
             if not self.parent.root is new:
                 raise ComponentError("Error in setting the root attribute: "
                                      "root != parent.root")
-        
+
+    def _config_changed(self, name, old, new):
+        # Get all traitlets with a config_key metadata entry
+        traitlets = self.traitlets(config_key=lambda v: True)
+        for k, v in traitlets.items():
+            try:
+                config_value = new[v.get_metadata('config_key')]
+            except KeyError:
+                pass
+            else:
+                setattr(self, k, config_value)
+
     @property
     def children(self):
         """A list of all my child components."""
         return self._children
 
     def _remove_child(self, child):
         """A private method for removing children componenets."""
         if child in self._children:
             index = self._children.index(child)
             del self._children[index]
 
     def _add_child(self, child):
         """A private method for adding children componenets."""
         if child not in self._children:
             self._children.append(child)
 
     def __repr__(self):
         return "<Component('%s')>" % self.name

IPython/core/tests/test_component.py

@@ -1,170 +1,194 b''
 #!/usr/bin/env python
 # encoding: utf-8
 """
 Tests for IPython.core.component
 
 Authors:
 
 * Brian Granger
 * Fernando Perez (design help)
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2009  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 from unittest import TestCase
 
 from IPython.core.component import Component, ComponentError
 from IPython.utils.traitlets import (
-    TraitletError
+    TraitletError, Int, Float, Str
 )
 from IPython.utils.ipstruct import Struct
 
 
 #-----------------------------------------------------------------------------
 # Test cases
 #-----------------------------------------------------------------------------
 
 
 class TestComponentMeta(TestCase):
 
     def test_get_instances(self):
         class BaseComponent(Component):
             pass
         c1 = BaseComponent(None)
         c2 = BaseComponent(c1)
         self.assertEquals(BaseComponent.get_instances(),[c1,c2])
 
     def test_get_instances_subclass(self):
         class MyComponent(Component):
             pass
         class MyOtherComponent(MyComponent):
             pass
         c1 = MyComponent(None)
         c2 = MyOtherComponent(c1)
         c3 = MyOtherComponent(c2)
         self.assertEquals(MyComponent.get_instances(), [c1, c2, c3])
         self.assertEquals(MyComponent.get_instances(klass=MyOtherComponent), [c2, c3])
 
     def test_get_instances_root(self):
         class MyComponent(Component):
             pass
         class MyOtherComponent(MyComponent):
             pass
         c1 = MyComponent(None)
         c2 = MyOtherComponent(c1)
         c3 = MyOtherComponent(c2)
         c4 = MyComponent(None)
         c5 = MyComponent(c4)
         self.assertEquals(MyComponent.get_instances(root=c1), [c1, c2, c3])
         self.assertEquals(MyComponent.get_instances(root=c4), [c4, c5])
 
 
 class TestComponent(TestCase):
 
     def test_parent_child(self):
         c1 = Component(None)
         c2 = Component(c1)
         c3 = Component(c1)
         c4 = Component(c3)
         self.assertEquals(c1.parent, None)
         self.assertEquals(c2.parent, c1)
         self.assertEquals(c3.parent, c1)
         self.assertEquals(c4.parent, c3)
         self.assertEquals(c1.children, [c2, c3])
         self.assertEquals(c2.children, [])
         self.assertEquals(c3.children, [c4])
         self.assertEquals(c4.children, [])
 
     def test_root(self):
         c1 = Component(None)
         c2 = Component(c1)
         c3 = Component(c1)
         c4 = Component(c3)
         self.assertEquals(c1.root, c1.root)
         self.assertEquals(c2.root, c1)
         self.assertEquals(c3.root, c1)
         self.assertEquals(c4.root, c1)
 
     def test_change_parent(self):
         c1 = Component(None)
         c2 = Component(None)
         c3 = Component(c1)
         self.assertEquals(c3.root, c1)
         self.assertEquals(c3.parent, c1)
         self.assertEquals(c1.children,[c3])
         c3.parent = c2
         self.assertEquals(c3.root, c2)
         self.assertEquals(c3.parent, c2)
         self.assertEquals(c2.children,[c3])
         self.assertEquals(c1.children,[])
 
     def test_subclass_parent(self):
         c1 = Component(None)
         self.assertRaises(TraitletError, setattr, c1, 'parent', 10)
 
         class MyComponent(Component):
             pass
         c1 = Component(None)
         c2 = MyComponent(c1)
         self.assertEquals(MyComponent.parent.this_class, Component)
         self.assertEquals(c2.parent, c1)
 
     def test_bad_root(self):
         c1 = Component(None)
         c2 = Component(None)
         c3 = Component(None)
         self.assertRaises(ComponentError, setattr, c1, 'root', c2)
         c1.parent = c2
         self.assertEquals(c1.root, c2)
         self.assertRaises(ComponentError, setattr, c1, 'root', c3)
 
 
 class TestComponentConfig(TestCase):
 
     def test_default(self):
         c1 = Component(None)
         c2 = Component(c1)
         c3 = Component(c2)
         self.assertEquals(c1.config, c2.config)
         self.assertEquals(c2.config, c3.config)
 
     def test_custom(self):
         config = Struct()
         config.FOO = 'foo'
         config.BAR = 'bar'
         c1 = Component(None, config=config)
         c2 = Component(c1)
         c3 = Component(c2)
         self.assertEquals(c1.config, config)
         self.assertEquals(c2.config, config)
         self.assertEquals(c3.config, config)
+        # Test that we always make copies
+        self.assert_(c1.config is not config)
+        self.assert_(c2.config is not config)
+        self.assert_(c3.config is not config)
+        self.assert_(c1.config is not c2.config)
+        self.assert_(c2.config is not c3.config)
+        
+    def test_inheritance(self):
+        class MyComponent(Component):
+            a = Int(1, config_key='A')
+            b = Float(1.0, config_key='B')
+            c = Str('no config')
+        config = Struct()
+        config.A = 2
+        config.B = 2.0
+        c1 = MyComponent(None, config=config)
+        c2 = MyComponent(c1)
+        self.assertEquals(c1.a, config.A)
+        self.assertEquals(c1.b, config.B)
+        self.assertEquals(c2.a, config.A)
+        self.assertEquals(c2.b, config.B)
+        c4 = MyComponent(c2, config=Struct())
+        self.assertEquals(c4.a, 1)
+        self.assertEquals(c4.b, 1.0)
 
 class TestComponentName(TestCase):
 
     def test_default(self):
         class MyComponent(Component):
             pass
         c1 = Component(None)
         c2 = MyComponent(None)
         c3 = Component(c2)
         self.assertNotEquals(c1.name, c2.name)
         self.assertNotEquals(c1.name, c3.name)
 
     def test_manual(self):
         class MyComponent(Component):
             pass
         c1 = Component(None, name='foo')
         c2 = MyComponent(None, name='bar')
         c3 = Component(c2, name='bah')
         self.assertEquals(c1.name, 'foo')
         self.assertEquals(c2.name, 'bar')
         self.assertEquals(c3.name, 'bah')

IPython/utils/ipstruct.py

@@ -1,400 +1,400 b''
 #!/usr/bin/env python
 # encoding: utf-8
 """A dict subclass that supports attribute style access.
 
 Authors:  
 
 * Fernando Perez (original)
 * Brian Granger (refactoring to a dict subclass)
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2009  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import pprint
 
 from IPython.utils.genutils import list2dict2
 
 __all__ = ['Struct']
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
 
 class Struct(dict):
     """A dict subclass with attribute style access.
 
     This dict subclass has a a few extra features:
 
     * Attribute style access.
     * Protection of class members (like keys, items) when using attribute
       style access.
     * The ability to restrict assignment to only existing keys.
     * Intelligent merging.
     * Overloaded operators.
     """
-
+    _allownew = True
     def __init__(self, *args, **kw):
         """Initialize with a dictionary, another Struct, or data.
 
         Parameters
         ----------
         args : dict, Struct
             Initialize with one dict or Struct
         kw : dict
             Initialize with key, value pairs.
 
         Examples
         --------
 
         >>> s = Struct(a=10,b=30)
         >>> s.a
         10
         >>> s.b
         30
         >>> s2 = Struct(s,c=30)
         >>> s2.keys()
         ['a', 'c', 'b']
         """
         object.__setattr__(self, '_allownew', True)
         dict.__init__(self, *args, **kw)
 
     def __setitem__(self, key, value):
         """Set an item with check for allownew.
 
         Examples
         --------
 
         >>> s = Struct()
         >>> s['a'] = 10
         >>> s.allow_new_attr(False)
         >>> s['a'] = 10
         >>> s['a']
         10
         >>> try:
         ...     s['b'] = 20
         ... except KeyError:
         ...     print 'this is not allowed'
         ...     
         this is not allowed
         """
         if not self._allownew and not self.has_key(key):
             raise KeyError(
                 "can't create new attribute %s when allow_new_attr(False)" % key)
         dict.__setitem__(self, key, value)
 
     def __setattr__(self, key, value):
         """Set an attr with protection of class members.
 
         This calls :meth:`self.__setitem__` but convert :exc:`KeyError` to 
         :exc:`AttributeError`.
 
         Examples
         --------
 
         >>> s = Struct()
         >>> s.a = 10
         >>> s.a
         10
         >>> try:
         ...     s.get = 10
         ... except AttributeError:
         ...     print "you can't set a class member"
         ...     
         you can't set a class member
         """
         # If key is an str it might be a class member or instance var
         if isinstance(key, str):
             # I can't simply call hasattr here because it calls getattr, which
             # calls self.__getattr__, which returns True for keys in 
             # self._data.  But I only want keys in the class and in
             # self.__dict__
             if key in self.__dict__ or hasattr(Struct, key):
                 raise AttributeError(
                     'attr %s is a protected member of class Struct.' % key
                 )
         try:
             self.__setitem__(key, value)
         except KeyError, e:
             raise AttributeError(e)
 
     def __getattr__(self, key):
         """Get an attr by calling :meth:`dict.__getitem__`.
 
         Like :meth:`__setattr__`, this method converts :exc:`KeyError` to 
         :exc:`AttributeError`.
 
         Examples
         --------
 
         >>> s = Struct(a=10)
         >>> s.a
         10
         >>> type(s.get)
         <type 'builtin_function_or_method'>
         >>> try:
         ...     s.b
         ... except AttributeError:
         ...     print "I don't have that key"
         ...     
         I don't have that key
         """
         try:
             result = self[key]
         except KeyError:
             raise AttributeError(key)
         else:
             return result
 
     def __iadd__(self, other):
         """s += s2 is a shorthand for s.merge(s2).
         
         Examples
         --------
         
         >>> s = Struct(a=10,b=30)
         >>> s2 = Struct(a=20,c=40)
         >>> s += s2
         >>> s
         {'a': 10, 'c': 40, 'b': 30}
         """
         self.merge(other)
         return self
 
     def __add__(self,other):
         """s + s2 -> New Struct made from s.merge(s2).
         
         Examples
         --------
         
         >>> s1 = Struct(a=10,b=30)
         >>> s2 = Struct(a=20,c=40)
         >>> s = s1 + s2
         >>> s
         {'a': 10, 'c': 40, 'b': 30}
         """
         sout = self.copy()
         sout.merge(other)
         return sout
 
     def __sub__(self,other):
         """s1 - s2 -> remove keys in s2 from s1.
         
         Examples
         --------
         
         >>> s1 = Struct(a=10,b=30)
         >>> s2 = Struct(a=40)
         >>> s = s1 - s2
         >>> s
         {'b': 30}
         """
         sout = self.copy()
         sout -= other
         return sout
 
     def __isub__(self,other):
         """Inplace remove keys from self that are in other.
         
         Examples
         --------
         
         >>> s1 = Struct(a=10,b=30)
         >>> s2 = Struct(a=40)
         >>> s1 -= s2
         >>> s1
         {'b': 30}
         """
         for k in other.keys():
             if self.has_key(k):
                 del self[k]
         return self
 
     def __dict_invert(self, data):
         """Helper function for merge. 
 
         Takes a dictionary whose values are lists and returns a dict with 
         the elements of each list as keys and the original keys as values.
         """
         outdict = {}
         for k,lst in data.items():
             if isinstance(lst, str):
                 lst = lst.split()
             for entry in lst:
                 outdict[entry] = k
         return outdict
 
     def dict(self):
         return self
 
     def copy(self):
         """Return a copy as a Struct.
         
         Examples
         --------
         
         >>> s = Struct(a=10,b=30)
         >>> s2 = s.copy()
         >>> s2
         {'a': 10, 'b': 30}
         >>> type(s2).__name__
         'Struct'
         """
         return Struct(dict.copy(self))
 
     def hasattr(self, key):
         """hasattr function available as a method.
 
         Implemented like has_key.
 
         Examples
         --------
 
         >>> s = Struct(a=10)
         >>> s.hasattr('a')
         True
         >>> s.hasattr('b')
         False
         >>> s.hasattr('get')
         False
         """
         return self.has_key(key)
 
     def allow_new_attr(self, allow = True):
         """Set whether new attributes can be created in this Struct.
 
         This can be used to catch typos by verifying that the attribute user
         tries to change already exists in this Struct.
         """
         object.__setattr__(self, '_allownew', allow)
 
     def merge(self, __loc_data__=None, __conflict_solve=None, **kw):
         """Merge two Structs with customizable conflict resolution.
 
         This is similar to :meth:`update`, but much more flexible. First, a
         dict is made from data+key=value pairs. When merging this dict with
         the Struct S, the optional dictionary 'conflict' is used to decide
         what to do.
 
         If conflict is not given, the default behavior is to preserve any keys
         with their current value (the opposite of the :meth:`update` method's
         behavior).
 
         Parameters
         ----------
         __loc_data : dict, Struct
             The data to merge into self
         __conflict_solve : dict
             The conflict policy dict.  The keys are binary functions used to
             resolve the conflict and the values are lists of strings naming
             the keys the conflict resolution function applies to.  Instead of
             a list of strings a space separated string can be used, like
             'a b c'.
         kw : dict
             Additional key, value pairs to merge in
 
         Notes
         -----
 
         The `__conflict_solve` dict is a dictionary of binary functions which will be used to
         solve key conflicts.  Here is an example::
         
             __conflict_solve = dict(
                 func1=['a','b','c'],
                 func2=['d','e']
             )
         
         In this case, the function :func:`func1` will be used to resolve
         keys 'a', 'b' and 'c' and the function :func:`func2` will be used for 
         keys 'd' and 'e'.  This could also be written as::
 
             __conflict_solve = dict(func1='a b c',func2='d e')
 
         These functions will be called for each key they apply to with the
         form::
 
             func1(self['a'], other['a'])
 
         The return value is used as the final merged value.
 
         As a convenience, merge() provides five (the most commonly needed)
         pre-defined policies: preserve, update, add, add_flip and add_s. The
         easiest explanation is their implementation::
 
             preserve = lambda old,new: old
             update   = lambda old,new: new
             add      = lambda old,new: old + new
             add_flip = lambda old,new: new + old  # note change of order!
             add_s    = lambda old,new: old + ' ' + new  # only for str!
 
         You can use those four words (as strings) as keys instead
         of defining them as functions, and the merge method will substitute
         the appropriate functions for you.
 
         For more complicated conflict resolution policies, you still need to
         construct your own functions.
 
         Examples
         --------
 
         This show the default policy:
         
         >>> s = Struct(a=10,b=30)
         >>> s2 = Struct(a=20,c=40)
         >>> s.merge(s2)
         >>> s
         {'a': 10, 'c': 40, 'b': 30}
         
         Now, show how to specify a conflict dict:
         
         >>> s = Struct(a=10,b=30)
         >>> s2 = Struct(a=20,b=40)
         >>> conflict = {'update':'a','add':'b'}
         >>> s.merge(s2,conflict)
         >>> s
         {'a': 20, 'b': 70}
         """
 
         data_dict = dict(__loc_data__,**kw)
 
         # policies for conflict resolution: two argument functions which return
         # the value that will go in the new struct
         preserve = lambda old,new: old
         update   = lambda old,new: new
         add      = lambda old,new: old + new
         add_flip = lambda old,new: new + old  # note change of order!
         add_s    = lambda old,new: old + ' ' + new
 
         # default policy is to keep current keys when there's a conflict
         conflict_solve = list2dict2(self.keys(), default = preserve)
 
         # the conflict_solve dictionary is given by the user 'inverted': we
         # need a name-function mapping, it comes as a function -> names
         # dict. Make a local copy (b/c we'll make changes), replace user
         # strings for the three builtin policies and invert it.
         if __conflict_solve:
             inv_conflict_solve_user = __conflict_solve.copy()
             for name, func in [('preserve',preserve), ('update',update),
                                ('add',add), ('add_flip',add_flip),
                                ('add_s',add_s)]:
                 if name in inv_conflict_solve_user.keys():
                     inv_conflict_solve_user[func] = inv_conflict_solve_user[name]
                     del inv_conflict_solve_user[name]
             conflict_solve.update(self.__dict_invert(inv_conflict_solve_user))
         #print 'merge. conflict_solve: '; pprint(conflict_solve) # dbg
         #print '*'*50,'in merger. conflict_solver:';  pprint(conflict_solve)
         for key in data_dict:
             if key not in self:
                 self[key] = data_dict[key]
             else:
                 self[key] = conflict_solve[key](self[key],data_dict[key])
 

IPython/utils/tests/test_traitlets.py

@@ -1,645 +1,667 b''
 #!/usr/bin/env python
 # encoding: utf-8
 """
 Tests for IPython.utils.traitlets.
 
 Authors:
 
 * Brian Granger
 * Enthought, Inc.  Some of the code in this file comes from enthought.traits
   and is licensed under the BSD license.  Also, many of the ideas also come
   from enthought.traits even though our implementation is very different.
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2009  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import sys
 import os
 
 
 from unittest import TestCase
 
 from IPython.utils.traitlets import (
     HasTraitlets, MetaHasTraitlets, TraitletType, Any,
     Int, Long, Float, Complex, Str, Unicode, Bool, TraitletError,
     Undefined, Type, This, Instance
 )
 
 
 #-----------------------------------------------------------------------------
 # Helper classes for testing
 #-----------------------------------------------------------------------------
 
 
 class HasTraitletsStub(HasTraitlets):
 
     def _notify_traitlet(self, name, old, new):
         self._notify_name = name
         self._notify_old = old
         self._notify_new = new
 
 
 #-----------------------------------------------------------------------------
 # Test classes
 #-----------------------------------------------------------------------------
 
 
 class TestTraitletType(TestCase):
 
     def test_get_undefined(self):
         class A(HasTraitlets):
             a = TraitletType
         a = A()
         self.assertEquals(a.a, Undefined)
 
     def test_set(self):
         class A(HasTraitletsStub):
             a = TraitletType
 
         a = A()
         a.a = 10
         self.assertEquals(a.a, 10)
         self.assertEquals(a._notify_name, 'a')
         self.assertEquals(a._notify_old, Undefined)
         self.assertEquals(a._notify_new, 10)
 
     def test_validate(self):
         class MyTT(TraitletType):
             def validate(self, inst, value):
                 return -1
         class A(HasTraitletsStub):
             tt = MyTT
         
         a = A()
         a.tt = 10
         self.assertEquals(a.tt, -1)
 
     def test_default_validate(self):
         class MyIntTT(TraitletType):
             def validate(self, obj, value):
                 if isinstance(value, int):
                     return value
                 self.error(obj, value)
         class A(HasTraitlets):
             tt = MyIntTT(10)
         a = A()
         self.assertEquals(a.tt, 10)
 
         # Defaults are validated when the HasTraitlets is instantiated
         class B(HasTraitlets):
             tt = MyIntTT('bad default')
         self.assertRaises(TraitletError, B)
 
     def test_is_valid_for(self):
         class MyTT(TraitletType):
             def is_valid_for(self, value):
                 return True
         class A(HasTraitlets):
             tt = MyTT
 
         a = A()
         a.tt = 10
         self.assertEquals(a.tt, 10)
 
     def test_value_for(self):
         class MyTT(TraitletType):
             def value_for(self, value):
                 return 20
         class A(HasTraitlets):
             tt = MyTT
 
         a = A()
         a.tt = 10
         self.assertEquals(a.tt, 20)
 
     def test_info(self):
         class A(HasTraitlets):
             tt = TraitletType
         a = A()
         self.assertEquals(A.tt.info(), 'any value')
 
     def test_error(self):
         class A(HasTraitlets):
             tt = TraitletType
         a = A()
         self.assertRaises(TraitletError, A.tt.error, a, 10)
 
 
 class TestHasTraitletsMeta(TestCase):
 
     def test_metaclass(self):
         self.assertEquals(type(HasTraitlets), MetaHasTraitlets)
 
         class A(HasTraitlets):
             a = Int
 
         a = A()
         self.assertEquals(type(a.__class__), MetaHasTraitlets)
         self.assertEquals(a.a,0)
         a.a = 10
         self.assertEquals(a.a,10)
 
         class B(HasTraitlets):
             b = Int()
 
         b = B()
         self.assertEquals(b.b,0)
         b.b = 10
         self.assertEquals(b.b,10)
 
         class C(HasTraitlets):
             c = Int(30)
 
         c = C()
         self.assertEquals(c.c,30)
         c.c = 10
         self.assertEquals(c.c,10)
 
     def test_this_class(self):
         class A(HasTraitlets):
             t = This()
             tt = This()
         class B(A):
             tt = This()
             ttt = This()
         self.assertEquals(A.t.this_class, A)
         self.assertEquals(B.t.this_class, A)
         self.assertEquals(B.tt.this_class, B)
         self.assertEquals(B.ttt.this_class, B)
 
 class TestHasTraitletsNotify(TestCase):
 
     def setUp(self):
         self._notify1 = []
         self._notify2 = []
 
     def notify1(self, name, old, new):
         self._notify1.append((name, old, new))
 
     def notify2(self, name, old, new):
         self._notify2.append((name, old, new))
 
     def test_notify_all(self):
 
         class A(HasTraitlets):
             a = Int
             b = Float
 
         a = A()
         a.on_traitlet_change(self.notify1)
         a.a = 0
         self.assertEquals(len(self._notify1),0)
         a.b = 0.0
         self.assertEquals(len(self._notify1),0)
         a.a = 10
         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._notify1 = []
         a.on_traitlet_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):
             a = Int
             b = Float
 
         a = A()
         a.on_traitlet_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')
 
     def test_subclass(self):
 
         class A(HasTraitlets):
             a = Int
 
         class B(A):
             b = Float
 
         b = B()
         self.assertEquals(b.a,0)
         self.assertEquals(b.b,0.0)
         b.a = 100
         b.b = 100.0
         self.assertEquals(b.a,100)
         self.assertEquals(b.b,100.0)
 
     def test_notify_subclass(self):
 
         class A(HasTraitlets):
             a = Int
 
         class B(A):
             b = Float
 
         b = B()
         b.on_traitlet_change(self.notify1, 'a')
         b.on_traitlet_change(self.notify2, 'b')
         b.a = 0
         b.b = 0.0
         self.assertEquals(len(self._notify1),0)
         self.assertEquals(len(self._notify2),0)
         b.a = 10
         b.b = 10.0
         self.assert_(('a',0,10) in self._notify1)
         self.assert_(('b',0.0,10.0) in self._notify2)
 
     def test_static_notify(self):
 
         class A(HasTraitlets):
             a = Int
             _notify1 = []
             def _a_changed(self, name, old, new):
                 self._notify1.append((name, old, new))
 
         a = A()
         a.a = 0
         # This is broken!!!
         self.assertEquals(len(a._notify1),0)
         a.a = 10
         self.assert_(('a',0,10) in a._notify1)
 
         class B(A):
             b = Float
             _notify2 = []
             def _b_changed(self, name, old, new):
                 self._notify2.append((name, old, new))
 
         b = B()
         b.a = 10
         b.b = 10.0
         self.assert_(('a',0,10) in b._notify1)
         self.assert_(('b',0.0,10.0) in b._notify2)
 
     def test_notify_args(self):
 
         def callback0():
             self.cb = ()
         def callback1(name):
             self.cb = (name,)
         def callback2(name, new):
             self.cb = (name, new)
         def callback3(name, old, new):
             self.cb = (name, old, new)
 
         class A(HasTraitlets):
             a = Int
 
         a = A()
         a.on_traitlet_change(callback0, 'a')
         a.a = 10
         self.assertEquals(self.cb,())
         a.on_traitlet_change(callback0, 'a', remove=True)
 
         a.on_traitlet_change(callback1, 'a')
         a.a = 100
         self.assertEquals(self.cb,('a',))
         a.on_traitlet_change(callback1, 'a', remove=True)
 
         a.on_traitlet_change(callback2, 'a')
         a.a = 1000
         self.assertEquals(self.cb,('a',1000))
         a.on_traitlet_change(callback2, 'a', remove=True)
 
         a.on_traitlet_change(callback3, 'a')
         a.a = 10000
         self.assertEquals(self.cb,('a',1000,10000))
         a.on_traitlet_change(callback3, 'a', remove=True)
 
         self.assertEquals(len(a._traitlet_notifiers['a']),0)
 
 
-class TestTraitletKeys(TestCase):
+class TestHasTraitlets(TestCase):
 
-    def test_keys(self):
+    def test_traitlet_names(self):
         class A(HasTraitlets):
-            a = Int
-            b = Float
+            i = Int
+            f = Float
+        a = A()
+        self.assertEquals(a.traitlet_names(),['i','f'])
+
+    def test_traitlet_metadata(self):
+        class A(HasTraitlets):
+            i = Int(config_key='MY_VALUE')
         a = A()
-        self.assertEquals(a.traitlet_names(),['a','b'])
+        self.assertEquals(a.traitlet_metadata('i','config_key'), 'MY_VALUE')
 
+    def test_traitlets(self):
+        class A(HasTraitlets):
+            i = Int
+            f = Float
+        a = A()
+        self.assertEquals(a.traitlets(), dict(i=A.i, f=A.f))
+
+    def test_traitlets_metadata(self):
+        class A(HasTraitlets):
+            i = Int(config_key='VALUE1', other_thing='VALUE2')
+            f = Float(config_key='VALUE3', other_thing='VALUE2')
+        a = A()
+        # traitlets = a.traitlets(config_key=lambda v: True)
+        # self.assertEquals(traitlets, dict(i=A.i, f=A.f))
+        traitlets = a.traitlets(config_key='VALUE1', other_thing='VALUE2')
+        self.assertEquals(traitlets, dict(i=A.i))
 
 #-----------------------------------------------------------------------------
 # Tests for specific traitlet types
 #-----------------------------------------------------------------------------
 
 
 class TestType(TestCase):
 
     def test_default(self):
 
         class B(object): pass
         class A(HasTraitlets):
             klass = Type
 
         a = A()
         self.assertEquals(a.klass, None)
         a.klass = B
         self.assertEquals(a.klass, B)
         self.assertRaises(TraitletError, setattr, a, 'klass', 10)
 
     def test_value(self):
 
         class B(object): pass
         class C(object): pass
         class A(HasTraitlets):
             klass = Type(B)
         
         a = A()
         self.assertEquals(a.klass, B)
         self.assertRaises(TraitletError, setattr, a, 'klass', C)
         self.assertRaises(TraitletError, setattr, a, 'klass', object)
         a.klass = B
 
     def test_allow_none(self):
 
         class B(object): pass
         class C(B): pass
         class A(HasTraitlets):
             klass = Type(B, allow_none=False)
 
         a = A()
         self.assertEquals(a.klass, B)
         self.assertRaises(TraitletError, setattr, a, 'klass', None)
         a.klass = C
         self.assertEquals(a.klass, C)
 
     def test_validate_klass(self):
 
         def inner():
             class A(HasTraitlets):
                 klass = Type('no strings allowed')
 
         self.assertRaises(TraitletError, inner)
 
     def test_validate_default(self):
 
         class B(object): pass
         class A(HasTraitlets):
             klass = Type('bad default', B)
 
         self.assertRaises(TraitletError, A)
 
         class C(HasTraitlets):
             klass = Type(None, B, allow_none=False)
 
         self.assertRaises(TraitletError, C)
 
 class TestInstance(TestCase):
 
     def test_basic(self):
         class Foo(object): pass
         class Bar(Foo): pass
         class Bah(object): pass
         
         class A(HasTraitlets):
             inst = Instance(Foo)
 
         a = A()
         self.assert_(a.inst is None)
         a.inst = Foo()
         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())
 
     def test_unique_default_value(self):
         class Foo(object): pass        
         class A(HasTraitlets):
             inst = Instance(Foo,(),{})
 
         a = A()
         b = A()
         self.assert_(a.inst is not b.inst)
 
     def test_args_kw(self):
         class Foo(object):
             def __init__(self, c): self.c = c
         class Bar(object): pass
         class Bah(object):
             def __init__(self, c, d):
                 self.c = c; self.d = d
 
         class A(HasTraitlets):
             inst = Instance(Foo, (10,))
         a = A()
         self.assertEquals(a.inst.c, 10)
 
         class B(HasTraitlets):
             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):
             inst = Instance(Foo)
         c = C()
         self.assert_(c.inst is None)
 
     def test_bad_default(self):
         class Foo(object): pass
 
         class A(HasTraitlets):
             inst = Instance(Foo, allow_none=False)
         
         self.assertRaises(TraitletError, A)
 
     def test_instance(self):
         class Foo(object): pass
 
         def inner():
             class A(HasTraitlets):
                 inst = Instance(Foo())
         
         self.assertRaises(TraitletError, inner)
 
 
 class TestThis(TestCase):
 
     def test_this_class(self):
         class Foo(HasTraitlets):
             this = This
 
         f = Foo()
         self.assertEquals(f.this, None)
         g = Foo()
         f.this = g
         self.assertEquals(f.this, g)
         self.assertRaises(TraitletError, setattr, f, 'this', 10)
 
     def test_this_inst(self):
         class Foo(HasTraitlets):
             this = This()
         
         f = Foo()
         f.this = Foo()
         self.assert_(isinstance(f.this, Foo))
 
     def test_subclass(self):
         class Foo(HasTraitlets):
             t = This()
         class Bar(Foo):
             pass
         f = Foo()
         b = Bar()
         f.t = b
         b.t = f
         self.assertEquals(f.t, b)
         self.assertEquals(b.t, f)
 
     def test_subclass_override(self):
         class Foo(HasTraitlets):
             t = This()
         class Bar(Foo):
             t = This()
         f = Foo()
         b = Bar()
         f.t = b
         self.assertEquals(f.t, b)
         self.assertRaises(TraitletError, setattr, b, 't', f)
 
 class TraitletTestBase(TestCase):
     """A best testing class for basic traitlet types."""
 
     def assign(self, value):
         self.obj.value = value
 
     def coerce(self, value):
         return value
 
     def test_good_values(self):
         if hasattr(self, '_good_values'):
             for value in self._good_values:
                 self.assign(value)
                 self.assertEquals(self.obj.value, self.coerce(value))
 
     def test_bad_values(self):
         if hasattr(self, '_bad_values'):
             for value in self._bad_values:
                 self.assertRaises(TraitletError, self.assign, value)
 
     def test_default_value(self):
         if hasattr(self, '_default_value'):
             self.assertEquals(self._default_value, self.obj.value)
 
 
 class AnyTraitlet(HasTraitlets):
 
     value = Any
 
 class AnyTraitTest(TraitletTestBase):
 
     obj = AnyTraitlet()
 
     _default_value = None
     _good_values   = [10.0, 'ten', u'ten', [10], {'ten': 10},(10,), None, 1j]
     _bad_values    = []
 
 
 class IntTraitlet(HasTraitlets):
 
     value = Int(99)
 
 class TestInt(TraitletTestBase):
 
     obj = IntTraitlet()
     _default_value = 99
     _good_values   = [10, -10]
     _bad_values    = ['ten', u'ten', [10], {'ten': 10},(10,), None, 1j, 10L,
                       -10L, 10.1, -10.1, '10L', '-10L', '10.1', '-10.1', u'10L',
                       u'-10L', u'10.1', u'-10.1',  '10', '-10', u'10', u'-10']
 
 
 class LongTraitlet(HasTraitlets):
 
     value = Long(99L)
 
 class TestLong(TraitletTestBase):
 
     obj = LongTraitlet()
 
     _default_value = 99L
     _good_values   = [10, -10, 10L, -10L]
     _bad_values    = ['ten', u'ten', [10], [10l], {'ten': 10},(10,),(10L,),
                       None, 1j, 10.1, -10.1, '10', '-10', '10L', '-10L', '10.1',
                       '-10.1', u'10', u'-10', u'10L', u'-10L', u'10.1',
                       u'-10.1']
 
 
 class FloatTraitlet(HasTraitlets):
 
     value = Float(99.0)
 
 class TestFloat(TraitletTestBase):
 
     obj = FloatTraitlet()
 
     _default_value = 99.0
     _good_values   = [10, -10, 10.1, -10.1]
     _bad_values    = [10L, -10L, 'ten', u'ten', [10], {'ten': 10},(10,), None,
                       1j, '10', '-10', '10L', '-10L', '10.1', '-10.1', u'10',
                       u'-10', u'10L', u'-10L', u'10.1', u'-10.1']
 
 
 class ComplexTraitlet(HasTraitlets):
 
     value = Complex(99.0-99.0j)
 
 class TestComplex(TraitletTestBase):
 
     obj = ComplexTraitlet()
 
     _default_value = 99.0-99.0j
     _good_values   = [10, -10, 10.1, -10.1, 10j, 10+10j, 10-10j, 
                       10.1j, 10.1+10.1j, 10.1-10.1j]
     _bad_values    = [10L, -10L, u'10L', u'-10L', 'ten', [10], {'ten': 10},(10,), None]
 
 
 class StringTraitlet(HasTraitlets):
 
     value = Str('string')
 
 class TestString(TraitletTestBase):
 
     obj = StringTraitlet()
 
     _default_value = 'string'
     _good_values   = ['10', '-10', '10L',
                       '-10L', '10.1', '-10.1', 'string']
     _bad_values    = [10, -10, 10L, -10L, 10.1, -10.1, 1j, [10],
                       ['ten'],{'ten': 10},(10,), None,  u'string']
 
 
 class UnicodeTraitlet(HasTraitlets):
 
     value = Unicode(u'unicode')
 
 class TestUnicode(TraitletTestBase):
 
     obj = UnicodeTraitlet()
 
     _default_value = u'unicode'
     _good_values   = ['10', '-10', '10L', '-10L', '10.1', 
                       '-10.1', '', u'', 'string', u'string', ]
     _bad_values    = [10, -10, 10L, -10L, 10.1, -10.1, 1j,
                       [10], ['ten'], [u'ten'], {'ten': 10},(10,), None]

IPython/utils/traitlets.py

@@ -1,798 +1,858 b''
 #!/usr/bin/env python
 # encoding: utf-8
 """
 A lightweight Traits like module.
 
 This is designed to provide a lightweight, simple, pure Python version of
 many of the capabilities of enthought.traits.  This includes:
 
 * Validation
 * Type specification with defaults
 * Static and dynamic notification
 * Basic predefined types
 * An API that is similar to enthought.traits
 
 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
   contents change.
 * API compatibility with enthought.traits
 
 There are also some important difference in our design:
 
 * enthought.traits does not validate default values.  We do.
 
 We choose to create this module because we need these capabilities, but
 we need them to be pure Python so they work in all Python implementations,
 including Jython and IronPython.
 
 Authors:
 
 * Brian Granger
 * Enthought, Inc.  Some of the code in this file comes from enthought.traits
   and is licensed under the BSD license.  Also, many of the ideas also come
   from enthought.traits even though our implementation is very different.
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2009  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 
 import inspect
 import sys
 import types
-from types import InstanceType, ClassType
+from types import InstanceType, ClassType, FunctionType
 
 ClassTypes = (ClassType, type)
 
 #-----------------------------------------------------------------------------
 # Basic classes
 #-----------------------------------------------------------------------------
 
 
 class NoDefaultSpecified ( object ): pass
 NoDefaultSpecified = NoDefaultSpecified()
 
 
 class Undefined ( object ): pass
 Undefined = Undefined()
 
 
 class TraitletError(Exception):
     pass
 
 
 #-----------------------------------------------------------------------------
 # Utilities
 #-----------------------------------------------------------------------------
 
 
 def class_of ( object ):
     """ Returns a string containing the class name of an object with the
     correct indefinite article ('a' or 'an') preceding it (e.g., 'an Image',
     'a PlotValue').
     """
     if isinstance( object, basestring ):
         return add_article( object )
 
     return add_article( object.__class__.__name__ )
 
 
 def add_article ( name ):
     """ Returns a string containing the correct indefinite article ('a' or 'an')
     prefixed to the specified string.
     """
     if name[:1].lower() in 'aeiou':
        return 'an ' + name
 
     return 'a ' + name
 
 
 def repr_type(obj):
     """ Return a string representation of a value and its type for readable
     error messages.
     """
     the_type = type(obj)
     if the_type is InstanceType:
         # Old-style class.
         the_type = obj.__class__
     msg = '%r %r' % (obj, the_type)
     return msg
 
 
 def parse_notifier_name(name):
     """Convert the name argument to a list of names.
     
     Examples
     --------
     
     >>> parse_notifier_name('a')
     ['a']
     >>> parse_notifier_name(['a','b'])
     ['a', 'b']
     >>> parse_notifier_name(None)
     ['anytraitlet']
     """
     if isinstance(name, str):
         return [name]
     elif name is None:
         return ['anytraitlet']
     elif isinstance(name, (list, tuple)):
         for n in name:
             assert isinstance(n, str), "names must be strings"
         return name
 
+
+class _SimpleTest:
+    def __init__ ( self, value ): self.value = value
+    def __call__ ( self, test  ):
+        print test, self.value 
+        return test == self.value
+    def __repr__(self):
+        return "<SimpleTest(%r)" % self.value
+    def __str__(self):
+        return self.__repr__()
+
+
 #-----------------------------------------------------------------------------
 # Base TraitletType for all traitlets
 #-----------------------------------------------------------------------------
 
 
 class TraitletType(object):
     """A base class for all traitlet descriptors.
 
     Notes
     -----
     Our implementation of traitlets 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`
     class that does the following:
 
     1. Sets the :attr:`name` attribute of every :class:`TraitletType`
        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
        accept superclasses for :class:`This` values.
     """
     
 
     metadata = {}
     default_value = Undefined
     info_text = 'any value'
 
     def __init__(self, default_value=NoDefaultSpecified, **metadata):
         """Create a TraitletType.
         """
         if default_value is not NoDefaultSpecified:
             self.default_value = default_value
-        self.metadata.update(metadata)
+
+        if len(metadata) > 0:
+            if len(self.metadata) > 0:
+                self._metadata = self.metadata.copy()
+                self._metadata.update(metadata)
+            else:
+                self._metadata = metadata
+        else:
+            self._metadata = self.metadata
+
         self.init()
 
     def init(self):
         pass
 
     def get_default_value(self):
         """Create a new instance of the default value."""
         dv = self.default_value
         return dv
 
     def set_default_value(self, obj):
         dv = self.get_default_value()
         newdv = self._validate(obj, dv)
         obj._traitlet_values[self.name] = newdv
         
 
     def __get__(self, obj, cls=None):
         """Get the value of the traitlet by self.name for the instance.
 
         Default values are instantiated when :meth:`HasTraitlets.__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.
         """
         if obj is None:
             return self
         else:
             try:
                 value = obj._traitlet_values[self.name]
             except:
                 # HasTraitlets should call set_default_value to populate
                 # this.  So this should never be reached.
                 raise TraitletError('Unexpected error in TraitletType: '
                                     'default value not set properly')
             else:
                 return value
 
     def __set__(self, obj, value):
         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)
 
     def _validate(self, obj, value):
         if hasattr(self, 'validate'):
             return self.validate(obj, value)
         elif hasattr(self, 'is_valid_for'):
             valid = self.is_valid_for(value)
             if valid:
                 return value
             else:
                 raise TraitletError('invalid value for type: %r' % value)
         elif hasattr(self, 'value_for'):
             return self.value_for(value)
         else:
             return value
 
     def info(self):
         return self.info_text
 
     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." \
                 % (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." \
                 % (self.name, self.info(), repr_type(value))            
         raise TraitletError(e)
 
+    def get_metadata(self, key):
+        return getattr(self, '_metadata', {}).get(key, None)
+
+    def set_metadata(self, key, value):
+        getattr(self, '_metadata', {})[key] = value
+
 
 #-----------------------------------------------------------------------------
 # The HasTraitlets implementation
 #-----------------------------------------------------------------------------
 
 
 class MetaHasTraitlets(type):
     """A metaclass for HasTraitlets.
     
     This metaclass makes sure that any TraitletType class attributes are
     instantiated and sets their name attribute.
     """
     
     def __new__(mcls, name, bases, classdict):
         """Create the HasTraitlets class.
         
         This instantiates all TraitletTypes in the class dict and sets their
         :attr:`name` attribute.
         """
         # print "========================="
         # print "MetaHasTraitlets.__new__"
         # print "mcls, ", mcls
         # print "name, ", name
         # print "bases, ", bases
         # print "classdict, ", classdict
         for k,v in classdict.iteritems():
             if isinstance(v, TraitletType):
                 v.name = k
             elif inspect.isclass(v):
                 if issubclass(v, TraitletType):
                     vinst = v()
                     vinst.name = k
                     classdict[k] = vinst
         return super(MetaHasTraitlets, mcls).__new__(mcls, name, bases, classdict)
 
     def __init__(cls, name, bases, classdict):
         """Finish initializing the HasTraitlets class.
         
         This sets the :attr:`this_class` attribute of each TraitletType in the
         class dict to the newly created class ``cls``.
         """
         # print "========================="
         # print "MetaHasTraitlets.__init__"
         # print "cls, ", cls
         # print "name, ", name
         # print "bases, ", bases
         # print "classdict, ", classdict
         for k, v in classdict.iteritems():
             if isinstance(v, TraitletType):
                 v.this_class = cls
         super(MetaHasTraitlets, cls).__init__(name, bases, classdict)
 
 class HasTraitlets(object):
 
     __metaclass__ = MetaHasTraitlets
 
     def __new__(cls, *args, **kw):
         inst = super(HasTraitlets, cls).__new__(cls, *args, **kw)
         inst._traitlet_values = {}
         inst._traitlet_notifiers = {}
         # Here we tell all the TraitletType instances to set their default
         # values on the instance. 
         for key in dir(cls):
             value = getattr(cls, key)
             if isinstance(value, TraitletType):
-                # print 'value: ', value
                 value.set_default_value(inst)
         return inst
 
     # def __init__(self):
     #     self._traitlet_values = {}
     #     self._traitlet_notifiers = {}
 
     def _notify_traitlet(self, name, old_value, new_value):
 
         # First dynamic ones
         callables = self._traitlet_notifiers.get(name,[])
         more_callables = self._traitlet_notifiers.get('anytraitlet',[])
         callables.extend(more_callables)
 
         # Now static ones
         try:
             cb = getattr(self, '_%s_changed' % name)
         except:
             pass
         else:
             callables.append(cb)
 
         # Call them all now
         for c in callables:
             # Traits catches and logs errors here.  I allow them to raise
             if callable(c):
                 argspec = inspect.getargspec(c)
                 nargs = len(argspec[0])
                 # Bound methods have an additional 'self' argument
                 # I don't know how to treat unbound methods, but they
                 # can't really be used for callbacks.
                 if isinstance(c, types.MethodType):
                     offset = -1
                 else:
                     offset = 0
                 if nargs + offset == 0:
                     c()
                 elif nargs + offset == 1:
                     c(name)
                 elif nargs + offset == 2:
                     c(name, new_value)
                 elif nargs + offset == 3:
                     c(name, old_value, new_value)
                 else:
                     raise TraitletError('a traitlet changed callback '
                                         'must have 0-3 arguments.')
             else:
                 raise TraitletError('a traitlet changed callback '
                                     'must be callable.')
                 
 
     def _add_notifiers(self, handler, name):
         if not self._traitlet_notifiers.has_key(name):
             nlist = []
             self._traitlet_notifiers[name] = nlist
         else:
             nlist = self._traitlet_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]
             try:
                 index = nlist.index(handler)
             except ValueError:
                 pass
             else:
                 del nlist[index]
 
     def on_traitlet_change(self, handler, name=None, remove=False):
         """Setup a handler to be called when a traitlet changes.
 
         This is used to setup dynamic notifications of traitlet 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
         _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 
                 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
                 of str, handler will apply to all names in the list.  If a
                 str, the handler will apply just to that name.
             remove : bool
                 If False (the default), then install the handler.  If True
                 then unintall it.
         """
         if remove:
             names = parse_notifier_name(name)
             for n in names:
                 self._remove_notifiers(handler, n)
         else:
             names = parse_notifier_name(name)
             for n in names:
                 self._add_notifiers(handler, n)
 
-    def traitlet_names(self):
+    def traitlet_names(self, **metadata):
         """Get a list of all the names of this classes traitlets."""
-        return [memb[0] for memb in inspect.getmembers(self.__class__) if isinstance(memb[1], TraitletType)]
+        return self.traitlets(**metadata).keys()
 
+    def traitlets(self, **metadata):
+        """Get a list of all the traitlets of this class.
+
+        The TraitletTypes returned don't know anything about the values
+        that the various HasTraitlet's instances are holding.
+        """
+        traitlets = dict([memb for memb in inspect.getmembers(self.__class__) if \
+                     isinstance(memb[1], TraitletType)])
+        if len(metadata) == 0:
+            return traitlets
+
+        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 meta_name, meta_eval in metadata.items():
+                if not meta_eval(traitlet.get_metadata(meta_name)):
+                    break
+            else:
+                result[name] = traitlet
+
+        return result
+
+    def traitlet_metadata(self, traitletname, key):
+        """Get metadata values for traitlet by key."""
+        try:
+            traitlet = getattr(self.__class__, traitletname)
+        except AttributeError:
+            raise TraitletError("Class %s does not have a traitlet named %s" %
+                                (self.__class__.__name__, traitletname))
+        else:
+            return traitlet.get_metadata(key)
 
 #-----------------------------------------------------------------------------
 # Actual TraitletTypes implementations/subclasses
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # TraitletTypes subclasses for handling classes and instances of classes
 #-----------------------------------------------------------------------------
 
 
 class ClassBasedTraitletType(TraitletType):
     """A traitlet with error reporting for Type, Instance and This."""
 
     def error(self, obj, value):
         kind = type(value)
         if kind is InstanceType:
             msg = 'class %s' % value.__class__.__name__
         else:
             msg = '%s (i.e. %s)' % ( str( kind )[1:-1], repr( value ) )
 
         super(ClassBasedTraitletType, self).error(obj, msg)
 
 
 class Type(ClassBasedTraitletType):
     """A traitlet 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
 
         A Type traitlet specifies that its values must be subclasses of
         a particular class.
 
         Parameters
         ----------
         default_value : class
             The default value must be a subclass of klass.
         klass : class, str, None
             Values of this traitlet must be a subclass of klass.  The klass
             may be specified in a string like: 'foo.bar.MyClass'.
         allow_none : boolean
             Indicates whether None is allowed as an assignable value. Even if
             ``False``, the default value may be ``None``.
         """
         if default_value is None:
             if klass is None:
                 klass = object
         elif klass is None:
             klass = default_value
 
         if not inspect.isclass(klass):
             raise TraitletError("A Type traitlet must specify a class.")
 
         self.klass       = klass
         self._allow_none = allow_none
 
         super(Type, self).__init__(default_value, **metadata)
 
     def validate(self, obj, value):
         """Validates that the value is a valid object instance."""
         try:
             if issubclass(value, self.klass):
                 return value
         except:
             if (value is None) and (self._allow_none):
                 return value
 
         self.error(obj, value)
 
     def info(self):
         """ Returns a description of the trait."""
         klass = self.klass.__name__
         result = 'a subclass of ' + klass
         if self._allow_none:
             return result + ' or None'
         return result
 
 
 class DefaultValueGenerator(object):
     """A class for generating new default value instances."""
 
     def __init__(self, klass, *args, **kw):
         self.klass = klass
         self.args = args
         self.kw = kw
 
     def generate(self):
         return self.klass(*self.args, **self.kw)
 
 
 class Instance(ClassBasedTraitletType):
     """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.
     """
 
     def __init__(self, klass=None, args=None, kw=None, 
                  allow_none=True, **metadata ):
         """Construct an Instance traitlet.
 
         This traitlet 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.
 
         Parameters
         ----------
         klass : class
             The class that forms the basis for the traitlet.  Instances
             and strings are not allowed.
         args : tuple
             Positional arguments for generating the default value.
         kw : dict
             Keyword arguments for generating the default value.
         allow_none : bool
             Indicates whether None is allowed as a value.
 
         Default Value
         -------------
         If both ``args`` and ``kw`` are None, then the default value is None.
         If ``args`` is a tuple and ``kw`` is a dict, then the default is
         created as ``klass(*args, **kw)``.  If either ``args`` or ``kw`` is 
         not (but not both), None is replace by ``()`` or ``{}``.
         """
 
         self._allow_none = allow_none
 
         if (klass is None) or (not inspect.isclass(klass)):
             raise TraitletError('The klass argument must be a class'
                                 ' you gave: %r' % klass)
         self.klass = klass
         
         # self.klass is a class, so handle default_value
         if args is None and kw is None:
             default_value = None
         else:
             if args is None:
                 # kw is not None
                 args = ()
             elif kw is None:
                 # args is not None
                 kw = {}
         
             if not isinstance(kw, dict):
                 raise TraitletError("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.")
             
             default_value = DefaultValueGenerator(self.klass, *args, **kw)
 
         super(Instance, self).__init__(default_value, **metadata)
 
     def validate(self, obj, value):
         if value is None:
             if self._allow_none:
                 return value
             self.error(obj, value)
 
         if isinstance(value, self.klass):
             return value
         else:
             self.error(obj, value)
 
     def info(self):
         klass = self.klass.__name__
         result = class_of(klass)
         if self._allow_none:
             return result + ' or None'
 
         return result
 
     def get_default_value(self):
         """Instantiate a default value instance.
         
         This is called when the containing HasTraitlets classes'
         :meth:`__new__` method is called to ensure that a unique instance
         is created for each HasTraitlets instance.
         """
         dv  = self.default_value
         if isinstance(dv, DefaultValueGenerator):
             return dv.generate()
         else:
             return dv
 
 
 class This(ClassBasedTraitletType):
     """A traitlet 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 
     always validate default values, ``allow_none`` is *always* true.
     """
 
     info_text = 'an instance of the same type as the receiver or None'
 
     def __init__(self, **metadata):
         super(This, self).__init__(None, **metadata)
 
     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.
         if isinstance(value, self.this_class) or (value is None):
             return value
         else:
             self.error(obj, value)
 
 
 #-----------------------------------------------------------------------------
 # Basic TraitletTypes implementations/subclasses
 #-----------------------------------------------------------------------------
 
 
 class Any(TraitletType):
     default_value = None
     info_text = 'any value'
 
 
 class Int(TraitletType):
     """A integer traitlet."""
 
     evaluate = int
     default_value = 0
     info_text = 'an integer'
 
     def validate(self, obj, value):
         if isinstance(value, int):
             return value
         self.error(obj, value)
 
 class CInt(Int):
     """A casting version of the int traitlet."""
 
     def validate(self, obj, value):
         try:
             return int(value)
         except:
             self.error(obj, value)
 
 
 class Long(TraitletType):
     """A long integer traitlet."""
 
     evaluate = long
     default_value = 0L
     info_text = 'a long'
 
     def validate(self, obj, value):
         if isinstance(value, long):
             return value
         if isinstance(value, int):
             return long(value)
         self.error(obj, value)
 
 
 class CLong(Long):
     """A casting version of the long integer traitlet."""
 
     def validate(self, obj, value):
         try:
             return long(value)
         except:
             self.error(obj, value)
 
 
 class Float(TraitletType):
     """A float traitlet."""
 
     evaluate = float
     default_value = 0.0
     info_text = 'a float'
 
     def validate(self, obj, value):
         if isinstance(value, float):
             return value
         if isinstance(value, int):
             return float(value)
         self.error(obj, value)
 
 
 class CFloat(Float):
     """A casting version of the float traitlet."""
 
     def validate(self, obj, value):
         try:
             return float(value)
         except:
             self.error(obj, value)
 
 class Complex(TraitletType):
     """A traitlet for complex numbers."""
 
     evaluate = complex
     default_value = 0.0 + 0.0j
     info_text = 'a complex number'
 
     def validate(self, obj, value):
         if isinstance(value, complex):
             return value
         if isinstance(value, (float, int)):
             return complex(value)
         self.error(obj, value)
 
 
 class CComplex(Complex):
     """A casting version of the complex number traitlet."""
 
     def validate (self, obj, value):
         try:
             return complex(value)
         except:
             self.error(obj, value)
 
 
 class Str(TraitletType):
     """A traitlet for strings."""
 
     evaluate = lambda x: x
     default_value = ''
     info_text = 'a string'
 
     def validate(self, obj, value):
         if isinstance(value, str):
             return value
         self.error(obj, value)
 
 
 class CStr(Str):
     """A casting version of the string traitlet."""
 
     def validate(self, obj, value):
         try:
             return str(value)
         except:
             try:
                 return unicode(value)
             except:
                 self.error(obj, value)
 
 
 class Unicode(TraitletType):
     """A traitlet for unicode strings."""
 
     evaluate = unicode
     default_value = u''
     info_text = 'a unicode string'
 
     def validate(self, obj, value):
         if isinstance(value, unicode):
             return value
         if isinstance(value, str):
             return unicode(value)
         self.error(obj, value)
 
 
 class CUnicode(Unicode):
     """A casting version of the unicode traitlet."""
 
     def validate(self, obj, value):
         try:
             return unicode(value)
         except:
             self.error(obj, value)
 
 
 class Bool(TraitletType):
     """A boolean (True, False) traitlet."""
     evaluate = bool
     default_value = False
     info_text = 'a boolean'
 
     def validate(self, obj, value):
         if isinstance(value, bool):
             return value
         self.error(obj, value)
 
 
 class CBool(Bool):
     """A casting version of the boolean traitlet."""
 
     def validate(self, obj, value):
         try:
             return bool(value)
         except:
             self.error(obj, value)
  No newline at end of file