Merge branch 'master' of git://github.com/nipy/nipype into fix/nipypetest

Author: mgxd

doc/users/saving_workflows.rst

@@ -55,7 +55,7 @@ This will create a file "outputtestsave.py" with the following content:
 	from nipype.pipeline.engine import Workflow, Node, MapNode
 	from nipype.interfaces.utility import IdentityInterface
 	from nipype.interfaces.utility import Function
-	from nipype.utils.misc import getsource
+	from nipype.utils.functions import getsource
 	from nipype.interfaces.fsl.preprocess import BET
 	from nipype.interfaces.fsl.utils import ImageMaths
 	# Functions

nipype/interfaces/afni/preprocess.py

@@ -2929,6 +2929,17 @@ class QwarpInputSpec(AFNICommandInputSpec):
              '* You CAN use -resample with these 3dQwarp options:'
              '-plusminus  -inilev  -iniwarp  -duplo',
         argstr='-resample')
+    allineate = traits.Bool(
+        desc='This option will make 3dQwarp run 3dAllineate first, to align '
+             'the source dataset to the base with an affine transformation. '
+             'It will then use that alignment as a starting point for the '
+             'nonlinear warping.',
+        argstr='-allineate')
+    allineate_opts = traits.Str(
+        desc='add extra options to the 3dAllineate command to be run by '
+             '3dQwarp.',
+        argstr='-allineate_opts %s',
+        xand=['allineate'])
     nowarp = traits.Bool(
         desc='Do not save the _WARP file.',
         argstr='-nowarp')
@@ -3465,11 +3476,24 @@ class Qwarp(AFNICommand):
     >>> qwarp2.cmdline  # doctest: +ALLOW_UNICODE
     '3dQwarp -base mni.nii -blur 0.0 2.0 -source structural.nii -inilev 7 -iniwarp Q25_warp+tlrc.HEAD -prefix Q11'
     >>> res2 = qwarp2.run()  # doctest: +SKIP
-    """
+    >>> res2 = qwarp2.run()  # doctest: +SKIP
+    >>> qwarp3 = afni.Qwarp()
+    >>> qwarp3.inputs.in_file = 'structural.nii'
+    >>> qwarp3.inputs.base_file = 'mni.nii'
+    >>> qwarp3.inputs.allineate = True
+    >>> qwarp3.inputs.allineate_opts = '-cose lpa -verb'
+    >>> qwarp3.cmdline  # doctest: +ALLOW_UNICODE
+    "3dQwarp -allineate -allineate_opts '-cose lpa -verb' -base mni.nii -source structural.nii -prefix structural_QW"
+    >>> res3 = qwarp3.run()  # doctest: +SKIP    """
     _cmd = '3dQwarp'
     input_spec = QwarpInputSpec
     output_spec = QwarpOutputSpec
 
+    def _format_arg(self, name, spec, value):
+        if name == 'allineate_opts':
+            return spec.argstr % ("'" + value + "'")
+        return super(Qwarp, self)._format_arg(name, spec, value)
+
     def _list_outputs(self):
         outputs = self.output_spec().get()
 

nipype/interfaces/afni/tests/test_auto_Qwarp.py

@@ -8,6 +8,11 @@ def test_Qwarp_inputs():
     ),
     Qonly=dict(argstr='-Qonly',
     ),
+    allineate=dict(argstr='-allineate',
+    ),
+    allineate_opts=dict(argstr='-allineate_opts %s',
+    xand=['allineate'],
+    ),
     allsave=dict(argstr='-allsave',
     xor=['nopadWARP', 'duplo', 'plusminus'],
     ),

nipype/interfaces/fsl/epi.py

@@ -592,7 +592,7 @@ def _run_interface(self, runtime):
         cmd = self._cmd
         if all((FSLDIR != '',
                 cmd == 'eddy_openmp',
-                not os.path.exists(os.path.join(FSLDIR, cmd)))):
+                not os.path.exists(os.path.join(FSLDIR, 'bin', cmd)))):
             self._cmd = 'eddy'
         runtime = super(Eddy, self)._run_interface(runtime)
 

nipype/interfaces/utility/wrappers.py

@@ -24,7 +24,7 @@
                     BaseInterfaceInputSpec)
 from ..io import IOBase, add_traits
 from ...utils.filemanip import filename_to_list
-from ...utils.misc import getsource, create_function_from_source
+from ...utils.functions import getsource, create_function_from_source
 
 logger = logging.getLogger('interface')
 

nipype/pipeline/engine/nodes.py

@@ -633,7 +633,7 @@ def _run_command(self, execute, copyfiles=True):
             if copyfiles:
                 self._copyfiles_to_wd(cwd, execute)
 
-            message = 'Running node "%s" (a "%s" interface)'
+            message = 'Running node "%s" ("%s.%s")'
             if issubclass(self._interface.__class__, CommandLine):
                 try:
                     cmd = self._interface.cmdline
@@ -644,7 +644,7 @@ def _run_command(self, execute, copyfiles=True):
                 with open(cmdfile, 'wt') as fd:
                     print(cmd + "\n", file=fd)
                 message += ', a CommandLine Interface with command:\n%s' % cmd
-            logger.info(message + '.', self.name,
+            logger.info(message + '.', self.name, self._interface.__module__,
                         self._interface.__class__.__name__)
             try:
                 result = self._interface.run()

nipype/pipeline/engine/utils.py

@@ -29,7 +29,8 @@
 
 from ...utils.filemanip import (fname_presuffix, FileNotFoundError, to_str,
                                 filename_to_list, get_related_files)
-from ...utils.misc import create_function_from_source, str2bool
+from ...utils.misc import str2bool
+from ...utils.functions import create_function_from_source
 from ...interfaces.base import (CommandLine, isdefined, Undefined,
                                 InterfaceResult)
 from ...interfaces.utility import IdentityInterface
@@ -99,7 +100,7 @@ def _write_inputs(node):
                         lines[-1] = lines[-1].replace(' %s(' % funcname,
                                                       ' %s_1(' % funcname)
                         funcname = '%s_1' % funcname
-                    lines.append('from nipype.utils.misc import getsource')
+                    lines.append('from nipype.utils.functions import getsource')
                     lines.append("%s.inputs.%s = getsource(%s)" % (nodename,
                                                                    key,
                                                                    funcname))

nipype/pipeline/engine/workflows.py

@@ -36,8 +36,9 @@
 
 
 from ... import config, logging
-from ...utils.misc import (unflatten, str2bool,
-                               getsource, create_function_from_source)
+
+from ...utils.misc import (unflatten, str2bool)
+from ...utils.functions import (getsource, create_function_from_source)
 from ...interfaces.base import (traits, InputMultiPath, CommandLine,
                                 Undefined, TraitedSpec, DynamicTraitedSpec,
                                 Bunch, InterfaceResult, md5, Interface,

nipype/utils/functions.py

@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+"""
+Handles custom functions used in Function interface. Future imports
+are avoided to keep namespace as clear as possible.
+"""
+from builtins import next, str
+from future.utils import raise_from
+import inspect
+from textwrap import dedent
+
+def getsource(function):
+    """Returns the source code of a function"""
+    return dedent(inspect.getsource(function))
+
+
+def create_function_from_source(function_source, imports=None):
+    """Return a function object from a function source
+
+    Parameters
+    ----------
+    function_source : unicode string
+        unicode string defining a function
+    imports : list of strings
+        list of import statements in string form that allow the function
+        to be executed in an otherwise empty namespace
+    """
+    ns = {}
+    import_keys = []
+
+    try:
+        if imports is not None:
+            for statement in imports:
+                exec(statement, ns)
+            import_keys = list(ns.keys())
+        exec(function_source, ns)
+
+    except Exception as e:
+        msg = 'Error executing function\n{}\n'.format(function_source)
+        msg += ("Functions in connection strings have to be standalone. "
+                "They cannot be declared either interactively or inside "
+                "another function or inline in the connect string. Any "
+                "imports should be done inside the function.")
+        raise_from(RuntimeError(msg), e)
+    ns_funcs = list(set(ns) - set(import_keys + ['__builtins__']))
+    assert len(ns_funcs) == 1, "Function or inputs are ill-defined"
+    func = ns[ns_funcs[0]]
+    return func

nipype/utils/misc.py

@@ -3,7 +3,7 @@
 # vi: set ft=python sts=4 ts=4 sw=4 et:
 """Miscellaneous utility functions
 """
-from __future__ import print_function, division, unicode_literals, absolute_import
+from __future__ import print_function, unicode_literals, division, absolute_import
 from future import standard_library
 standard_library.install_aliases()
 from builtins import next, str
@@ -66,47 +66,6 @@ def trim(docstring, marker=None):
     return '\n'.join(trimmed)
 
 
-def getsource(function):
-    """Returns the source code of a function"""
-    src = dedent(inspect.getsource(function))
-    return src
-
-
-def create_function_from_source(function_source, imports=None):
-    """Return a function object from a function source
-
-    Parameters
-    ----------
-    function_source : pickled string
-        string in pickled form defining a function
-    imports : list of strings
-        list of import statements in string form that allow the function
-        to be executed in an otherwise empty namespace
-    """
-    ns = {}
-    import_keys = []
-    try:
-        if imports is not None:
-            for statement in imports:
-                exec(statement, ns)
-            import_keys = list(ns.keys())
-        exec(function_source, ns)
-
-    except Exception as e:
-        msg = '\nError executing function:\n %s\n' % function_source
-        msg += '\n'.join(["Functions in connection strings have to be standalone.",
-                          "They cannot be declared either interactively or inside",
-                          "another function or inline in the connect string. Any",
-                          "imports should be done inside the function"
-                          ])
-        raise_from(RuntimeError(msg), e)
-    ns_funcs = list(set(ns) - set(import_keys + ['__builtins__']))
-    assert len(ns_funcs) == 1, "Function or inputs are ill-defined"
-    funcname = ns_funcs[0]
-    func = ns[funcname]
-    return func
-
-
 def find_indices(condition):
     "Return the indices where ravel(condition) is true"
     res, = np.nonzero(np.ravel(condition))