fix(traits): avoid redefining Either and Tuple and new test-cases

Author: oesteban

nipype/interfaces/base/tests/test_traits_extension.py

@@ -13,10 +13,13 @@ class _test_spec(nib.TraitedSpec):
     c = nib.traits.List(nib.File())
     d = nib.Either(nib.File(), nib.traits.Float())
     e = nib.OutputMultiObject(nib.File())
+    ee = nib.OutputMultiObject(nib.Str)
     f = nib.traits.Dict(nib.Str, nib.File())
     g = nib.Either(nib.File, nib.Str)
     h = nib.Str
-    ee = nib.OutputMultiObject(nib.Str)
+    i = nib.Either(nib.File, nib.Tuple(nib.File, nib.traits.Int))
+    j = nib.Either(nib.File, nib.Tuple(nib.File, nib.traits.Int),
+                   nib.traits.Dict(nib.Str, nib.File()))
 
 
 def test_rebase_path_traits():
@@ -58,6 +61,11 @@ def test_rebase_path_traits():
         '/some/path')
     assert e == [[Path('f1.txt'), Path('f2.txt')], [[Path('f3.txt')]]]
 
+    ee = rebase_path_traits(
+        spec.trait('ee'), [['/some/path/f1.txt', '/some/path/f2.txt'], [['/some/path/f3.txt']]],
+        '/some/path')
+    assert ee == [['/some/path/f1.txt', '/some/path/f2.txt'], [['/some/path/f3.txt']]]
+
     f = rebase_path_traits(
         spec.trait('f'), {'1': '/some/path/f1.txt'}, '/some/path')
     assert f == {'1': Path('f1.txt')}
@@ -79,10 +87,21 @@ def test_rebase_path_traits():
     h = rebase_path_traits(spec.trait('h'), '2', '/some/path')
     assert h == '2'
 
-    ee = rebase_path_traits(
-        spec.trait('ee'), [['/some/path/f1.txt', '/some/path/f2.txt'], [['/some/path/f3.txt']]],
-        '/some/path')
-    assert ee == [['/some/path/f1.txt', '/some/path/f2.txt'], [['/some/path/f3.txt']]]
+    i = rebase_path_traits(spec.trait('i'), '/some/path/either/file.txt', '/some/path')
+    assert '%s' % i == 'either/file.txt'
+
+    i = rebase_path_traits(spec.trait('i'), ('/some/path/either/tuple/file.txt', 2), '/some/path')
+    assert ('%s' % i[0], i[1]) == ('either/tuple/file.txt', 2)
+
+    j = rebase_path_traits(spec.trait('j'), '/some/path/either/file.txt', '/some/path')
+    assert '%s' % j == 'either/file.txt'
+
+    j = rebase_path_traits(spec.trait('j'), ('/some/path/either/tuple/file.txt', 2), '/some/path')
+    assert ('%s' % j[0], j[1]) == ('either/tuple/file.txt', 2)
+
+    j = rebase_path_traits(spec.trait('j'), {'a': '/some/path/either/dict/file.txt'},
+                           '/some/path')
+    assert j == {'a': Path('either/dict/file.txt')}
 
 
 def test_resolve_path_traits():

nipype/interfaces/base/traits_extension.py

@@ -471,36 +471,12 @@ class InputMultiObject(MultiObject):
 OutputMultiPath = OutputMultiObject
 
 
-class Tuple(traits.BaseTuple):
-    """Defines a new type of Tuple trait that reports inner types."""
-
-    def init_fast_validator(self, *args):
-        """Set up the C-level fast validator."""
-        super(Tuple, self).init_fast_validator(*args)
-        self.fast_validate = args
-
-    def inner_traits(self):
-        """Return the *inner trait* (or traits) for this trait."""
-        return self.types
-
-
-class Either(TraitType):
-    """Defines a trait whose value can be any of of a specified list of traits."""
-
-    def __init__(self, *traits, **metadata):
-        """Create a trait whose value can be any of of a specified list of traits."""
-        _either_traits = tuple(trait_from(t) for t in traits)
-        self.trait_maker = _TraitMaker(
-            metadata.pop("default", None), *traits, **metadata)
-        self.either_traits = _either_traits
+class Tuple(traits.Tuple):
+    pass
 
-    def as_ctrait(self):
-        """Return a CTrait corresponding to the trait defined by this class."""
-        return self.trait_maker.as_ctrait()
 
-    def inner_traits(self):
-        """Return the *inner trait* (or traits) for this trait."""
-        return self.either_traits
+class Either(traits.Either):
+    pass
 
 
 traits.Tuple = Tuple
@@ -548,22 +524,22 @@ def _recurse_on_path_traits(func, thistrait, value, cwd):
 
         value = [_recurse_on_path_traits(func, innertrait, v, cwd)
                  for v in value]
-    elif thistrait.is_trait_type(traits.Dict):
+    elif isinstance(value, dict) and thistrait.is_trait_type(traits.Dict):
         _, innertrait = thistrait.inner_traits
         value = {k: _recurse_on_path_traits(func, innertrait, v, cwd)
                  for k, v in value.items()}
-    elif thistrait.is_trait_type(Tuple):
+    elif isinstance(value, tuple) and thistrait.is_trait_type(Tuple):
         value = tuple([_recurse_on_path_traits(func, subtrait, v, cwd)
-                       for subtrait, v in zip(thistrait.inner_traits, value)])
-    elif thistrait.is_trait_type(Either):
-        is_str = [f.is_trait_type((traits.String, traits.BaseStr, traits.BaseBytes, Str))
-                  for f in thistrait.inner_traits]
+                       for subtrait, v in zip(thistrait.handler.types, value)])
+    elif thistrait.is_trait_type(traits.TraitCompound):
+        is_str = [isinstance(f, (traits.String, traits.BaseStr, traits.BaseBytes, Str))
+                  for f in thistrait.handler.handlers]
         if any(is_str) and isinstance(value, (bytes, str)) and not value.startswith('/'):
             return value
-        is_basepath = [f.is_trait_type(BasePath) for f in thistrait.inner_traits]
-        if any(is_basepath):
-            subtrait = thistrait.inner_traits[is_basepath.index(True)]
-            value = _recurse_on_path_traits(func, subtrait, value, cwd)
+
+        for subtrait in thistrait.handler.handlers:
+            value = _recurse_on_path_traits(func, subtrait(), value, cwd)
+
     return value