FIX: Disallow returning None in pipeline.utils.load_resultfile

Prevents #3009 and #3014 from happening - although this might not solve those issues,
this patch will help find their origin by making ``load_resultfile`` more strict (and
letting it raise exceptions).

The try .. except structure is moved to the only place is was being used within the Node code.

Author: oesteban

nipype/pipeline/engine/nodes.py

@@ -195,7 +195,7 @@ def interface(self):
     def result(self):
         """Get result from result file (do not hold it in memory)"""
         return _load_resultfile(
-            op.join(self.output_dir(), 'result_%s.pklz' % self.name))[0]
+            op.join(self.output_dir(), 'result_%s.pklz' % self.name))
 
     @property
     def inputs(self):
@@ -518,7 +518,7 @@ def _get_inputs(self):
             logger.debug('input: %s', key)
             results_file = info[0]
             logger.debug('results file: %s', results_file)
-            outputs = _load_resultfile(results_file)[0].outputs
+            outputs = _load_resultfile(results_file).outputs
             if outputs is None:
                 raise RuntimeError("""\
 Error populating the input "%s" of node "%s": the results file of the source node \
@@ -565,34 +565,42 @@ def _run_interface(self, execute=True, updatehash=False):
 
     def _load_results(self):
         cwd = self.output_dir()
-        result, aggregate, attribute_error = _load_resultfile(
-            op.join(cwd, 'result_%s.pklz' % self.name))
+
+        try:
+            result = _load_resultfile(
+                op.join(cwd, 'result_%s.pklz' % self.name))
+        except (traits.TraitError, EOFError):
+            logger.debug(
+                'Error populating inputs/outputs, (re)aggregating results...')
+        except (AttributeError, ImportError) as err:
+            logger.debug('attribute error: %s probably using '
+                         'different trait pickled file', str(err))
+            old_inputs = loadpkl(op.join(cwd, '_inputs.pklz'))
+            self.inputs.trait_set(**old_inputs)
+        else:
+            return result
+
         # try aggregating first
-        if aggregate:
-            logger.debug('aggregating results')
-            if attribute_error:
-                old_inputs = loadpkl(op.join(cwd, '_inputs.pklz'))
-                self.inputs.trait_set(**old_inputs)
-            if not isinstance(self, MapNode):
-                self._copyfiles_to_wd(linksonly=True)
-                aggouts = self._interface.aggregate_outputs(
-                    needed_outputs=self.needed_outputs)
-                runtime = Bunch(
-                    cwd=cwd,
-                    returncode=0,
-                    environ=dict(os.environ),
-                    hostname=socket.gethostname())
-                result = InterfaceResult(
-                    interface=self._interface.__class__,
-                    runtime=runtime,
-                    inputs=self._interface.inputs.get_traitsfree(),
-                    outputs=aggouts)
-                _save_resultfile(
-                    result, cwd, self.name,
-                    rebase=str2bool(self.config['execution']['use_relative_paths']))
-            else:
-                logger.debug('aggregating mapnode results')
-                result = self._run_interface()
+        if not isinstance(self, MapNode):
+            self._copyfiles_to_wd(linksonly=True)
+            aggouts = self._interface.aggregate_outputs(
+                needed_outputs=self.needed_outputs)
+            runtime = Bunch(
+                cwd=cwd,
+                returncode=0,
+                environ=dict(os.environ),
+                hostname=socket.gethostname())
+            result = InterfaceResult(
+                interface=self._interface.__class__,
+                runtime=runtime,
+                inputs=self._interface.inputs.get_traitsfree(),
+                outputs=aggouts)
+            _save_resultfile(
+                result, cwd, self.name,
+                rebase=str2bool(self.config['execution']['use_relative_paths']))
+        else:
+            logger.debug('aggregating mapnode results')
+            result = self._run_interface()
         return result
 
     def _run_command(self, execute, copyfiles=True):

nipype/pipeline/engine/utils.py

@@ -38,11 +38,12 @@
     write_rst_header,
     write_rst_dict,
     write_rst_list,
+    FileNotFoundError,
 )
 from ...utils.misc import str2bool
 from ...utils.functions import create_function_from_source
 from ...interfaces.base.traits_extension import (
-    rebase_path_traits, resolve_path_traits, OutputMultiPath, isdefined, Undefined, traits)
+    rebase_path_traits, resolve_path_traits, OutputMultiPath, isdefined, Undefined)
 from ...interfaces.base.support import Bunch, InterfaceResult
 from ...interfaces.base import CommandLine
 from ...interfaces.utility import IdentityInterface
@@ -281,38 +282,22 @@ def load_resultfile(results_file, resolve=True):
     Returns
     -------
     result : InterfaceResult structure
-    aggregate : boolean indicating whether node should aggregate_outputs
-    attribute error : boolean indicating whether there was some mismatch in
-        versions of traits used to store result and hence node needs to
-        rerun
 
     """
     results_file = Path(results_file)
-    aggregate = True
-    result = None
-    attribute_error = False
 
     if not results_file.exists():
-        return result, aggregate, attribute_error
+        raise FileNotFoundError(results_file)
 
     with indirectory(str(results_file.parent)):
-        try:
-            result = loadpkl(results_file)
-        except (traits.TraitError, EOFError):
-            logger.debug(
-                'some file does not exist. hence trait cannot be set')
-        except (AttributeError, ImportError) as err:
-            attribute_error = True
-            logger.debug('attribute error: %s probably using '
-                         'different trait pickled file', str(err))
-        else:
-            aggregate = False
+        result = loadpkl(results_file)
 
         if resolve and result.outputs:
             try:
                 outputs = result.outputs.get()
             except TypeError:  # This is a Bunch
-                return result, aggregate, attribute_error
+                logger.debug('Outputs object of loaded result %s is a Bunch.', results_file)
+                return result
 
             logger.debug('Resolving paths in outputs loaded from results file.')
             for trait_name, old in list(outputs.items()):
@@ -323,8 +308,7 @@ def load_resultfile(results_file, resolve=True):
                     value = resolve_path_traits(result.outputs.trait(trait_name), old,
                                                 results_file.parent)
                     setattr(result.outputs, trait_name, value)
-
-    return result, aggregate, attribute_error
+    return result
 
 
 def strip_temp(files, wd):