Merge pull request #6892 from quantopian/recursive_traits

Better support for recursive/parameterized Traits.

IPython/utils/tests/test_traitlets.py

@@ -20,7 +20,7 b' from IPython.utils.traitlets import ('
     Int, Long, Integer, Float, Complex, Bytes, Unicode, TraitError,
     Undefined, Type, This, Instance, TCPAddress, List, Tuple,
     ObjectName, DottedObjectName, CRegExp, link, directional_link,
-    EventfulList, EventfulDict
+    EventfulList, EventfulDict, ForwardDeclaredType, ForwardDeclaredInstance,
 )
 from IPython.utils import py3compat
 from IPython.testing.decorators import skipif
@@ -684,6 +684,20 b' class TestThis(TestCase):'
         self.assertEqual(f.t, b)
         self.assertRaises(TraitError, setattr, b, 't', f)
 
+    def test_this_in_container(self):
+
+        class Tree(HasTraits):
+            value = Unicode()
+            leaves = List(This())
+
+        tree = Tree(
+            value='foo',
+            leaves=[Tree('bar'), Tree('buzz')]
+        )
+
+        with self.assertRaises(TraitError):
+            tree.leaves = [1, 2]
+
 class TraitTestBase(TestCase):
     """A best testing class for basic trait types."""
 
@@ -1306,3 +1320,103 b' class TestEventful(TestCase):'
 
         # Is the output correct?
         self.assertEqual(a.x, {c: c for c in 'bz'})
+
+###
+# Traits for Forward Declaration Tests
+###
+class ForwardDeclaredInstanceTrait(HasTraits):
+
+    value = ForwardDeclaredInstance('ForwardDeclaredBar')
+
+class ForwardDeclaredTypeTrait(HasTraits):
+
+    value = ForwardDeclaredType('ForwardDeclaredBar')
+
+class ForwardDeclaredInstanceListTrait(HasTraits):
+
+    value = List(ForwardDeclaredInstance('ForwardDeclaredBar'))
+
+class ForwardDeclaredTypeListTrait(HasTraits):
+
+    value = List(ForwardDeclaredType('ForwardDeclaredBar'))
+###
+# End Traits for Forward Declaration Tests
+###
+
+###
+# Classes for Forward Declaration Tests
+###
+class ForwardDeclaredBar(object):
+    pass
+
+class ForwardDeclaredBarSub(ForwardDeclaredBar):
+    pass
+###
+# End Classes for Forward Declaration Tests
+###
+
+###
+# Forward Declaration Tests
+###
+class TestForwardDeclaredInstanceTrait(TraitTestBase):
+
+    obj = ForwardDeclaredInstanceTrait()
+    _default_value = None
+    _good_values = [None, ForwardDeclaredBar(), ForwardDeclaredBarSub()]
+    _bad_values = ['foo', 3, ForwardDeclaredBar, ForwardDeclaredBarSub]
+
+class TestForwardDeclaredTypeTrait(TraitTestBase):
+
+    obj = ForwardDeclaredTypeTrait()
+    _default_value = None
+    _good_values = [None, ForwardDeclaredBar, ForwardDeclaredBarSub]
+    _bad_values = ['foo', 3, ForwardDeclaredBar(), ForwardDeclaredBarSub()]
+
+class TestForwardDeclaredInstanceList(TraitTestBase):
+
+    obj = ForwardDeclaredInstanceListTrait()
+
+    def test_klass(self):
+        """Test that the instance klass is properly assigned."""
+        self.assertIs(self.obj.traits()['value']._trait.klass, ForwardDeclaredBar)
+
+    _default_value = []
+    _good_values = [
+        [ForwardDeclaredBar(), ForwardDeclaredBarSub(), None],
+        [None],
+        [],
+        None,
+    ]
+    _bad_values = [
+        ForwardDeclaredBar(),
+        [ForwardDeclaredBar(), 3],
+        '1',
+        # Note that this is the type, not an instance.
+        [ForwardDeclaredBar]
+    ]
+
+class TestForwardDeclaredTypeList(TraitTestBase):
+
+    obj = ForwardDeclaredTypeListTrait()
+
+    def test_klass(self):
+        """Test that the instance klass is properly assigned."""
+        self.assertIs(self.obj.traits()['value']._trait.klass, ForwardDeclaredBar)
+
+    _default_value = []
+    _good_values = [
+        [ForwardDeclaredBar, ForwardDeclaredBarSub, None],
+        [],
+        [None],
+        None,
+    ]
+    _bad_values = [
+        ForwardDeclaredBar,
+        [ForwardDeclaredBar, 3],
+        '1',
+        # Note that this is an instance, not the type.
+        [ForwardDeclaredBar()]
+    ]
+###
+# End Forward Declaration Tests
+###

IPython/utils/traitlets.py

@@ -748,7 +748,16 b' class HasTraits(py3compat.with_metaclass(MetaHasTraits, object)):'
 
 
 class ClassBasedTraitType(TraitType):
-    """A trait with error reporting for Type, Instance and This."""
+    """
+    A trait with error reporting and string -> type resolution for Type,
+    Instance and This.
+    """
+
+    def _resolve_string(self, string):
+        """
+        Resolve a string supplied for a type into an actual object.
+        """
+        return import_item(string)
 
     def error(self, obj, value):
         kind = type(value)
@@ -813,7 +822,7 b' class Type(ClassBasedTraitType):'
         """Validates that the value is a valid object instance."""
         if isinstance(value, py3compat.string_types):
             try:
-                value = import_item(value)
+                value = self._resolve_string(value)
             except ImportError:
                 raise TraitError("The '%s' trait of %s instance must be a type, but "
                                 "%r could not be imported" % (self.name, obj, value))
@@ -842,9 +851,9 b' class Type(ClassBasedTraitType):'
 
     def _resolve_classes(self):
         if isinstance(self.klass, py3compat.string_types):
-            self.klass = import_item(self.klass)
+            self.klass = self._resolve_string(self.klass)
         if isinstance(self.default_value, py3compat.string_types):
-            self.default_value = import_item(self.default_value)
+            self.default_value = self._resolve_string(self.default_value)
 
     def get_default_value(self):
         return self.default_value
@@ -951,7 +960,7 b' class Instance(ClassBasedTraitType):'
 
     def _resolve_classes(self):
         if isinstance(self.klass, py3compat.string_types):
-            self.klass = import_item(self.klass)
+            self.klass = self._resolve_string(self.klass)
 
     def get_default_value(self):
         """Instantiate a default value instance.
@@ -967,6 +976,33 b' class Instance(ClassBasedTraitType):'
             return dv
 
 
+class ForwardDeclaredMixin(object):
+    """
+    Mixin for forward-declared versions of Instance and Type.
+    """
+    def _resolve_string(self, string):
+        """
+        Find the specified class name by looking for it in the module in which
+        our this_class attribute was defined.
+        """
+        modname = self.this_class.__module__
+        return import_item('.'.join([modname, string]))
+
+
+class ForwardDeclaredType(ForwardDeclaredMixin, Type):
+    """
+    Forward-declared version of Type.
+    """
+    pass
+
+
+class ForwardDeclaredInstance(ForwardDeclaredMixin, Instance):
+    """
+    Forward-declared version of Instance.
+    """
+    pass
+
+
 class This(ClassBasedTraitType):
     """A trait for instances of the class containing this trait.
 
@@ -1354,8 +1390,10 b' class Container(Instance):'
         return self.klass(validated)
 
     def instance_init(self, obj):
-        if isinstance(self._trait, Instance):
-            self._trait._resolve_classes()
+        if isinstance(self._trait, TraitType):
+            self._trait.this_class = self.this_class
+        if hasattr(self._trait, 'instance_init'):
+            self._trait.instance_init(obj)
         super(Container, self).instance_init(obj)