enh: added output versioning as well

Author: satra

nipype/interfaces/base.py

@@ -823,29 +823,35 @@ def _check_mandatory_inputs(self):
                                              transient=None).items():
             self._check_requires(spec, name, getattr(self.inputs, name))
 
-    def _check_input_version_requirements(self):
+    def _check_version_requirements(self, trait_object, raise_exception=True):
         """ Raises an exception on version mismatch
         """
+        unavailable_traits = []
         version = LooseVersion(str(self.version))
         if not version:
             return
         # check minimum version
-        names = self.inputs.trait_names(**dict(min_ver=lambda t: t is not None))
+        names = trait_object.trait_names(**dict(min_ver=lambda t: t is not None))
         for name in names:
-            if not isdefined(getattr(self.inputs, name)):
-                continue
-            min_ver = LooseVersion(str(self.inputs.traits()[name].min_ver))
+            min_ver = LooseVersion(str(trait_object.traits()[name].min_ver))
             if min_ver > version:
-                raise Exception('Input %s (%s) (version %s < required %s)' %
+                unavailable_traits.append(name)
+                if not isdefined(getattr(trait_object, name)):
+                    continue
+                if raise_exception:
+                    raise Exception('Trait %s (%s) (version %s < required %s)' %
                               (name, self.__class__.__name__, version, min_ver))
-        names = self.inputs.trait_names(**dict(max_ver=lambda t: t is not None))
+        names = trait_object.trait_names(**dict(max_ver=lambda t: t is not None))
         for name in names:
-            if not isdefined(getattr(self.inputs, name)):
-                continue
-            max_ver = LooseVersion(str(self.inputs.traits()[name].max_ver))
+            max_ver = LooseVersion(str(trait_object.traits()[name].max_ver))
             if max_ver < version:
-                raise Exception('Input %s (%s) (version %s > required %s)' %
+                unavailable_traits.append(name)
+                if not isdefined(getattr(trait_object, name)):
+                    continue
+                if raise_exception:
+                    raise Exception('Trait %s (%s) (version %s > required %s)' %
                               (name, self.__class__.__name__, version, max_ver))
+        return unavailable_traits
 
     def _run_interface(self, runtime):
         """ Core function that executes interface
@@ -869,7 +875,7 @@ def run(self, **inputs):
         """
         self.inputs.set(**inputs)
         self._check_mandatory_inputs()
-        self._check_input_version_requirements()
+        self._check_version_requirements(self.inputs)
         interface = self.__class__
         # initialize provenance tracking
         env = deepcopy(os.environ.data)
@@ -929,9 +935,18 @@ def aggregate_outputs(self, runtime=None, needed_outputs=None):
         predicted_outputs = self._list_outputs()
         outputs = self._outputs()
         if predicted_outputs:
+            _unavailable_outputs = []
+            if outputs:
+                _unavailable_outputs = \
+                               self._check_version_requirements(self._outputs())
             for key, val in predicted_outputs.items():
                 if needed_outputs and key not in needed_outputs:
                     continue
+                if key in _unavailable_outputs:
+                    raise KeyError(('Output trait %s not available in version '
+                                    '%s of interface %s. Please inform '
+                                    'developers.') % (key, self.version,
+                                                      self.__class__.__name__))
                 try:
                     setattr(outputs, key, val)
                     _ = getattr(outputs, key)

nipype/interfaces/tests/test_base.py

@@ -255,80 +255,117 @@ def _run_interface(self, runtime):
     nib.BaseInterface.input_spec = None
     yield assert_raises, Exception, nib.BaseInterface
 
-def test_version():
+def test_input_version():
     class InputSpec(nib.TraitedSpec):
-        foo = nib.traits.Int(desc='a random int', min_ver=0.9)
+        foo = nib.traits.Int(desc='a random int', min_ver='0.9')
     class DerivedInterface1(nib.BaseInterface):
         input_spec = InputSpec
     obj = DerivedInterface1()
     not_raised = True
     try:
-        obj._check_input_version_requirements()
+        obj._check_version_requirements(obj.inputs)
     except:
         not_raised = False
     yield assert_true, not_raised
     config.set('execution', 'stop_on_unknown_version', True)
     try:
-        obj._check_input_version_requirements()
+        obj._check_version_requirements(obj.inputs)
     except:
         not_raised = False
     yield assert_false, not_raised
     config.set_default_config()
     class InputSpec(nib.TraitedSpec):
-        foo = nib.traits.Int(desc='a random int', min_ver=0.9)
+        foo = nib.traits.Int(desc='a random int', min_ver='0.9')
     class DerivedInterface1(nib.BaseInterface):
         input_spec = InputSpec
-        _version = 0.8
+        _version = '0.8'
     obj = DerivedInterface1()
     obj.inputs.foo = 1
-    yield assert_raises, Exception, obj._check_input_version_requirements
+    yield assert_raises, Exception, obj._check_version_requirements
     class InputSpec(nib.TraitedSpec):
-        foo = nib.traits.Int(desc='a random int', min_ver=0.9)
+        foo = nib.traits.Int(desc='a random int', min_ver='0.9')
     class DerivedInterface1(nib.BaseInterface):
         input_spec = InputSpec
-        _version = 0.10
+        _version = '0.10'
     obj = DerivedInterface1()
     not_raised = True
     try:
-        obj._check_input_version_requirements()
+        obj._check_version_requirements(obj.inputs)
     except:
         not_raised = False
     yield assert_true, not_raised
     class InputSpec(nib.TraitedSpec):
-        foo = nib.traits.Int(desc='a random int', min_ver=0.9)
+        foo = nib.traits.Int(desc='a random int', min_ver='0.9')
     class DerivedInterface1(nib.BaseInterface):
         input_spec = InputSpec
-        _version = 0.9
+        _version = '0.9'
     obj = DerivedInterface1()
     obj.inputs.foo = 1
     not_raised = True
     try:
-        obj._check_input_version_requirements()
+        obj._check_version_requirements(obj.inputs)
     except:
         not_raised = False
     yield assert_true, not_raised
     class InputSpec(nib.TraitedSpec):
-        foo = nib.traits.Int(desc='a random int', max_ver=0.7)
+        foo = nib.traits.Int(desc='a random int', max_ver='0.7')
     class DerivedInterface2(nib.BaseInterface):
         input_spec = InputSpec
-        _version = 0.8
+        _version = '0.8'
     obj = DerivedInterface2()
     obj.inputs.foo = 1
-    yield assert_raises, Exception, obj._check_input_version_requirements
+    yield assert_raises, Exception, obj._check_version_requirements
     class InputSpec(nib.TraitedSpec):
-        foo = nib.traits.Int(desc='a random int', max_ver=0.9)
+        foo = nib.traits.Int(desc='a random int', max_ver='0.9')
     class DerivedInterface1(nib.BaseInterface):
         input_spec = InputSpec
-        _version = 0.9
+        _version = '0.9'
     obj = DerivedInterface1()
     obj.inputs.foo = 1
     not_raised = True
     try:
-        obj._check_input_version_requirements()
+        obj._check_version_requirements(obj.inputs)
     except:
         not_raised = False
     yield assert_true, not_raised
 
+def test_output_version():
+    class InputSpec(nib.TraitedSpec):
+        foo = nib.traits.Int(desc='a random int')
+    class OutputSpec(nib.TraitedSpec):
+        foo = nib.traits.Int(desc='a random int', min_ver='0.9')
+    class DerivedInterface1(nib.BaseInterface):
+        input_spec = InputSpec
+        output_spec = OutputSpec
+        _version = '0.10'
+    obj = DerivedInterface1()
+    yield assert_equal, obj._check_version_requirements(obj._outputs()), []
+
+    class InputSpec(nib.TraitedSpec):
+        foo = nib.traits.Int(desc='a random int')
+    class OutputSpec(nib.TraitedSpec):
+        foo = nib.traits.Int(desc='a random int', min_ver='0.11')
+    class DerivedInterface1(nib.BaseInterface):
+        input_spec = InputSpec
+        output_spec = OutputSpec
+        _version = '0.10'
+    obj = DerivedInterface1()
+    yield assert_equal, obj._check_version_requirements(obj._outputs()), ['foo']
+    class InputSpec(nib.TraitedSpec):
+        foo = nib.traits.Int(desc='a random int')
+    class OutputSpec(nib.TraitedSpec):
+        foo = nib.traits.Int(desc='a random int', min_ver='0.11')
+    class DerivedInterface1(nib.BaseInterface):
+        input_spec = InputSpec
+        output_spec = OutputSpec
+        _version = '0.10'
+        def _run_interface(self, runtime):
+            return runtime
+        def _list_outputs(self):
+            return {'foo': 1}
+    obj = DerivedInterface1()
+    yield assert_raises, KeyError, obj.run
+
 def test_Commandline():
     yield assert_raises, Exception, nib.CommandLine
     ci = nib.CommandLine(command='which')