Fix tutorials

.travis.yml

@@ -42,8 +42,9 @@ deploy:
   provider: pypi
   user: satra
   password:
-    secure: ZaN6Y4hfybPMi1rW3Qe03irCe/3GU4J4BJsjG+tClVN5Fjc3FCJaYU0k4wNd9q2kMjuRDv1efA9BN/5QasJS32oqs6wHvxzIWA18ucel4BBnAAkuviC1vqi/8Hk/DGB6e1gnmZ1Nv58zVLfn0MwlOKmsGDtvGQWc+HbaV2fS5NA=
+    secure: OCO0FXb4f+pH4Uw7zWCIRp3qOJ1t7rhky4K8MjNU8tyVCJgd6O/Bv8GJgceS0LktPodlAAjB8SxAhTORPAQZ1D/44PJYy3NQIisvej1zjLpaA9TEGfl6W7MqhDpRyMHW+cnSi/n84SAmdr+Z4vOxScDHdwr13EPmGyOIlHMAGnE=
   on:
     tags: true
     repo: nipy/nipype
     branch: master
+  distributions: "sdist bdist_wheel"

CHANGES

@@ -2,6 +2,8 @@ Next release
 ============
 
 * API: Change how hash values are computed (https://github.com/nipy/nipype/pull/1174)
+* ENH: New algorithm: mesh.WarpPoints applies displacements fields to point sets
+       (https://github.com/nipy/nipype/pull/889).
 * ENH: New interfaces for MRTrix3 (https://github.com/nipy/nipype/pull/1126)
 * ENH: New option in afni.3dRefit - zdel, ydel, zdel etc. (https://github.com/nipy/nipype/pull/1079)
 * FIX: ants.Registration composite transform outputs are no longer returned as lists (https://github.com/nipy/nipype/pull/1183)

doc/devel/cmd_interface_devel.rst

@@ -39,7 +39,11 @@ above example we have used the ``desc`` metadata which holds human readable
 description of the input. The ``mandatory`` flag forces Nipype to throw an
 exception if the input was not set. ``exists`` is a special flag that works only
 for ``File traits`` and checks if the provided file exists. More details can be
+<<<<<<< HEAD
 found at :doc:`interface_specs`.
+=======
+found at :ref:`interface_specs`.
+>>>>>>> cb80e24fc2a68758defcb16c7ab70092aa35b693
 
 The input and output specifications have to be connected to the our example
 interface class:
@@ -80,7 +84,7 @@ symbols. For an input defined in InputSpec to be included into the executed
 commandline ``argstr`` has to be included. Additionally inside the main
 interface class you need to specify the name of the executable by assigning it
 to the ``_cmd`` field. Also the main interface class needs to inherit from
-:class:`nipype.interfaces.base.CommandLine`:
+:class:`CommandLine <nipype.interfaces.base.CommandLine>`:
 
 .. testcode::
 
@@ -92,7 +96,7 @@ to the ``_cmd`` field. Also the main interface class needs to inherit from
 There is one more thing we need to take care of. When the executable finishes
 processing it will presumably create some output files. We need to know which
 files to look for, check if they exist and expose them to whatever node would
-like to use them. This is done by implementing ``_list_outputs`` method in the
+like to use them. This is done by implementing :func:`_list_outputs <nipype.interfaces.base.BaseInterface._list_outputs>` method in the
 main interface class. Basically what it does is assigning the expected output
 files to the fields of our output spec:
 

doc/devel/matlab_example1.py

@@ -0,0 +1,47 @@
+from nipype.interfaces.matlab import MatlabCommand
+from nipype.interfaces.base import TraitedSpec, \
+    BaseInterface, BaseInterfaceInputSpec, File
+import os
+from string import Template
+
+
+class ConmapTxt2MatInputSpec(BaseInterfaceInputSpec):
+    in_file = File(exists=True, mandatory=True)
+    out_file = File('cmatrix.mat', usedefault=True)
+
+
+class ConmapTxt2MatOutputSpec(TraitedSpec):
+    out_file = File(exists=True)
+
+
+class ConmapTxt2Mat(BaseInterface):
+    input_spec = ConmapTxt2MatInputSpec
+    output_spec = ConmapTxt2MatOutputSpec
+
+    def _run_interface(self, runtime):
+        d = dict(in_file=self.inputs.in_file,
+                 out_file=self.inputs.out_file)
+        # This is your MATLAB code template
+        script = Template("""in_file = '$in_file';
+                             out_file = '$out_file';
+                             ConmapTxt2Mat(in_file, out_file);
+                             exit;
+                          """).substitute(d)
+
+        # mfile = True  will create an .m file with your script and executed.
+        # Alternatively
+        # mfile can be set to False which will cause the matlab code to be
+        # passed
+        # as a commandline argument to the matlab executable
+        # (without creating any files).
+        # This, however, is less reliable and harder to debug
+        # (code will be reduced to
+        # a single line and stripped of any comments).
+        mlab = MatlabCommand(script=script, mfile=True)
+        result = mlab.run()
+        return result.runtime
+
+    def _list_outputs(self):
+        outputs = self._outputs().get()
+        outputs['out_file'] = os.path.abspath(self.inputs.out_file)
+        return outputs

doc/devel/matlab_example2.py

@@ -0,0 +1,54 @@
+from nipype.interfaces.base import traits
+from nipype.interfaces.base import TraitedSpec
+from nipype.interfaces.matlab import MatlabCommand, MatlabInputSpec
+
+
+class HelloWorldInputSpec(MatlabInputSpec):
+    name = traits.Str(mandatory=True,
+                      desc='Name of person to say hello to')
+
+
+class HelloWorldOutputSpec(TraitedSpec):
+    matlab_output = traits.Str()
+
+
+class HelloWorld(MatlabCommand):
+    """Basic Hello World that displays Hello <name> in MATLAB
+
+    Returns
+    -------
+
+    matlab_output : capture of matlab output which may be
+                    parsed by user to get computation results
+
+    Examples
+    --------
+
+    >>> hello = HelloWorld()
+    >>> hello.inputs.name = 'hello_world'
+    >>> out = hello.run()
+    >>> print out.outputs.matlab_output
+    """
+    input_spec = HelloWorldInputSpec
+    output_spec = HelloWorldOutputSpec
+
+    def _my_script(self):
+        """This is where you implement your script"""
+        script = """
+        disp('Hello %s Python')
+        two = 1 + 1
+        """ % (self.inputs.name)
+        return script
+
+    def run(self, **inputs):
+        # Inject your script
+        self.inputs.script = self._my_script()
+        results = super(MatlabCommand, self).run(**inputs)
+        stdout = results.runtime.stdout
+        # Attach stdout to outputs to access matlab results
+        results.outputs.matlab_output = stdout
+        return results
+
+    def _list_outputs(self):
+        outputs = self._outputs().get()
+        return outputs

doc/devel/matlab_interface_devel.rst

@@ -4,127 +4,39 @@
 How to wrap a MATLAB script
 ===========================
 
-This is minimal script for wrapping MATLAB code. You should replace the MATLAB
-code template, and define approriate inputs and outputs.
-
 
 Example 1
 +++++++++
 
-.. testcode::
-
-	from nipype.interfaces.matlab import MatlabCommand
-	from nipype.interfaces.base import TraitedSpec, BaseInterface, BaseInterfaceInputSpec, File
-	import os
-	from string import Template
-
-	class ConmapTxt2MatInputSpec(BaseInterfaceInputSpec):
-	    in_file = File(exists=True, mandatory=True)
-	    out_file = File('cmatrix.mat', usedefault=True)
-
-	class ConmapTxt2MatOutputSpec(TraitedSpec):
-	    out_file = File(exists=True)
-
-	class ConmapTxt2Mat(BaseInterface):
-	    input_spec = ConmapTxt2MatInputSpec
-	    output_spec = ConmapTxt2MatOutputSpec
-
-	    def _run_interface(self, runtime):
-	        d = dict(in_file=self.inputs.in_file,
-	        out_file=self.inputs.out_file)
-	        #this is your MATLAB code template
-	        script = Template("""in_file = ‘$in_file';
-	out_file = ‘$out_file';
-	ConmapTxt2Mat(in_file, out_file);
-	exit;
-	""").substitute(d)
-
-	        # mfile = True  will create an .m file with your script and executed.
-		# Alternatively
-	        # mfile can be set to False which will cause the matlab code to be
-		# passed
-	        # as a commandline argument to the matlab executable
-		# (without creating any files).
-	        # This, however, is less reliable and harder to debug
-		# (code will be reduced to
-	        # a single line and stripped of any comments).
-
-	        mlab = MatlabCommand(script=script, mfile=True)
-		result = mlab.run()
-	        return result.runtime
-
-	    def _list_outputs(self):
-	        outputs = self._outputs().get()
-	        outputs['out_file'] = os.path.abspath(self.inputs.out_file)
-	        return outputs
-
-
-Example 2
-+++++++++
-
-By subclassing **MatlabCommand** for your main class, and **MatlabInputSpec** for your input and output spec, you gain access to some useful MATLAB hooks
-
-.. testcode::
-
-	import os
-        from nipype.interfaces.base import File, traits
-        from nipype.interfaces.matlab import MatlabCommand, MatlabInputSpec
-
-
-        class HelloWorldInputSpec( MatlabInputSpec):
-            name = traits.Str( mandatory = True,
-                               desc = 'Name of person to say hello to')
-
-    	class HelloWorldOutputSpec( MatlabInputSpec):
-            matlab_output = traits.Str( )
-
-        class HelloWorld( MatlabCommand):
-            """ Basic Hello World that displays Hello <name> in MATLAB
-
-            Returns
-            -------
-
-            matlab_output : capture of matlab output which may be
-                            parsed by user to get computation results
-
-	    Examples
-	    --------
-
-            >>> hello = HelloWorld()
-            >>> hello.inputs.name = 'hello_world'
-            >>> out = hello.run()
-            >>> print out.outputs.matlab_output
-            """
-            input_spec = HelloWorldInputSpec
-            output_spec = HelloWorldOutputSpec
+This is a minimal script for wrapping MATLAB code. You should replace the MATLAB
+code template, and define approriate inputs and outputs.
 
-	    def _my_script(self):
-        	"""This is where you implement your script"""
-        	script = """
-        	disp('Hello %s Python')
-        	two = 1 + 1
-        	"""%(self.inputs.name)
-        	return script
+.. literalinclude:: matlab_example1.py
 
+.. admonition:: Example source code
 
-    	    def run(self, **inputs):
-        	## inject your script
-        	self.inputs.script =  self._my_script()
-        	results = super(MatlabCommand, self).run( **inputs)
-        	stdout = results.runtime.stdout
-        	# attach stdout to outputs to access matlab results
-        	results.outputs.matlab_output = stdout
-        	return results
+  You can download :download:`the source code of this example <matlab_example1.py>`.
 
+Example 2
++++++++++
 
-            def _list_outputs(self):
-                outputs = self._outputs().get()
-                return outputs
+By subclassing :class:`nipype.interfaces.matlab.MatlabCommand` for your main class, and :class:`nipype.interfaces.matlab.MatlabInputSpec` for your input spec, you gain access to some useful MATLAB hooks
+<<<<<<< HEAD
 
+.. literalinclude:: matlab_example2.py
 
+.. admonition:: Example source code
 
+  You can download :download:`the source code of this example <matlab_example2.py>`.
 
+.. include:: ../links_names.txt
+=======
 
+.. literalinclude:: matlab_example2.py
 
+.. admonition:: Example source code
 
+  You can download :download:`the source code of this example <matlab_example2.py>`.
+>>>>>>> cb80e24fc2a68758defcb16c7ab70092aa35b693
 
+.. include:: ../links_names.txt

doc/index.rst

@@ -2,6 +2,7 @@
 
  * -  .. image:: images/nipype_architecture_overview2.png
          :width: 100 %
+
    -  .. container::
 
         Current neuroimaging software offer users an incredible opportunity to
@@ -14,10 +15,10 @@
         to existing neuroimaging software and facilitates interaction between
         these packages within a single workflow. Nipype provides an environment
         that encourages interactive exploration of algorithms from different
-        packages (e.g., ANTS_, SPM_, FSL_, FreeSurfer_, Camino_, MRtrix_, MNE_, AFNI_,
+        packages (e.g., ANTS_, SPM_, FSL_, FreeSurfer_, Camino_, MRtrix_, MNE_, AFNI_, 
         Slicer_), eases the design of workflows within and between packages, and
         reduces the learning curve necessary to use different packages. Nipype is
-        creating a collaborative platform for neuroimaging software development
+        creating a collaborative platform for neuroimaging software development 
         in a high-level language and addressing limitations of existing pipeline
         systems.
 

doc/users/config_file.rst

@@ -115,10 +115,10 @@ Execution
     done after a job finish is detected. (float in seconds; default value: 5)
 
 *remove_node_directories (EXPERIMENTAL)*
-	Removes directories whose outputs have already been used
-	up. Doesn't work with IdentiInterface or any node that patches
-	data through (without copying) (possible values: ``true`` and
-	``false``; default value: ``false``)
+    Removes directories whose outputs have already been used
+    up. Doesn't work with IdentiInterface or any node that patches
+    data through (without copying) (possible values: ``true`` and
+    ``false``; default value: ``false``)
 
 *stop_on_unknown_version*
     If this is set to True, an underlying interface will raise an error, when no

doc/users/function_interface.rst

@@ -146,6 +146,6 @@ the string would be
 Unlike when using a function object, this input can be set like any other,
 meaning that you could write a function that outputs different function
 strings depending on some run-time contingencies, and connect that output
-the the ``function_str`` input of a downstream Function interface.
+the ``function_str`` input of a downstream Function interface.
 
 .. include:: ../links_names.txt

doc/users/interface_tutorial.rst

@@ -10,7 +10,7 @@ Specifying options
 The nipype interface modules provide a Python interface to external
 packages like FSL_ and SPM_.  Within the module are a series of Python
 classes which wrap specific package functionality.  For example, in
-the fsl module, the class :class:`nipype.interfaces.fsl.Bet` wraps the
+the :ref:`fsl <nipype.interfaces.fsl>` module, the class :ref:`BET <nipype.interfaces.fsl.preprocess.BET>` wraps the
 ``bet`` command-line tool.  Using the command-line tool, one would
 specify options using flags like ``-o``, ``-m``, ``-f <f>``, etc...
 However, in nipype, options are assigned to Python attributes and can